{"version":3,"sources":["webpack:///./node_modules/core-js/internals/to-string-tag-support.js","webpack:///./node_modules/core-js/internals/function-bind-context.js","webpack:///./node_modules/core-js/internals/object-get-own-property-descriptor.js","webpack:///./node_modules/core-js/internals/ie8-dom-define.js","webpack:///./node_modules/core-js/internals/an-instance.js","webpack:///./node_modules/core-js/internals/html.js","webpack:///./node_modules/core-js/internals/a-function.js","webpack:///./node_modules/core-js/internals/check-correctness-of-iteration.js","webpack:///./node_modules/core-js/internals/engine-is-ios.js","webpack:///./node_modules/core-js/internals/require-object-coercible.js","webpack:///./node_modules/core-js/internals/array-method-has-species-support.js","webpack:///./node_modules/core-js/internals/iterate.js","webpack:///./node_modules/core-js/internals/to-absolute-index.js","webpack:///./node_modules/core-js/internals/export.js","webpack:///./node_modules/core-js/internals/object-get-own-property-names.js","webpack:///./node_modules/core-js/internals/set-species.js","webpack:///./node_modules/core-js/internals/task.js","webpack:///./node_modules/core-js/internals/engine-v8-version.js","webpack:///./node_modules/object-assign/index.js","webpack:///./node_modules/core-js/internals/engine-user-agent.js","webpack:///./node_modules/core-js/internals/get-iterator-method.js","webpack:///./node_modules/core-js/internals/object-define-properties.js","webpack:///./node_modules/core-js/internals/a-possible-prototype.js","webpack:///./node_modules/core-js/internals/iterators.js","webpack:///./node_modules/core-js/internals/path.js","webpack:///./node_modules/core-js/internals/indexed-object.js","webpack:///./node_modules/core-js/internals/add-to-unscopables.js","webpack:///./node_modules/core-js/internals/host-report-errors.js","webpack:///./node_modules/core-js/internals/species-constructor.js","webpack:///./node_modules/core-js/internals/native-symbol.js","webpack:///./node_modules/react-is/index.js","webpack:///./node_modules/core-js/internals/array-includes.js","webpack:///./node_modules/core-js/internals/to-length.js","webpack:///./node_modules/core-js/internals/has.js","webpack:///./node_modules/core-js/internals/shared.js","webpack:///./node_modules/core-js/internals/own-keys.js","webpack:///./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js","webpack:///./node_modules/core-js/internals/create-property-descriptor.js","webpack:///./node_modules/core-js/internals/object-assign.js","webpack:///./node_modules/core-js/internals/array-species-create.js","webpack:///./node_modules/core-js/internals/internal-state.js","webpack:///./node_modules/core-js/internals/redefine.js","webpack:///./node_modules/core-js/internals/object-get-own-property-symbols.js","webpack:///./node_modules/core-js/internals/enum-bug-keys.js","webpack:///./node_modules/core-js/internals/to-object.js","webpack:///./node_modules/core-js/internals/object-create.js","webpack:///./node_modules/core-js/internals/define-iterator.js","webpack:///./node_modules/core-js/internals/native-weak-map.js","webpack:///./node_modules/core-js/internals/an-object.js","webpack:///./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js","webpack:///./node_modules/core-js/internals/descriptors.js","webpack:///./node_modules/core-js/internals/create-property.js","webpack:///./node_modules/core-js/internals/is-object.js","webpack:///./node_modules/core-js/internals/inspect-source.js","webpack:///./node_modules/core-js/internals/uid.js","webpack:///./node_modules/core-js/internals/create-non-enumerable-property.js","webpack:///./node_modules/core-js/internals/is-forced.js","webpack:///./node_modules/core-js/modules/es.array.concat.js","webpack:///./node_modules/core-js/internals/call-with-safe-iteration-closing.js","webpack:///./node_modules/core-js/internals/object-define-property.js","webpack:///./node_modules/core-js/internals/create-iterator-constructor.js","webpack:///./node_modules/@vue/shared/dist/shared.esm-bundler.js","webpack:///./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js","webpack:///./node_modules/core-js/internals/to-integer.js","webpack:///./node_modules/core-js/modules/es.promise.finally.js","webpack:///./node_modules/react-is/cjs/react-is.production.min.js","webpack:///./node_modules/react/index.js","webpack:///./node_modules/core-js/internals/array-method-uses-to-length.js","webpack:///./node_modules/core-js/internals/iterators-core.js","webpack:///./node_modules/core-js/internals/microtask.js","webpack:///./node_modules/core-js/internals/well-known-symbol.js","webpack:///./node_modules/react/cjs/react.production.min.js","webpack:///./node_modules/core-js/internals/to-primitive.js","webpack:///./node_modules/core-js/internals/is-pure.js","webpack:///./node_modules/core-js/internals/classof-raw.js","webpack:///./node_modules/core-js/internals/shared-store.js","webpack:///(webpack)/buildin/global.js","webpack:///./node_modules/core-js/internals/object-keys-internal.js","webpack:///./node_modules/core-js/internals/document-create-element.js","webpack:///./node_modules/core-js/modules/es.object.assign.js","webpack:///./node_modules/core-js/internals/promise-resolve.js","webpack:///./node_modules/core-js/internals/set-global.js","webpack:///./node_modules/core-js/internals/hidden-keys.js","webpack:///./node_modules/core-js/internals/fails.js","webpack:///./node_modules/core-js/internals/get-built-in.js","webpack:///./node_modules/event-target-shim/dist/event-target-shim.mjs","webpack:///./node_modules/flatbuffers/js/flatbuffers.mjs","webpack:///./node_modules/text-encoding-utf-8/lib/encoding.lib.mjs","webpack:///./node_modules/apache-arrow/util/utf8.mjs","webpack:///./node_modules/apache-arrow/io/interfaces.mjs","webpack:///./node_modules/apache-arrow/util/compat.mjs","webpack:///./node_modules/apache-arrow/util/buffer.mjs","webpack:///./node_modules/apache-arrow/io/adapters.mjs","webpack:///./node_modules/apache-arrow/vector.mjs","webpack:///./node_modules/apache-arrow/fb/Schema.mjs","webpack:///./node_modules/apache-arrow/fb/Message.mjs","webpack:///./node_modules/apache-arrow/enum.mjs","webpack:///./node_modules/apache-arrow/util/bit.mjs","webpack:///./node_modules/apache-arrow/visitor.mjs","webpack:///./node_modules/apache-arrow/visitor/typecomparator.mjs","webpack:///./node_modules/apache-arrow/type.mjs","webpack:///./node_modules/apache-arrow/data.mjs","webpack:///./node_modules/apache-arrow/util/pretty.mjs","webpack:///./node_modules/apache-arrow/builder/valid.mjs","webpack:///./node_modules/apache-arrow/builder/buffer.mjs","webpack:///./node_modules/apache-arrow/builder.mjs","webpack:///./node_modules/apache-arrow/builder/bool.mjs","webpack:///./node_modules/apache-arrow/builder/null.mjs","webpack:///./node_modules/apache-arrow/builder/date.mjs","webpack:///./node_modules/apache-arrow/builder/decimal.mjs","webpack:///./node_modules/apache-arrow/builder/dictionary.mjs","webpack:///./node_modules/apache-arrow/builder/fixedsizebinary.mjs","webpack:///./node_modules/apache-arrow/util/math.mjs","webpack:///./node_modules/apache-arrow/builder/float.mjs","webpack:///./node_modules/apache-arrow/util/bn.mjs","webpack:///./node_modules/apache-arrow/builder/int.mjs","webpack:///./node_modules/apache-arrow/builder/time.mjs","webpack:///./node_modules/apache-arrow/builder/timestamp.mjs","webpack:///./node_modules/apache-arrow/builder/interval.mjs","webpack:///./node_modules/apache-arrow/builder/binary.mjs","webpack:///./node_modules/apache-arrow/builder/utf8.mjs","webpack:///./node_modules/apache-arrow/builder/run.mjs","webpack:///./node_modules/apache-arrow/vector/row.mjs","webpack:///./node_modules/apache-arrow/util/vector.mjs","webpack:///./node_modules/apache-arrow/vector/chunked.mjs","webpack:///./node_modules/apache-arrow/column.mjs","webpack:///./node_modules/apache-arrow/util/args.mjs","webpack:///./node_modules/apache-arrow/schema.mjs","webpack:///./node_modules/apache-arrow/builder/list.mjs","webpack:///./node_modules/apache-arrow/builder/fixedsizelist.mjs","webpack:///./node_modules/apache-arrow/builder/map.mjs","webpack:///./node_modules/apache-arrow/builder/struct.mjs","webpack:///./node_modules/apache-arrow/builder/union.mjs","webpack:///./node_modules/apache-arrow/visitor/set.mjs","webpack:///./node_modules/apache-arrow/visitor/builderctor.mjs","webpack:///./node_modules/apache-arrow/builder/index.mjs","webpack:///./node_modules/apache-arrow/fb/File.mjs","webpack:///./node_modules/apache-arrow/ipc/metadata/file.mjs","webpack:///./node_modules/apache-arrow/io/stream.mjs","webpack:///./node_modules/apache-arrow/io/file.mjs","webpack:///./node_modules/apache-arrow/util/int.mjs","webpack:///./node_modules/apache-arrow/visitor/vectorloader.mjs","webpack:///./node_modules/apache-arrow/visitor/typeassembler.mjs","webpack:///./node_modules/apache-arrow/ipc/metadata/json.mjs","webpack:///./node_modules/apache-arrow/ipc/metadata/message.mjs","webpack:///./node_modules/apache-arrow/ipc/message.mjs","webpack:///./node_modules/apache-arrow/visitor/vectorassembler.mjs","webpack:///./node_modules/apache-arrow/ipc/writer.mjs","webpack:///./node_modules/apache-arrow/util/recordbatch.mjs","webpack:///./node_modules/apache-arrow/vector/base.mjs","webpack:///./node_modules/apache-arrow/vector/binary.mjs","webpack:///./node_modules/apache-arrow/vector/bool.mjs","webpack:///./node_modules/apache-arrow/vector/date.mjs","webpack:///./node_modules/apache-arrow/vector/decimal.mjs","webpack:///./node_modules/apache-arrow/vector/dictionary.mjs","webpack:///./node_modules/apache-arrow/vector/fixedsizebinary.mjs","webpack:///./node_modules/apache-arrow/vector/fixedsizelist.mjs","webpack:///./node_modules/apache-arrow/vector/float.mjs","webpack:///./node_modules/apache-arrow/vector/interval.mjs","webpack:///./node_modules/apache-arrow/vector/int.mjs","webpack:///./node_modules/apache-arrow/vector/list.mjs","webpack:///./node_modules/apache-arrow/vector/map.mjs","webpack:///./node_modules/apache-arrow/vector/null.mjs","webpack:///./node_modules/apache-arrow/vector/struct.mjs","webpack:///./node_modules/apache-arrow/vector/timestamp.mjs","webpack:///./node_modules/apache-arrow/vector/time.mjs","webpack:///./node_modules/apache-arrow/vector/union.mjs","webpack:///./node_modules/apache-arrow/vector/utf8.mjs","webpack:///./node_modules/apache-arrow/util/fn.mjs","webpack:///./node_modules/apache-arrow/visitor/get.mjs","webpack:///./node_modules/apache-arrow/visitor/indexof.mjs","webpack:///./node_modules/apache-arrow/visitor/iterator.mjs","webpack:///./node_modules/apache-arrow/visitor/toarray.mjs","webpack:///./node_modules/apache-arrow/visitor/bytewidth.mjs","webpack:///./node_modules/apache-arrow/visitor/vectorctor.mjs","webpack:///./node_modules/apache-arrow/vector/index.mjs","webpack:///./node_modules/apache-arrow/table.mjs","webpack:///./node_modules/apache-arrow/recordbatch.mjs","webpack:///./node_modules/apache-arrow/ipc/reader.mjs","webpack:///./node_modules/apache-arrow/io/whatwg/iterable.mjs","webpack:///./node_modules/apache-arrow/io/whatwg/builder.mjs","webpack:///./node_modules/apache-arrow/io/whatwg/reader.mjs","webpack:///./node_modules/apache-arrow/io/whatwg/writer.mjs","webpack:///./node_modules/apache-arrow/compute/predicate.mjs","webpack:///./node_modules/apache-arrow/compute/dataframe.mjs","webpack:///./node_modules/apache-arrow/Arrow.dom.mjs","webpack:///./node_modules/streamlit-component-lib/dist/ArrowTable.js","webpack:///./node_modules/streamlit-component-lib/dist/streamlit.js","webpack:///./node_modules/streamlit-component-lib/dist/StreamlitReact.js","webpack:///./node_modules/core-js/internals/object-property-is-enumerable.js","webpack:///./node_modules/core-js/internals/object-set-prototype-of.js","webpack:///./node_modules/core-js/internals/set-to-string-tag.js","webpack:///./node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js","webpack:///./node_modules/core-js/internals/global.js","webpack:///./node_modules/core-js/internals/object-keys.js","webpack:///./node_modules/core-js/internals/object-get-prototype-of.js","webpack:///./node_modules/core-js/internals/correct-prototype-getter.js","webpack:///./node_modules/core-js/modules/es.array.iterator.js","webpack:///./node_modules/core-js/internals/redefine-all.js","webpack:///./node_modules/core-js/internals/perform.js","webpack:///./node_modules/core-js/modules/es.promise.js","webpack:///./node_modules/core-js/internals/copy-constructor-properties.js","webpack:///./node_modules/core-js/internals/is-array.js","webpack:///./node_modules/core-js/internals/is-array-iterator-method.js","webpack:///./node_modules/core-js/internals/new-promise-capability.js","webpack:///./node_modules/core-js/internals/classof.js","webpack:///./node_modules/core-js/internals/shared-key.js","webpack:///./node_modules/core-js/modules/es.array.slice.js","webpack:///./node_modules/core-js/internals/to-indexed-object.js","webpack:///./node_modules/core-js/internals/use-symbol-as-uid.js","webpack:///./node_modules/core-js/internals/native-promise-constructor.js"],"names":["wellKnownSymbol","TO_STRING_TAG","test","module","exports","String","aFunction","fn","that","length","undefined","call","a","b","c","apply","arguments","DESCRIPTORS","propertyIsEnumerableModule","createPropertyDescriptor","toIndexedObject","toPrimitive","has","IE8_DOM_DEFINE","nativeGetOwnPropertyDescriptor","Object","getOwnPropertyDescriptor","f","O","P","error","fails","createElement","defineProperty","get","it","Constructor","name","TypeError","getBuiltIn","ITERATOR","SAFE_CLOSING","called","iteratorWithReturn","next","done","this","Array","from","exec","SKIP_CLOSING","ITERATION_SUPPORT","object","userAgent","V8_VERSION","SPECIES","METHOD_NAME","array","constructor","foo","Boolean","anObject","isArrayIteratorMethod","toLength","bind","getIteratorMethod","callWithSafeIterationClosing","Result","stopped","result","iterate","iterable","AS_ENTRIES","IS_ITERATOR","iterator","iterFn","index","step","boundFunction","value","stop","toInteger","max","Math","min","integer","global","createNonEnumerableProperty","redefine","setGlobal","copyConstructorProperties","isForced","options","source","FORCED","target","key","targetProperty","sourceProperty","descriptor","TARGET","GLOBAL","STATIC","stat","prototype","noTargetGet","forced","sham","internalObjectKeys","enumBugKeys","hiddenKeys","concat","getOwnPropertyNames","definePropertyModule","CONSTRUCTOR_NAME","configurable","defer","channel","port","classof","html","IS_IOS","location","set","setImmediate","clear","clearImmediate","process","MessageChannel","Dispatch","counter","queue","ONREADYSTATECHANGE","run","id","hasOwnProperty","runner","listener","event","data","post","postMessage","protocol","host","args","i","push","Function","nextTick","now","port2","port1","onmessage","addEventListener","importScripts","appendChild","removeChild","setTimeout","match","version","versions","v8","split","getOwnPropertySymbols","propIsEnumerable","propertyIsEnumerable","toObject","val","shouldUseNative","assign","test1","test2","fromCharCode","order2","map","n","join","test3","forEach","letter","keys","err","symbols","to","s","Iterators","objectKeys","defineProperties","Properties","isObject","create","UNSCOPABLES","ArrayPrototype","console","defaultConstructor","S","C","Symbol","toAbsoluteIndex","createMethod","IS_INCLUDES","$this","el","fromIndex","includes","indexOf","argument","IS_PURE","store","mode","copyright","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","stack","warn","msg","instance","component","appWarnHandler","appContext","config","warnHandler","trace","getComponentTrace","callWithErrorHandling","proxy","vnode","formatComponentName","type","warnArgs","formatTrace","currentVNode","normalizedStack","last","recurseCount","parentInstance","parent","logs","entry","formatTraceEntry","postfix","isRoot","open","close","props","formatProps","res","slice","formatProp","raw","JSON","stringify","handleError","callWithAsyncErrorHandling","catch","values","contextVNode","cur","exposedInstance","errorInfo","errorCapturedHooks","ec","appErrorHandler","errorHandler","logError","postFlushCbs","resolvedPromise","Promise","resolve","currentFlushPromise","isFlushing","isFlushPending","flushIndex","pendingPostFlushCbs","pendingPostFlushIndex","p","then","queueJob","job","queueFlush","invalidateJob","queuePostFlushCb","cb","flushJobs","flushPostFlushCbs","seen","Set","getId","Infinity","sort","Map","currentRenderingInstance","setCurrentRenderingInstance","renderComponentRoot","Component","withProxy","slots","attrs","emit","render","renderCache","setupState","ctx","fallthroughAttrs","shapeFlag","proxyToUse","normalizeVNode","getFunctionalFallthrough","root","inheritAttrs","some","filterModelListeners","cloneVNode","scopeId","needScopeId","treeOwnerId","__scopeId","slotScopeId","extras","dirs","transition","createVNode","Comment","shouldUpdateComponent","prevVNode","nextVNode","optimized","prevProps","children","prevChildren","nextProps","nextChildren","patchFlag","$stable","hasPropsChanged","dynamicProps","nextKeys","updateHOCHostEl","subTree","isSuspense","__isSuspense","queueEffectWithSuspense","suspense","isResolved","effects","withCtx","owner","currentScopeId","scopeIdStack","pushScopeId","popScopeId","pop","withScopeId","isTeleport","__isTeleport","COMPONENTS","resolveComponent","resolveAsset","NULL_DYNAMIC_COMPONENT","warnMissing","currentInstance","selfName","displayName","registry","Fragment","Text","Static","blockStack","currentBlock","openBlock","disableTracking","shouldTrack","createBlock","dynamicChildren","isVNode","__v_isVNode","isSameVNodeType","n1","n2","InternalObjectKey","normalizeKey","normalizeRef","ref","_createVNode","isBlockNode","cloned","normalizeChildren","__vccOpts","class","klass","style","__v_skip","anchor","targetAnchor","staticCount","extraProps","mergedProps","mergeProps","createTextVNode","text","flag","createCommentVNode","asBlock","child","cloneIfMounted","default","slotFlag","_","_ctx","ret","toMerge","existing","incoming","handlerName","handler","startsWith","emitted","normalizeEmitsOptions","comp","__emits","emits","normalized","hasExtends","extends","mixins","m","isEmitListener","replace","toLowerCase","initProps","rawProps","isStateful","isSSR","setFullProps","updateProps","rawPrevProps","rawCurrentProps","normalizePropsOptions","kebabKey","resolvePropValue","propsToUpdate","camelizedKey","needCastKeys","camelKey","opt","hasDefault","defaultValue","__props","extendProps","normalizedKey","validatePropName","prop","booleanIndex","getTypeIndex","stringIndex","normalizedEntry","getType","ctor","toString","isSameType","expectedTypes","len","injectHook","hook","prepend","hooks","wrappedHook","__weh","isUnmounted","setCurrentInstance","unshift","createHook","lifecycle","isInSSRComponentSetup","onBeforeMount","onMounted","onBeforeUpdate","onUpdated","onBeforeUnmount","onUnmounted","onRenderTriggered","onRenderTracked","onErrorCaptured","useTransitionState","state","isMounted","isLeaving","isUnmounting","leavingVNodes","BaseTransitionImpl","appear","persisted","onBeforeEnter","onEnter","onAfterEnter","onEnterCancelled","onBeforeLeave","onLeave","onAfterLeave","onLeaveCancelled","onBeforeAppear","onAppear","onAfterAppear","onAppearCancelled","getCurrentInstance","prevTransitionKey","getTransitionRawChildren","emptyPlaceholder","innerChild","getKeepAliveChild","enterHooks","resolveTransitionHooks","oldChild","oldInnerChild","transitionKeyChanged","getTransitionKey","leavingHooks","setTransitionHooks","afterLeave","update","delayLeave","earlyRemove","delayedLeave","leavingVNodesCache","getLeavingNodesForType","_leaveCb","BaseTransition","callHook","leavingVNode","afterHook","cancelHook","_enterCb","cancelled","remove","isKeepAlive","keepComment","keyedFragmentCount","__isKeepAlive","RegExp","getName","matches","pattern","onActivated","registerKeepAliveHook","onDeactivated","__wdc","current","isDeactivated","injectToKeepAliveRoot","keepAliveRoot","resetShapeFlag","isInternalKey","normalizeSlotValue","normalizeSlot","rawSlot","normalizeObjectSlots","rawSlots","normalizeVNodeSlots","initSlots","updateSlots","needDeletionCheck","deletionComparisonTarget","invokeDirectiveHook","bindings","oldBindings","binding","oldValue","dir","devtools","devtoolsUnmountApp","app","createAppContext","isNativeTag","performance","globalProperties","optionMergeStrategies","isCustomElement","components","directives","provides","createAppAPI","hydrate","rootComponent","rootProps","context","installedPlugins","_component","_props","_container","_context","v","plugin","install","add","mixin","directive","rootContainer","isHydrate","__vue_app__","hasMismatch","isSVGContainer","container","namespaceURI","tagName","isComment","node","nodeType","createHydrationFunctions","rendererInternals","mt","mountComponent","patch","o","patchProp","nextSibling","parentNode","insert","createComment","hydrateNode","firstChild","parentComponent","parentSuspense","isFragmentStart","onMismatch","handleMismatch","domType","nextNode","needToAdoptContent","outerHTML","hydrateFragment","hydrateElement","hydrateComponent","loadAsync","__asyncLoader","locateClosingAsyncAnchor","hydrateChildren","setRef","onClick","vnodeHooks","onVnodeBeforeMount","invokeVNodeHook","onVnodeMounted","innerHTML","textContent","l","isFragment","end","initFeatureFlags","prodEffectOptions","scheduler","queuePostRenderEffect","rawRef","oldRawRef","oldRef","refs","createRenderer","baseCreateRenderer","createHydrationRenderer","createHydrationFns","hostInsert","hostRemove","hostPatchProp","forcePatchProp","hostForcePatchProp","hostCreateElement","createText","hostCreateText","hostCreateComment","setText","hostSetText","setElementText","hostSetElementText","hostParentNode","hostNextSibling","setScopeId","hostSetScopeId","cloneNode","hostCloneNode","insertStaticContent","hostInsertStaticContent","isSVG","getNextHostNode","unmount","processText","processCommentNode","mountStaticNode","processFragment","processElement","processComponent","internals","mountElement","patchElement","vnodeHook","is","mountChildren","unmountChildren","beforeEnter","needCallTransitionHooks","enter","start","oldProps","newProps","onVnodeBeforeUpdate","patchProps","prev","areChildrenSVG","patchBlockChildren","patchChildren","onVnodeUpdated","oldChildren","newChildren","fallbackContainer","oldVNode","newVNode","fragmentStartAnchor","fragmentEndAnchor","activate","updateComponent","initialVNode","createComponentInstance","renderer","setupComponent","asyncDep","registerDep","setupRenderEffect","placeholder","asyncResolved","updateComponentPreRender","bu","u","originNext","nextTree","prevTree","bm","c1","prevShapeFlag","c2","patchKeyedChildren","patchUnkeyedChildren","oldLength","newLength","commonLength","nextChild","parentAnchor","l2","e1","e2","nextPos","s1","s2","keyToNewIndexMap","j","patched","toBePatched","moved","maxNewIndexSoFar","newIndexToOldIndexMap","prevChild","newIndex","increasingNewIndexSequence","getSequence","nextIndex","move","moveType","needTransition","leave","performLeave","doRemove","deactivate","shouldInvokeDirs","onVnodeBeforeUnmount","unmountComponent","onVnodeUnmounted","removeFragment","performRemove","bum","um","da","deps","_vnode","r","mc","pc","pbc","createApp","arr","arrI","watchEffect","effect","doWatch","INITIAL_WATCHER_VALUE","watch","immediate","deep","flush","onTrack","onTrigger","getter","cleanup","traverse","onInvalidate","baseGetter","onStop","active","newValue","lazy","recordInstanceBoundEffect","instanceWatch","publicThis","provide","parentProvides","inject","applyOptions","deferredData","deferredWatch","asMixin","extendsOptions","dataOptions","computed","computedOptions","methods","watchOptions","provideOptions","injectOptions","beforeMount","mounted","beforeUpdate","updated","activated","deactivated","beforeUnmount","unmounted","renderTracked","renderTriggered","errorCaptured","globalMixins","callSyncHook","applyMixins","methodHandler","resolveData","dataFn","enumerable","createWatcher","callHookFromMixins","baseHook","selfHook","resolveMergedOptions","__merged","mergeOptions","strats","publicPropertiesMap","$","$el","$data","$props","$attrs","$slots","$refs","$parent","$root","$emit","$options","$forceUpdate","$nextTick","$watch","PublicInstanceProxyHandlers","accessCache","normalizedProps","publicGetter","cssModule","__cssModules","RuntimeCompiledPublicInstanceProxyHandlers","unscopables","emptyAppContext","uid","setupContext","bc","rtg","rtc","compile","setupResult","setupStatefulComponent","Proxy","setup","createSetupContext","resolvedResult","handleSetupResult","finishComponentSetup","template","delimiters","_rc","classifyRE","classify","str","toUpperCase","__file","inferFromRegistry","getterOrOptions","defineComponent","h","propsOrChildren","renderList","renderItem","renderSlot","fallback","slot","bitmap","writable","IndexedObject","nativeAssign","A","B","symbol","alphabet","chr","T","argumentsLength","isArray","originalArray","NATIVE_WEAK_MAP","objectHas","sharedKey","WeakMap","enforce","getterFor","TYPE","wmget","wmhas","wmset","metadata","STATE","inspectSource","InternalStateModule","getInternalState","enforceInternalState","TEMPLATE","unsafe","simple","requireObjectCoercible","activeXDocument","documentCreateElement","GT","LT","PROTOTYPE","SCRIPT","IE_PROTO","EmptyConstructor","scriptTag","content","NullProtoObjectViaActiveX","write","temp","parentWindow","NullProtoObjectViaIFrame","iframeDocument","iframe","JS","display","src","contentWindow","document","F","NullProtoObject","domain","ActiveXObject","createIteratorConstructor","getPrototypeOf","setPrototypeOf","setToStringTag","IteratorsCore","IteratorPrototype","BUGGY_SAFARI_ITERATORS","KEYS","VALUES","ENTRIES","returnThis","Iterable","NAME","IteratorConstructor","DEFAULT","IS_SET","CurrentIteratorPrototype","KEY","getIterationMethod","KIND","defaultIterator","IterablePrototype","INCORRECT_VALUES_NAME","nativeIterator","anyNativeIterator","entries","proto","svgNS","doc","tempContainer","tempSVGContainer","nodeOps","insertBefore","tag","createElementNS","createTextNode","nodeValue","querySelector","selector","setAttribute","first","patchClass","transitionClasses","_vtc","className","patchStyle","cssText","setStyle","removeAttribute","importantRE","setProperty","prefixed","autoPrefix","prefixes","prefixCache","rawName","cached","xlinkNS","patchAttr","removeAttributeNS","setAttributeNS","isBoolean","patchDOMProp","_value","e","_getNow","Date","createEvent","timeStamp","cachedNow","reset","getNow","removeEventListener","patchEvent","prevValue","nextValue","invoker","parseName","createInvoker","optionsModifierRE","initialValue","attached","patchStopImmediatePropagation","originalStop","stopImmediatePropagation","_stopped","nativeOnRE","shouldSetAsProp","_trueValue","_falseValue","TRANSITION","ANIMATION","Transition","resolveTransitionProps","DOMTransitionPropsValidators","css","duration","Number","enterFromClass","enterActiveClass","enterToClass","appearFromClass","appearActiveClass","appearToClass","leaveFromClass","leaveActiveClass","leaveToClass","baseProps","durations","normalizeDuration","enterDuration","leaveDuration","finishEnter","isAppear","removeTransitionClass","finishLeave","makeEnterHook","nextFrame","addTransitionClass","whenTransitionEnds","NumberOf","cls","classList","delete","size","requestAnimationFrame","expectedType","timeout","propCount","getTransitionInfo","endEvent","ended","onEnd","styles","window","getComputedStyle","getStyleProperties","transitionDelays","transitionDurations","transitionTimeout","getTimeout","animationDelays","animationDurations","animationTimeout","hasTransform","delays","d","toMs","rendererOptions","ensureRenderer","mount","containerOrSelector","normalizeContainer","propertyKey","functionToString","random","replacement","feature","detection","normalize","POLYFILL","NATIVE","string","createProperty","arraySpeciesCreate","arrayMethodHasSpeciesSupport","IS_CONCAT_SPREADABLE","MAX_SAFE_INTEGER","MAXIMUM_ALLOWED_INDEX_EXCEEDED","IS_CONCAT_SPREADABLE_SUPPORT","SPECIES_SUPPORT","isConcatSpreadable","spreadable","arg","k","E","returnMethod","nativeDefineProperty","Attributes","makeMap","expectsLowerCase","list","GLOBALS_WHITE_LISTED","isGloballyWhitelisted","specialBooleanAttrs","isSpecialBooleanAttr","normalizeStyle","item","isString","parseStringStyle","listDelimiterRE","propertyDelimiterRE","tmp","trim","normalizeClass","HTML_TAGS","SVG_TAGS","isHTMLTag","isSVGTag","looseCompareArrays","equal","looseEqual","aValidType","isDate","bValidType","getTime","aKeysCount","bKeysCount","aHasKey","bHasKey","looseIndexOf","findIndex","toDisplayString","replacer","_key","reduce","isPlainObject","EMPTY_OBJ","EMPTY_ARR","NOOP","NO","onRE","isOn","isModelListener","extend","splice","hasOwn","isFunction","isSymbol","isPromise","objectToString","toTypeString","toRawType","isReservedProp","cacheStringFunction","cache","hit","camelizeRE","camelize","hyphenateRE","hyphenate","capitalize","charAt","hasChanged","invokeArrayFns","fns","def","obj","toNumber","parseFloat","isNaN","targetMap","effectStack","activeEffect","ITERATE_KEY","MAP_KEY_ITERATE_KEY","isEffect","_isEffect","createReactiveEffect","enableTracking","resetTracking","trackStack","pauseTracking","track","depsMap","dep","trigger","oldTarget","effectsToAdd","isAddOrDelete","builtInSymbols","filter","createGetter","shallowGet","readonlyGet","shallowReadonlyGet","arrayInstrumentations","isReadonly","shallow","receiver","targetIsArray","Reflect","isRef","readonly","reactive","toRaw","createSetter","shallowSet","hadKey","deleteProperty","ownKeys","mutableHandlers","readonlyHandlers","shallowReactiveHandlers","toReactive","toReadonly","toShallow","getProto","get$1","wrap","rawKey","has$1","set$1","deleteEntry","del","hadItems","createForEach","callback","thisArg","observed","wrappedCallback","createIterableMethod","method","isMap","isPair","isKeyOnly","innerIterator","createReadonlyMethod","mutableInstrumentations","shallowInstrumentations","readonlyInstrumentations","iteratorMethods","createInstrumentationGetter","instrumentations","mutableCollectionHandlers","shallowCollectionHandlers","readonlyCollectionHandlers","collectionTypes","WeakSet","isObservableType","canObserve","isFrozen","createReactiveObject","shallowReactive","baseHandlers","collectionHandlers","reactiveFlag","isReactive","isProxy","convert","__v_isRef","createRef","rawValue","newVal","unref","shallowUnwrapHandlers","proxyRefs","objectWithRefs","setter","dirty","ceil","floor","NativePromise","speciesConstructor","promiseResolve","NON_GENERIC","real","onFinally","x","for","g","q","t","w","y","z","$$typeof","AsyncMode","ConcurrentMode","ContextConsumer","ContextProvider","Element","ForwardRef","Lazy","Memo","Portal","Profiler","StrictMode","Suspense","isAsyncMode","isConcurrentMode","isContextConsumer","isContextProvider","isElement","isForwardRef","isLazy","isMemo","isPortal","isProfiler","isStrictMode","isValidElementType","typeOf","thrower","ACCESSORS","argument0","argument1","PrototypeOfArrayIteratorPrototype","arrayIterator","head","notify","toggle","promise","macrotask","MutationObserver","WebKitMutationObserver","IS_NODE","queueMicrotaskDescriptor","queueMicrotask","exit","observe","characterData","task","shared","NATIVE_SYMBOL","USE_SYMBOL_AS_UID","WellKnownSymbolsStore","createWellKnownSymbol","withoutSetter","encodeURIComponent","D","enqueueForceUpdate","enqueueReplaceState","enqueueSetState","updater","G","H","isReactComponent","setState","Error","forceUpdate","I","isPureReactComponent","J","K","L","__self","__source","M","defaultProps","_owner","N","escape","Q","R","keyPrefix","func","count","U","V","W","aa","X","Y","Z","ba","ReactCurrentDispatcher","ReactCurrentBatchConfig","ReactCurrentOwner","IsSomeRendererActing","Children","toArray","only","PureComponent","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","cloneElement","createContext","_calculateChangedBits","_currentValue","_currentValue2","_threadCount","Provider","Consumer","createFactory","forwardRef","isValidElement","_ctor","_status","_result","memo","compare","useCallback","useContext","useDebugValue","useEffect","useImperativeHandle","useLayoutEffect","useMemo","useReducer","useRef","useState","input","PREFERRED_STRING","valueOf","SHARED","names","EXISTS","newPromiseCapability","promiseCapability","path","variable","namespace","privateData","wrappers","pd","retv","assert","setCancelFlag","passiveListener","cancelable","canceled","preventDefault","Event","eventTarget","eventPhase","currentTarget","immediateStopped","defineRedirectDescriptor","defineCallDescriptor","defineWrapper","BaseEvent","CustomEvent","isFunc","getWrapper","wrapper","wrapEvent","Wrapper","isStopped","setEventPhase","setCurrentTarget","setPassiveListener","stopPropagation","bubbles","composed","cancelBubble","listenersMap","CAPTURE","BUBBLE","ATTRIBUTE","getListeners","listeners","defineEventAttributeDescriptor","eventName","listenerType","newNode","passive","once","defineEventAttribute","eventTargetPrototype","defineCustomEventTarget","eventNames","CustomEventTarget","EventTarget","types","optionsIsObj","capture","wrappedEvent","handleEvent","defaultPrevented","flatbuffers","inRange","ToDictionary","stringToCodePoints","charCodeAt","codePointsToString","code_points","cp","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","capacity","forceDefaults","dataBuffer","asUint8Array","bytes","subarray","position","offset","prep","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","addFieldInt16","addFieldInt32","addFieldInt64","addFieldFloat32","addFieldFloat64","addFieldOffset","addOffset","addFieldStruct","nested","notNested","new_buf_size","nbb","setPosition","startObject","numfields","endObject","vtableloc","trimmed_size","standard_fields","existing_vtable","vt1","outer_loop","vt2","readInt16","finish","root_table","opt_file_identifier","file_identifier","requiredField","table","field","table_start","vtable_start","readInt32","ok","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","__offset","bb_pos","vtable_offset","__union","__string","opt_encoding","__indirect","__vector","__vector_len","__has_identifier","ident","end_of_stream","Stream","tokens","endOfStream","read","shift","token","finished","decoderError","fatal","opt_code_point","Decoder","Encoder","stream","bite","code_point","DEFAULT_ENCODING","encoding","_streaming","_BOMseen","_decoder","_fatal","_ignoreBOM","_encoder","_options","UTF8Decoder","utf8_code_point","utf8_bytes_seen","utf8_bytes_needed","utf8_lower_boundary","utf8_upper_boundary","UTF8Encoder","decode","ArrayBuffer","byteOffset","byteLength","input_stream","encode","opt_string","_Buffer","Buffer","useNativeEncoders","TextDecoder","TextEncoder","decodeUtf8","decoder","toUint8Array","encodeUtf8","encoder","ITERATOR_DONE","freeze","ArrowJSON","_json","ReadableInterop","_getDOMStream","tee","_getNodeStream","pipe","pipeTo","duplex","pipeThrough","_DOMStream","toDOMStream","_nodeStream","toNodeStream","super","_values","resolvers","_closedPromise","_closedPromiseResolve","reason","return","_ensureOpen","_error","reject","asyncIterator","abort","_args","BigIntCtor","BigIntAvailable","BigIntUnavailableError","BigIntUnavailable","asIntN","asUintN","BigInt","BigInt64ArrayCtor","BigInt64ArrayAvailable","BigInt64ArrayUnavailableError","BigInt64ArrayUnavailable","BigInt64Array","BigUint64ArrayCtor","BigUint64ArrayAvailable","BigUint64ArrayUnavailableError","BigUint64ArrayUnavailable","BigUint64Array","isNumber","isIterable","isAsyncIterable","isArrowJSON","isIteratorResult","isFileHandle","isFetchResponse","isReadableDOMStream","isWritableDOMStream","isWritableNodeStream","isReadableNodeStream","SharedArrayBuf","SharedArrayBuffer","collapseContiguousByteRanges","chunks","xOffset","yOffset","xLen","yLen","memcpy","targetByteOffset","sourceByteLength","targetByteLength","dst","joinUint8Arrays","sliced","toArrayBufferView","ArrayBufferViewCtor","isView","BYTES_PER_ELEMENT","toInt8Array","Int8Array","toInt16Array","Int16Array","toInt32Array","toBigInt64Array","toUint16Array","toUint32Array","Uint32Array","toBigUint64Array","toFloat32Array","toFloat64Array","toUint8ClampedArray","Uint8ClampedArray","pump","toArrayBufferViewIterator","ArrayCtor","buffers","toInt8ArrayIterator","toInt16ArrayIterator","toInt32ArrayIterator","toUint8ArrayIterator","toUint16ArrayIterator","toUint32ArrayIterator","toFloat32ArrayIterator","toFloat64ArrayIterator","toUint8ClampedArrayIterator","async","toArrayBufferViewAsyncIterator","toInt8ArrayAsyncIterator","toInt16ArrayAsyncIterator","toInt32ArrayAsyncIterator","toUint8ArrayAsyncIterator","toUint16ArrayAsyncIterator","toUint32ArrayAsyncIterator","toFloat32ArrayAsyncIterator","toFloat64ArrayAsyncIterator","toUint8ClampedArrayAsyncIterator","rebaseValueOffsets","valueOffsets","compareArrayLike","fromIterable","fromAsyncIterable","fromDOMStream","fromNodeStream","cmd","threw","bufferLength","byteRange","throw","releaseLock","byobReader","defaultReader","supportsBYOB","reader","getBYOBReader","getDefaultReader","readFromBYOBReader","readInto","onEvent","events","race","isFinite","evt","destroy","AbstractVector","org","apache","arrow","flatbuf","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","indexTypeOffset","isOrdered","startDictionaryEncoding","addId","addIndexType","addIsOrdered","endDictionaryEncoding","Field","NONE","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","headerType","headerOffset","bodyLength","startMessage","addVersion","addHeaderType","addHeader","addBodyLength","endMessage","BufferType","getBool","_data","_index","byte","bit","getBit","setBool","truncateBitmap","alignedSize","packBools","iterateBits","xs","begin","byteIndex","remaining","popcnt_bit_range","lhs","rhs","sum","rhsInside","lhsInside","popcnt_array","cnt","pos","view","DataView","popcnt_uint32","getUint32","getUint16","getUint8","uint32","Visitor","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","compareFixedSizeBinary","compareDate","compareTimestamp","timezone","compareTime","compareList","compareStruct","compareUnion","typeIds","compareDictionary","indices","dictionary","compareInterval","compareFixedSizeList","compareMap","toStringTag","ArrayType","valueType","typeIdToChildIndex","idx","atomicDictionaryId","strideForType","kUnknownNullCount","nullCount","childData","_nullCount","stride","nullBitmap","childStride","_sliceBuffers","clone","_sliceChildren","fill","VALIDITY","OFFSET","DATA","valueOffsetsOrChildren","undf","valueToString","createIsValidFunction","nullValues","fnBody","noNaNs","valueToCase","roundLengthUpToNearest64Bytes","BPE","sliceOrExtendArray","_resize","extra","reserved","DataBufferBuilder","reserve","BitmapBufferBuilder","numValid","OffsetsBufferBuilder","_ArrayType64","buffer64","ArrayType64","nulls","_nulls","_isValid","throughIterable","throughAsyncIterable","new","numInvalid","_offsets","_typeIds","reservedLength","reservedByteLength","setValid","isValid","setValue","_setValue","valid","numChildren","offsets","opts","_pendingLength","pending","_pending","_flush","pendingLength","_flushPending","queueingStrategy","highWaterMark","sizeProperty","numChunks","append","toVector","DateDayBuilder","DateMillisecondBuilder","hashFn","_dictionaryOffset","_keysToIndices","valueToKey","keysToIndices","_dictionary","curr","f64","u32","uint16ToFloat64","expo","sigf","sign","NaN","float64ToUint16","Float32Builder","Float64Builder","isArrowBigNumSymbol","BigNum","SignedBigNum","UnsignedBigNum","DecimalBigNum","bignumToNumber","bn","hi","lo","signed","words","number","bignumToString","bignumToBigInt","decimalToString","digits","base64","base32","checks","reverse","toJSON","hint","num","Int8Builder","Int16Builder","Int32Builder","toBigInt","Uint8Builder","Uint16Builder","Uint32Builder","TimeSecondBuilder","TimeMillisecondBuilder","TimeMicrosecondBuilder","TimeNanosecondBuilder","TimestampSecondBuilder","TimestampMillisecondBuilder","TimestampMicrosecondBuilder","TimestampNanosecondBuilder","IntervalDayTimeBuilder","IntervalYearMonthBuilder","kParent","kRowIndex","kKeyToIdx","kIdxToVal","kCustomInspect","numKeys","ktoi","itov","getValue","getIndex","ki","vi","kr","vr","callbackfn","MapRow","createRowProxy","getChildAt","StructRow","defineRowProxyProperties","desc","row","getKey","RowProxyHandler","clampIndex","adjust","clampRange","big0","isNaNFast","createElementComparator","search","typeofSearch","valueOfSearch","creatMapComparator","createArrayLikeComparator","createVectorComparator","createObjectComparator","comparators","createSubElementsComparator","compareArray","compareObject","compareVector","vec","lKeyItr","rKeyItr","rValItr","rVal","lKey","rKey","calculateOffsets","_type","_chunks","_chunkOffsets","_length","_numChildren","vectors","selectChunkArgs","flatten","chunk","isDictionary","_indices","_sliceInternal","columns","_children","vector","mid","isValidInternal","getInternal","element","self","indexOfInternal","arraySet","typedSet","chunkIndex","found","slices","chunkOffsets","chunkLength","chunkOffset","_field","SingleChunkColumn","rest","column","_chunk","selectArgs","Ctor","vals","_selectArgs","selectColumnArgs","_selectFieldArgs","selectFieldArgs","_selectChunkArgs","selectVectorChildrenArgs","_selectVectorChildrenArgs","toKeysAndValues","fieldIndex","valueIndex","dictionaries","generateDictionaryMap","compareSchemas","columnNames","columnIndices","curFields","mergeMaps","newFields","f2","newDictionaries","m1","m2","_run","childIndex","_valueToChildTypeId","childTypeId","SparseUnionBuilder","setEpochMsToDays","epochMs","setEpochMsToMillisecondsLong","setEpochMsToMicrosecondsLong","setEpochMsToNanosecondsLong","setVariableWidthBytes","setDateDay","setDateMillisecond","setNumeric","setFloat16","setNumericX2","values64","long","setFixedSizeBinary","setBinary","setUtf8","setInt","setFloat","setDate","setTimestampSecond","setTimestampMillisecond","setTimestampMicrosecond","setTimestampNanosecond","setTimestamp","setTimeSecond","setTimeMillisecond","setTimeMicrosecond","setTimeNanosecond","setTime","setDecimal","setList","itr","setMap","_setStructArrayValue","_setStructVectorValue","_setStructMapValue","_setStructObjectValue","setStruct","setUnion","setDenseUnion","setSparseUnion","setDictionary","setIntervalValue","setIntervalDayTime","setIntervalYearMonth","setFixedSizeList","newBuilder","defaultOptions","getChildOptions","BuilderCtor","Footer","Block","schemaOffset","dictionariesOffset","recordBatchesOffset","startFooter","addSchema","addDictionaries","addRecordBatches","endFooter","metaDataLength","_Block","_Footer","V4","recordBatches","dictionaryBatches","_recordBatches","_dictionaryBatches","buf","footer","getRootAsFooter","OffHeapFooter","startRecordBatchesVector","numRecordBatches","rb","FileBlock","startDictionariesVector","numDictionaries","db","dictionaryBatchesOffset","finishFooterBuffer","block","getRecordBatch","getDictionaryBatch","_footer","recordBatchesLength","dictionariesLength","fileBlock","sync","peek","body","closed","cancel","readAt","getInt32","nBytes","file","_handle","bytesRead","carryBit16","intAsHex","kInt32DecimalDigits","kPowersOfTen","BaseInt64","product","lessThan","_times","_plus","out_buffer","fromString","out","posn","group","parseInt","substr","multiple","times","plus","left","right","rtrn","this_high","other_high","negate","Int128","L0","L1","L2","L3","R0","R1","R2","R3","multiply","sums","nodesIndex","buffersIndex","nextFieldNode","readNullBitmap","readData","readOffsets","visitMany","readTypeIds","readDictionary","nextBufferRange","sources","isTimestamp","isInt","isTime","convertArray","isDecimal","isBinary","isFixedSizeBinary","binaryDataFromJSON","isBool","isUtf8","joined","startTypeIdsVector","createTypeIdsVector","indexType","schemaFromJSON","_schema","schemaFieldsFromJSON","customMetadataFromJSON","recordBatchFromJSON","fieldNodesFromJSON","buffersFromJSON","dictionaryBatchFromJSON","fromJSON","fieldChildrenFromJSON","fieldNodes","nullCountFromJSON","BufferRegion","validity","fieldFromJSON","dictMeta","dictType","indexTypeFromJSON","typeFromJSON","_metadata","_Field","_Schema","_Message","_KeyValue","_FieldNode","_Endianness","_RecordBatch","_DictionaryBatch","header","_version","_headerType","_createHeader","_bodyLength","message","messageHeaderFromJSON","_message","getRootAsMessage","decodeMessageHeader","isSchema","isRecordBatch","isDictionaryBatch","finishMessageBuffer","_nodes","_buffers","_id","_isDelta","decodeSchema","decodeSchemaFields","decodeCustomMetadata","decodeRecordBatch","batch","decodeFieldNodes","decodeBuffers","decodeDictionaryBatch","decodeBufferRegion","decodeFieldNode","nodesLength","bufferRegions","buffersLength","fieldsLength","decodeFieldChildren","childrenLength","decodeField","decodeIndexType","decodeFieldType","customMetadataLength","customMetadata","typeIdsArray","encodeSchema","fieldOffsets","startFieldsVector","fieldsVectorOffset","createFieldsVector","metadataOffset","createCustomMetadataVector","platformIsLittleEndian","Big","encodeField","childOffsets","childrenVectorOffset","createChildrenVector","encodeRecordBatch","recordBatch","startNodesVector","nodesVectorOffset","startBuffersVector","b_","buffersVectorOffset","encodeDictionaryBatch","dictionaryBatch","encodeFieldNode","createFieldNode","encodeBufferRegion","createBuffer","setInt16","invalidMessageType","nullMessage","invalidMessageMetadata","expected","actual","invalidMessageBodyLength","readMetadataLength","readMetadata","throwIfNull","readMessage","PADDING","metadataLength","_body","_batchIndex","_dictionaryIndex","batches","flattenDataSources","MAGIC_STR","MAGIC","checkForMagicArrowString","magicLength","magicAndPadding","magicX2AndPadding","_byteLength","_bufferRegions","assembler","vectorChildren","assembleResult","RangeError","isNull","addBuffer","_nullV","assembleUnion","assembleNestedVector","maxChildTypeId","childLengths","shiftedOffsets","unshiftedOffsets","childLength","assembleBoolVector","assembleFlatVector","assembleFlatListVector","firstOffset","lastOffset","assembleListVector","_position","_started","_sink","_dictionaryBlocks","_recordBatchBlocks","_dictionaryDeltaOffsets","autoDestroy","writeLegacyIpcFormat","_autoDestroy","_writeLegacyIpcFormat","writableStrategy","readableStrategy","writeAll","writeAllAsync","sink","objectMode","_writeFooter","compareTo","_writeSchema","payload","_writeRecordBatch","flatbufferSize","prefixSize","nPaddingBytes","_write","of","_writePadding","_writeMessage","assemble","_writeDictionaries","_writeBodyBuffers","padding","_writeDictionaryBatch","writer","_writeMagic","noopBuf","nullBufs","bitmapLength","ensureSameLengthData","batchLength","batchData","_changeLengthAndBackfillNullBitmap","distributeColumnsIntoRecordBatches","distributeVectorsIntoRecordBatches","vecs","uniformlyDistributeChunksAcrossRecordBatches","batchArgs","numBatches","numColumns","POSITIVE_INFINITY","distributeChildData","_bindDataAccessors","VectorName","mask","vectorFromValuesWithType","DateDayVector","DateMillisecondVector","ArrowType","vectorTypeToDataType","InputType","arrayTypeToDataType","convertTo16Bit","Float16Vector","Float32Vector","Float64Vector","typeCtor","dataCtor","IntervalDayTimeVector","IntervalYearMonthVector","is64bit","convert32To64Bit","Int8Vector","Int16Vector","Int32Vector","_values64","Uint8Vector","Uint16Vector","Uint32Vector","_row","bound","TimestampSecondVector","TimestampMillisecondVector","TimestampMicrosecondVector","TimestampNanosecondVector","TimeSecondVector","TimeMillisecondVector","TimeMicrosecondVector","TimeNanosecondVector","DenseUnionVector","SparseUnionVector","partial0","partial1","partial2","epochDaysToMs","epochMillisecondsLongToMs","epochMicrosecondsLongToMs","epochNanosecondsLongToMs","epochMillisecondsToDate","epochDaysToDate","epochMillisecondsLongToDate","getNull","_vector","getVariableWidthBytes","getDateDay","getDateMillisecond","getNumeric","getFloat16","getBigInts","getFixedSizeBinary","getBinary","getUtf8","getInt","getFloat","getDate","getTimestampSecond","getTimestampMillisecond","getTimestampMicrosecond","getTimestampNanosecond","getTimestamp","getTimeSecond","getTimeMillisecond","getTimeMicrosecond","getTimeNanosecond","getDecimal","decimal","getList","getMap","getStruct","getUnion","getDenseUnion","getSparseUnion","getDictionary","getInterval","getIntervalDayTime","getIntervalYearMonth","interval","int32s","getFixedSizeList","nullIndexOf","searchElement","indexOfNull","indexOfValue","indexOfUnion","nullableIterator","getFn","nullByte","nullBit","vectorIterator","arrayOfVector","variableWidthColumnErrorMessage","____","visitFields","newVector","newDataType","vectorFrom","transform","partialType0","wrapNullableGet","wrapNullableSet","bindBaseVectorDataAccessors","getByteWidth","VectorCtor","empty","tableFromIterable","tableFromAsyncIterable","isSync","opening","cols","getColumnAt","getColumnIndex","Writer","nameToIndex","selectAt","columnName","oldToNew","newIdx","_f","_fs","fromStruct","fs","vs","_dictionaries","collect","impl","_impl","isFile","isAsync","isStream","readRecordBatch","fromArrowJSON","fromFileHandle","fromAsyncByteStream","fromByteStream","readAllSync","readAllAsync","RecordBatchStreamReader","AsyncRecordBatchStreamReader","RecordBatchFileReader","AsyncRecordBatchFileReader","_recordBatchIndex","_loadVectors","_reader","shouldAutoDestroy","readSchema","_readNextMessageAndValidate","readMessageBody","_loadRecordBatch","_loadDictionaryBatch","_readFooter","_readDictionaryBatch","seek","asyncIterableAsReadableDOMStream","iterableAsReadableDOMStream","hwm","ReadableStream","controller","desiredSize","enqueue","builderThroughDOMStream","_numChunks","_finished","_bufferedSize","builderOptions","_controller","_builder","_getSize","chunkByteLength","readableHighWaterMark","writableHighWaterMark","_maybeFlush","WritableStream","_writeValueAndReturnChunkSize","bufferedSize","_enqueue","recordBatchReaderThroughDOMStream","readable","recordBatchWriterThroughDOMStream","Value","Literal","LTeq","GTeq","Not","ge","le","eq","Col","colidx","Predicate","expr","And","Or","ComparisonPredicate","_bindLitLit","_bindLitCol","_bindColLit","_bindColCol","CombinationPredicate","accum","_batch","left_func","right_func","col","lit","col_func","lastDictionary","reverseLookup","lastKey","countBy","scan","scanReverse","predicate","batchIndex","numRows","count_by","countByteLength","log","CountsArrayType","counts","_predicate","isBound","and","ComponentMessageType","ArrowTable","indexBuffer","columnsBuffer","styler","_this","getCell","rowIndex","columnIndex","isBlankCell","headerRows","headerColumns","isIndexCell","isColumnsCell","classNames","dataColumnIndex","getContent","columnsTable","dataRowIndex","uuid","indexTable","displayValuesTable","dataTable","columnTypeId","getColumnTypeId","nanosToDate","caption","displayValues","numCols","rows","dataRows","dataColumns","serialize","nanos","__assign","Streamlit","API_VERSION","RENDER_EVENT","registeredMessageListener","setComponentReady","onMessageEvent","sendBackMsg","COMPONENT_READY","apiVersion","setFrameHeight","height","scrollHeight","lastFrameHeight","SET_FRAME_HEIGHT","setComponentValue","dataType","isTypedArray","SET_COMPONENT_VALUE","onRenderMessage","dataframeArgs","argsDataframeToObject","disabled","theme","_injectTheme","eventData","detail","dispatchEvent","argsDataframe","argsDataframeArrow","_a","toArrowTable","fromEntries","df","isStreamlitMessage","primaryColor","backgroundColor","secondaryBackgroundColor","textColor","font","isBigIntArray","__extends","extendStatics","__proto__","__","_super","StreamlitComponentBase","componentDidMount","componentDidUpdate","nativePropertyIsEnumerable","NASHORN_BUG","1","aPossiblePrototype","CORRECT_SETTER","TAG","reactIs","REACT_STATICS","childContextTypes","contextType","contextTypes","getDefaultProps","getDerivedStateFromError","getDerivedStateFromProps","propTypes","KNOWN_STATICS","caller","callee","arity","FORWARD_REF_STATICS","MEMO_STATICS","TYPE_STATICS","getStatics","objectPrototype","hoistNonReactStatics","targetComponent","sourceComponent","blacklist","inheritedComponent","targetStatics","sourceStatics","check","globalThis","CORRECT_PROTOTYPE_GETTER","ObjectPrototype","addToUnscopables","defineIterator","ARRAY_ITERATOR","setInternalState","iterated","kind","Arguments","Internal","OwnPromiseCapability","PromiseWrapper","nativeThen","redefineAll","setSpecies","anInstance","checkCorrectnessOfIteration","microtask","hostReportErrors","newPromiseCapabilityModule","perform","PROMISE","getInternalPromiseState","PromiseConstructor","$fetch","newGenericPromiseCapability","DISPATCH_EVENT","UNHANDLED_REJECTION","REJECTION_HANDLED","PENDING","FULFILLED","REJECTED","HANDLED","UNHANDLED","GLOBAL_CORE_JS_PROMISE","PromiseRejectionEvent","FakePromise","INCORRECT_ITERATION","all","isThenable","isReject","notified","chain","reactions","exited","reaction","fail","rejection","onHandleUnhandled","onUnhandled","initEvent","IS_UNHANDLED","isUnhandled","unwrap","internalReject","internalResolve","executor","onFulfilled","onRejected","fetch","capability","$promiseResolve","alreadyCalled","getOwnPropertyDescriptorModule","PromiseCapability","$$resolve","$$reject","TO_STRING_TAG_SUPPORT","classofRaw","CORRECT_ARGUMENTS","tryGet","arrayMethodUsesToLength","HAS_SPECIES_SUPPORT","USES_TO_LENGTH","0","nativeSlice","fin"],"mappings":"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","file":"js/chunk-vendors.1b4b40f9.js","sourcesContent":["var wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","var aFunction = require('../internals/a-function');\n\n// optional / simple context binding\nmodule.exports = function (fn, that, length) {\n  aFunction(fn);\n  if (that === undefined) return fn;\n  switch (length) {\n    case 0: return function () {\n      return fn.call(that);\n    };\n    case 1: return function (a) {\n      return fn.call(that, a);\n    };\n    case 2: return function (a, b) {\n      return fn.call(that, a, b);\n    };\n    case 3: return function (a, b, c) {\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function (/* ...args */) {\n    return fn.apply(that, arguments);\n  };\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPrimitive = require('../internals/to-primitive');\nvar has = require('../internals/has');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\nvar nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n  O = toIndexedObject(O);\n  P = toPrimitive(P, true);\n  if (IE8_DOM_DEFINE) try {\n    return nativeGetOwnPropertyDescriptor(O, P);\n  } catch (error) { /* empty */ }\n  if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thank's IE8 for his funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n  return Object.defineProperty(createElement('div'), 'a', {\n    get: function () { return 7; }\n  }).a != 7;\n});\n","module.exports = function (it, Constructor, name) {\n  if (!(it instanceof Constructor)) {\n    throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation');\n  } return it;\n};\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","module.exports = function (it) {\n  if (typeof it != 'function') {\n    throw TypeError(String(it) + ' is not a function');\n  } return it;\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n  var called = 0;\n  var iteratorWithReturn = {\n    next: function () {\n      return { done: !!called++ };\n    },\n    'return': function () {\n      SAFE_CLOSING = true;\n    }\n  };\n  iteratorWithReturn[ITERATOR] = function () {\n    return this;\n  };\n  // eslint-disable-next-line no-throw-literal\n  Array.from(iteratorWithReturn, function () { throw 2; });\n} catch (error) { /* empty */ }\n\nmodule.exports = function (exec, SKIP_CLOSING) {\n  if (!SKIP_CLOSING && !SAFE_CLOSING) return false;\n  var ITERATION_SUPPORT = false;\n  try {\n    var object = {};\n    object[ITERATOR] = function () {\n      return {\n        next: function () {\n          return { done: ITERATION_SUPPORT = true };\n        }\n      };\n    };\n    exec(object);\n  } catch (error) { /* empty */ }\n  return ITERATION_SUPPORT;\n};\n","var userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /(iphone|ipod|ipad).*applewebkit/i.test(userAgent);\n","// `RequireObjectCoercible` abstract operation\n// https://tc39.github.io/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n  if (it == undefined) throw TypeError(\"Can't call method on \" + it);\n  return it;\n};\n","var fails = require('../internals/fails');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (METHOD_NAME) {\n  // We can't use this feature detection in V8 since it causes\n  // deoptimization and serious performance degradation\n  // https://github.com/zloirock/core-js/issues/677\n  return V8_VERSION >= 51 || !fails(function () {\n    var array = [];\n    var constructor = array.constructor = {};\n    constructor[SPECIES] = function () {\n      return { foo: 1 };\n    };\n    return array[METHOD_NAME](Boolean).foo !== 1;\n  });\n};\n","var anObject = require('../internals/an-object');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar toLength = require('../internals/to-length');\nvar bind = require('../internals/function-bind-context');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');\n\nvar Result = function (stopped, result) {\n  this.stopped = stopped;\n  this.result = result;\n};\n\nvar iterate = module.exports = function (iterable, fn, that, AS_ENTRIES, IS_ITERATOR) {\n  var boundFunction = bind(fn, that, AS_ENTRIES ? 2 : 1);\n  var iterator, iterFn, index, length, result, next, step;\n\n  if (IS_ITERATOR) {\n    iterator = iterable;\n  } else {\n    iterFn = getIteratorMethod(iterable);\n    if (typeof iterFn != 'function') throw TypeError('Target is not iterable');\n    // optimisation for array iterators\n    if (isArrayIteratorMethod(iterFn)) {\n      for (index = 0, length = toLength(iterable.length); length > index; index++) {\n        result = AS_ENTRIES\n          ? boundFunction(anObject(step = iterable[index])[0], step[1])\n          : boundFunction(iterable[index]);\n        if (result && result instanceof Result) return result;\n      } return new Result(false);\n    }\n    iterator = iterFn.call(iterable);\n  }\n\n  next = iterator.next;\n  while (!(step = next.call(iterator)).done) {\n    result = callWithSafeIterationClosing(iterator, boundFunction, step.value, AS_ENTRIES);\n    if (typeof result == 'object' && result && result instanceof Result) return result;\n  } return new Result(false);\n};\n\niterate.stop = function (result) {\n  return new Result(true, result);\n};\n","var toInteger = require('../internals/to-integer');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n  var integer = toInteger(index);\n  return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","var global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar setGlobal = require('../internals/set-global');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n  options.target      - name of the target object\n  options.global      - target is the global object\n  options.stat        - export as static methods of target\n  options.proto       - export as prototype methods of target\n  options.real        - real prototype method for the `pure` version\n  options.forced      - export even if the native feature is available\n  options.bind        - bind methods to the target, required for the `pure` version\n  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version\n  options.unsafe      - use the simple assignment of property instead of delete + defineProperty\n  options.sham        - add a flag to not completely full polyfills\n  options.enumerable  - export as enumerable property\n  options.noTargetGet - prevent calling a getter on target\n*/\nmodule.exports = function (options, source) {\n  var TARGET = options.target;\n  var GLOBAL = options.global;\n  var STATIC = options.stat;\n  var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n  if (GLOBAL) {\n    target = global;\n  } else if (STATIC) {\n    target = global[TARGET] || setGlobal(TARGET, {});\n  } else {\n    target = (global[TARGET] || {}).prototype;\n  }\n  if (target) for (key in source) {\n    sourceProperty = source[key];\n    if (options.noTargetGet) {\n      descriptor = getOwnPropertyDescriptor(target, key);\n      targetProperty = descriptor && descriptor.value;\n    } else targetProperty = target[key];\n    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n    // contained in target\n    if (!FORCED && targetProperty !== undefined) {\n      if (typeof sourceProperty === typeof targetProperty) continue;\n      copyConstructorProperties(sourceProperty, targetProperty);\n    }\n    // add a flag to not completely full polyfills\n    if (options.sham || (targetProperty && targetProperty.sham)) {\n      createNonEnumerableProperty(sourceProperty, 'sham', true);\n    }\n    // extend global\n    redefine(target, key, sourceProperty, options);\n  }\n};\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.github.io/ecma262/#sec-object.getownpropertynames\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n  return internalObjectKeys(O, hiddenKeys);\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar definePropertyModule = require('../internals/object-define-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (CONSTRUCTOR_NAME) {\n  var Constructor = getBuiltIn(CONSTRUCTOR_NAME);\n  var defineProperty = definePropertyModule.f;\n\n  if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {\n    defineProperty(Constructor, SPECIES, {\n      configurable: true,\n      get: function () { return this; }\n    });\n  }\n};\n","var global = require('../internals/global');\nvar fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\nvar bind = require('../internals/function-bind-context');\nvar html = require('../internals/html');\nvar createElement = require('../internals/document-create-element');\nvar IS_IOS = require('../internals/engine-is-ios');\n\nvar location = global.location;\nvar set = global.setImmediate;\nvar clear = global.clearImmediate;\nvar process = global.process;\nvar MessageChannel = global.MessageChannel;\nvar Dispatch = global.Dispatch;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar defer, channel, port;\n\nvar run = function (id) {\n  // eslint-disable-next-line no-prototype-builtins\n  if (queue.hasOwnProperty(id)) {\n    var fn = queue[id];\n    delete queue[id];\n    fn();\n  }\n};\n\nvar runner = function (id) {\n  return function () {\n    run(id);\n  };\n};\n\nvar listener = function (event) {\n  run(event.data);\n};\n\nvar post = function (id) {\n  // old engines have not location.origin\n  global.postMessage(id + '', location.protocol + '//' + location.host);\n};\n\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!set || !clear) {\n  set = function setImmediate(fn) {\n    var args = [];\n    var i = 1;\n    while (arguments.length > i) args.push(arguments[i++]);\n    queue[++counter] = function () {\n      // eslint-disable-next-line no-new-func\n      (typeof fn == 'function' ? fn : Function(fn)).apply(undefined, args);\n    };\n    defer(counter);\n    return counter;\n  };\n  clear = function clearImmediate(id) {\n    delete queue[id];\n  };\n  // Node.js 0.8-\n  if (classof(process) == 'process') {\n    defer = function (id) {\n      process.nextTick(runner(id));\n    };\n  // Sphere (JS game engine) Dispatch API\n  } else if (Dispatch && Dispatch.now) {\n    defer = function (id) {\n      Dispatch.now(runner(id));\n    };\n  // Browsers with MessageChannel, includes WebWorkers\n  // except iOS - https://github.com/zloirock/core-js/issues/624\n  } else if (MessageChannel && !IS_IOS) {\n    channel = new MessageChannel();\n    port = channel.port2;\n    channel.port1.onmessage = listener;\n    defer = bind(port.postMessage, port, 1);\n  // Browsers with postMessage, skip WebWorkers\n  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n  } else if (\n    global.addEventListener &&\n    typeof postMessage == 'function' &&\n    !global.importScripts &&\n    !fails(post) &&\n    location.protocol !== 'file:'\n  ) {\n    defer = post;\n    global.addEventListener('message', listener, false);\n  // IE8-\n  } else if (ONREADYSTATECHANGE in createElement('script')) {\n    defer = function (id) {\n      html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {\n        html.removeChild(this);\n        run(id);\n      };\n    };\n  // Rest old browsers\n  } else {\n    defer = function (id) {\n      setTimeout(runner(id), 0);\n    };\n  }\n}\n\nmodule.exports = {\n  set: set,\n  clear: clear\n};\n","var global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar versions = process && process.versions;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n  match = v8.split('.');\n  version = match[0] + match[1];\n} else if (userAgent) {\n  match = userAgent.match(/Edge\\/(\\d+)/);\n  if (!match || match[1] >= 74) {\n    match = userAgent.match(/Chrome\\/(\\d+)/);\n    if (match) version = match[1];\n  }\n}\n\nmodule.exports = version && +version;\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","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('navigator', 'userAgent') || '';\n","var classof = require('../internals/classof');\nvar Iterators = require('../internals/iterators');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = function (it) {\n  if (it != undefined) return it[ITERATOR]\n    || it['@@iterator']\n    || Iterators[classof(it)];\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.github.io/ecma262/#sec-object.defineproperties\nmodule.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {\n  anObject(O);\n  var keys = objectKeys(Properties);\n  var length = keys.length;\n  var index = 0;\n  var key;\n  while (length > index) definePropertyModule.f(O, key = keys[index++], Properties[key]);\n  return O;\n};\n","var isObject = require('../internals/is-object');\n\nmodule.exports = function (it) {\n  if (!isObject(it) && it !== null) {\n    throw TypeError(\"Can't set \" + String(it) + ' as a prototype');\n  } return it;\n};\n","module.exports = {};\n","var global = require('../internals/global');\n\nmodule.exports = global;\n","var fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar split = ''.split;\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n  // eslint-disable-next-line no-prototype-builtins\n  return !Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n  return classof(it) == 'String' ? split.call(it, '') : Object(it);\n} : Object;\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar definePropertyModule = require('../internals/object-define-property');\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] == undefined) {\n  definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {\n    configurable: true,\n    value: create(null)\n  });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n  ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","var global = require('../internals/global');\n\nmodule.exports = function (a, b) {\n  var console = global.console;\n  if (console && console.error) {\n    arguments.length === 1 ? console.error(a) : console.error(a, b);\n  }\n};\n","var anObject = require('../internals/an-object');\nvar aFunction = require('../internals/a-function');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `SpeciesConstructor` abstract operation\n// https://tc39.github.io/ecma262/#sec-speciesconstructor\nmodule.exports = function (O, defaultConstructor) {\n  var C = anObject(O).constructor;\n  var S;\n  return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? defaultConstructor : aFunction(S);\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n  // Chrome 38 Symbol has incorrect toString conversion\n  // eslint-disable-next-line no-undef\n  return !String(Symbol());\n});\n","'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","var toIndexedObject = require('../internals/to-indexed-object');\nvar toLength = require('../internals/to-length');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n  return function ($this, el, fromIndex) {\n    var O = toIndexedObject($this);\n    var length = toLength(O.length);\n    var index = toAbsoluteIndex(fromIndex, length);\n    var value;\n    // Array#includes uses SameValueZero equality algorithm\n    // eslint-disable-next-line no-self-compare\n    if (IS_INCLUDES && el != el) while (length > index) {\n      value = O[index++];\n      // eslint-disable-next-line no-self-compare\n      if (value != value) return true;\n    // Array#indexOf ignores holes, Array#includes - not\n    } else for (;length > index; index++) {\n      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n\nmodule.exports = {\n  // `Array.prototype.includes` method\n  // https://tc39.github.io/ecma262/#sec-array.prototype.includes\n  includes: createMethod(true),\n  // `Array.prototype.indexOf` method\n  // https://tc39.github.io/ecma262/#sec-array.prototype.indexof\n  indexOf: createMethod(false)\n};\n","var toInteger = require('../internals/to-integer');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.github.io/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n  return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","var hasOwnProperty = {}.hasOwnProperty;\n\nmodule.exports = function (it, key) {\n  return hasOwnProperty.call(it, key);\n};\n","var IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n  return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n  version: '3.6.5',\n  mode: IS_PURE ? 'pure' : 'global',\n  copyright: '© 2020 Denis Pushkarev (zloirock.ru)'\n});\n","var getBuiltIn = require('../internals/get-built-in');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n  var keys = getOwnPropertyNamesModule.f(anObject(it));\n  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n  return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;\n};\n","import { pauseTracking, resetTracking, isRef, toRaw, isProxy, shallowReactive, trigger, effect, stop, isReactive, reactive, shallowReadonly, track, proxyRefs, computed as computed$1, ref } from '@vue/reactivity';\nexport { customRef, isProxy, isReactive, isReadonly, isRef, markRaw, proxyRefs, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRaw, toRef, toRefs, triggerRef, unref } from '@vue/reactivity';\nimport { isString, isFunction, isPromise, isArray, extend, isModelListener, isOn, camelize, capitalize, EMPTY_ARR, normalizeClass, isObject, normalizeStyle, EMPTY_OBJ, hyphenate, hasOwn, def, isReservedProp, toRawType, makeMap, remove, invokeArrayFns, NO, getGlobalThis, NOOP, hasChanged, isGloballyWhitelisted } from '@vue/shared';\nexport { camelize, capitalize, toDisplayString } from '@vue/shared';\n\nconst stack = [];\r\nfunction pushWarningContext(vnode) {\r\n    stack.push(vnode);\r\n}\r\nfunction popWarningContext() {\r\n    stack.pop();\r\n}\r\nfunction warn(msg, ...args) {\r\n    // avoid props formatting or warn handler tracking deps that might be mutated\r\n    // during patch, leading to infinite recursion.\r\n    pauseTracking();\r\n    const instance = stack.length ? stack[stack.length - 1].component : null;\r\n    const appWarnHandler = instance && instance.appContext.config.warnHandler;\r\n    const trace = getComponentTrace();\r\n    if (appWarnHandler) {\r\n        callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [\r\n            msg + args.join(''),\r\n            instance && instance.proxy,\r\n            trace\r\n                .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)\r\n                .join('\\n'),\r\n            trace\r\n        ]);\r\n    }\r\n    else {\r\n        const warnArgs = [`[Vue warn]: ${msg}`, ...args];\r\n        /* istanbul ignore if */\r\n        if (trace.length &&\r\n            // avoid spamming console during tests\r\n            !false) {\r\n            warnArgs.push(`\\n`, ...formatTrace(trace));\r\n        }\r\n        console.warn(...warnArgs);\r\n    }\r\n    resetTracking();\r\n}\r\nfunction getComponentTrace() {\r\n    let currentVNode = stack[stack.length - 1];\r\n    if (!currentVNode) {\r\n        return [];\r\n    }\r\n    // we can't just use the stack because it will be incomplete during updates\r\n    // that did not start from the root. Re-construct the parent chain using\r\n    // instance parent pointers.\r\n    const normalizedStack = [];\r\n    while (currentVNode) {\r\n        const last = normalizedStack[0];\r\n        if (last && last.vnode === currentVNode) {\r\n            last.recurseCount++;\r\n        }\r\n        else {\r\n            normalizedStack.push({\r\n                vnode: currentVNode,\r\n                recurseCount: 0\r\n            });\r\n        }\r\n        const parentInstance = currentVNode.component && currentVNode.component.parent;\r\n        currentVNode = parentInstance && parentInstance.vnode;\r\n    }\r\n    return normalizedStack;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatTrace(trace) {\r\n    const logs = [];\r\n    trace.forEach((entry, i) => {\r\n        logs.push(...(i === 0 ? [] : [`\\n`]), ...formatTraceEntry(entry));\r\n    });\r\n    return logs;\r\n}\r\nfunction formatTraceEntry({ vnode, recurseCount }) {\r\n    const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;\r\n    const isRoot = vnode.component ? vnode.component.parent == null : false;\r\n    const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;\r\n    const close = `>` + postfix;\r\n    return vnode.props\r\n        ? [open, ...formatProps(vnode.props), close]\r\n        : [open + close];\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProps(props) {\r\n    const res = [];\r\n    const keys = Object.keys(props);\r\n    keys.slice(0, 3).forEach(key => {\r\n        res.push(...formatProp(key, props[key]));\r\n    });\r\n    if (keys.length > 3) {\r\n        res.push(` ...`);\r\n    }\r\n    return res;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProp(key, value, raw) {\r\n    if (isString(value)) {\r\n        value = JSON.stringify(value);\r\n        return raw ? value : [`${key}=${value}`];\r\n    }\r\n    else if (typeof value === 'number' ||\r\n        typeof value === 'boolean' ||\r\n        value == null) {\r\n        return raw ? value : [`${key}=${value}`];\r\n    }\r\n    else if (isRef(value)) {\r\n        value = formatProp(key, toRaw(value.value), true);\r\n        return raw ? value : [`${key}=Ref<`, value, `>`];\r\n    }\r\n    else if (isFunction(value)) {\r\n        return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];\r\n    }\r\n    else {\r\n        value = toRaw(value);\r\n        return raw ? value : [`${key}=`, value];\r\n    }\r\n}\n\nconst ErrorTypeStrings = {\r\n    [\"bc\" /* BEFORE_CREATE */]: 'beforeCreate hook',\r\n    [\"c\" /* CREATED */]: 'created hook',\r\n    [\"bm\" /* BEFORE_MOUNT */]: 'beforeMount hook',\r\n    [\"m\" /* MOUNTED */]: 'mounted hook',\r\n    [\"bu\" /* BEFORE_UPDATE */]: 'beforeUpdate hook',\r\n    [\"u\" /* UPDATED */]: 'updated',\r\n    [\"bum\" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',\r\n    [\"um\" /* UNMOUNTED */]: 'unmounted hook',\r\n    [\"a\" /* ACTIVATED */]: 'activated hook',\r\n    [\"da\" /* DEACTIVATED */]: 'deactivated hook',\r\n    [\"ec\" /* ERROR_CAPTURED */]: 'errorCaptured hook',\r\n    [\"rtc\" /* RENDER_TRACKED */]: 'renderTracked hook',\r\n    [\"rtg\" /* RENDER_TRIGGERED */]: 'renderTriggered hook',\r\n    [0 /* SETUP_FUNCTION */]: 'setup function',\r\n    [1 /* RENDER_FUNCTION */]: 'render function',\r\n    [2 /* WATCH_GETTER */]: 'watcher getter',\r\n    [3 /* WATCH_CALLBACK */]: 'watcher callback',\r\n    [4 /* WATCH_CLEANUP */]: 'watcher cleanup function',\r\n    [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',\r\n    [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',\r\n    [7 /* VNODE_HOOK */]: 'vnode hook',\r\n    [8 /* DIRECTIVE_HOOK */]: 'directive hook',\r\n    [9 /* TRANSITION_HOOK */]: 'transition hook',\r\n    [10 /* APP_ERROR_HANDLER */]: 'app errorHandler',\r\n    [11 /* APP_WARN_HANDLER */]: 'app warnHandler',\r\n    [12 /* FUNCTION_REF */]: 'ref function',\r\n    [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',\r\n    [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +\r\n        'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'\r\n};\r\nfunction callWithErrorHandling(fn, instance, type, args) {\r\n    let res;\r\n    try {\r\n        res = args ? fn(...args) : fn();\r\n    }\r\n    catch (err) {\r\n        handleError(err, instance, type);\r\n    }\r\n    return res;\r\n}\r\nfunction callWithAsyncErrorHandling(fn, instance, type, args) {\r\n    if (isFunction(fn)) {\r\n        const res = callWithErrorHandling(fn, instance, type, args);\r\n        if (res && isPromise(res)) {\r\n            res.catch(err => {\r\n                handleError(err, instance, type);\r\n            });\r\n        }\r\n        return res;\r\n    }\r\n    const values = [];\r\n    for (let i = 0; i < fn.length; i++) {\r\n        values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));\r\n    }\r\n    return values;\r\n}\r\nfunction handleError(err, instance, type) {\r\n    const contextVNode = instance ? instance.vnode : null;\r\n    if (instance) {\r\n        let cur = instance.parent;\r\n        // the exposed instance is the render proxy to keep it consistent with 2.x\r\n        const exposedInstance = instance.proxy;\r\n        // in production the hook receives only the error code\r\n        const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] : type;\r\n        while (cur) {\r\n            const errorCapturedHooks = cur.ec;\r\n            if (errorCapturedHooks) {\r\n                for (let i = 0; i < errorCapturedHooks.length; i++) {\r\n                    if (errorCapturedHooks[i](err, exposedInstance, errorInfo)) {\r\n                        return;\r\n                    }\r\n                }\r\n            }\r\n            cur = cur.parent;\r\n        }\r\n        // app-level handling\r\n        const appErrorHandler = instance.appContext.config.errorHandler;\r\n        if (appErrorHandler) {\r\n            callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);\r\n            return;\r\n        }\r\n    }\r\n    logError(err, type, contextVNode);\r\n}\r\nfunction logError(err, type, contextVNode) {\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        const info = ErrorTypeStrings[type];\r\n        if (contextVNode) {\r\n            pushWarningContext(contextVNode);\r\n        }\r\n        warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);\r\n        if (contextVNode) {\r\n            popWarningContext();\r\n        }\r\n        // crash in dev so it's more noticeable\r\n        throw err;\r\n    }\r\n    else {\r\n        // recover in prod to reduce the impact on end-user\r\n        console.error(err);\r\n    }\r\n}\n\nconst queue = [];\r\nconst postFlushCbs = [];\r\nconst resolvedPromise = Promise.resolve();\r\nlet currentFlushPromise = null;\r\nlet isFlushing = false;\r\nlet isFlushPending = false;\r\nlet flushIndex = -1;\r\nlet pendingPostFlushCbs = null;\r\nlet pendingPostFlushIndex = 0;\r\nconst RECURSION_LIMIT = 100;\r\nfunction nextTick(fn) {\r\n    const p = currentFlushPromise || resolvedPromise;\r\n    return fn ? p.then(fn) : p;\r\n}\r\nfunction queueJob(job) {\r\n    if (!queue.includes(job, flushIndex + 1)) {\r\n        queue.push(job);\r\n        queueFlush();\r\n    }\r\n}\r\nfunction invalidateJob(job) {\r\n    const i = queue.indexOf(job);\r\n    if (i > -1) {\r\n        queue[i] = null;\r\n    }\r\n}\r\nfunction queuePostFlushCb(cb) {\r\n    if (!isArray(cb)) {\r\n        if (!pendingPostFlushCbs ||\r\n            !pendingPostFlushCbs.includes(cb, pendingPostFlushIndex + 1)) {\r\n            postFlushCbs.push(cb);\r\n        }\r\n    }\r\n    else {\r\n        // if cb is an array, it is a component lifecycle hook which can only be\r\n        // triggered by a job, which is already deduped in the main queue, so\r\n        // we can skip dupicate check here to improve perf\r\n        postFlushCbs.push(...cb);\r\n    }\r\n    queueFlush();\r\n}\r\nfunction queueFlush() {\r\n    if (!isFlushing && !isFlushPending) {\r\n        isFlushPending = true;\r\n        currentFlushPromise = resolvedPromise.then(flushJobs);\r\n    }\r\n}\r\nfunction flushPostFlushCbs(seen) {\r\n    if (postFlushCbs.length) {\r\n        pendingPostFlushCbs = [...new Set(postFlushCbs)];\r\n        postFlushCbs.length = 0;\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            seen = seen || new Map();\r\n        }\r\n        for (pendingPostFlushIndex = 0; pendingPostFlushIndex < pendingPostFlushCbs.length; pendingPostFlushIndex++) {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                checkRecursiveUpdates(seen, pendingPostFlushCbs[pendingPostFlushIndex]);\r\n            }\r\n            pendingPostFlushCbs[pendingPostFlushIndex]();\r\n        }\r\n        pendingPostFlushCbs = null;\r\n        pendingPostFlushIndex = 0;\r\n    }\r\n}\r\nconst getId = (job) => (job.id == null ? Infinity : job.id);\r\nfunction flushJobs(seen) {\r\n    isFlushPending = false;\r\n    isFlushing = true;\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        seen = seen || new Map();\r\n    }\r\n    // Sort queue before flush.\r\n    // This ensures that:\r\n    // 1. Components are updated from parent to child. (because parent is always\r\n    //    created before the child so its render effect will have smaller\r\n    //    priority number)\r\n    // 2. If a component is unmounted during a parent component's update,\r\n    //    its update can be skipped.\r\n    // Jobs can never be null before flush starts, since they are only invalidated\r\n    // during execution of another flushed job.\r\n    queue.sort((a, b) => getId(a) - getId(b));\r\n    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\r\n        const job = queue[flushIndex];\r\n        if (job) {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                checkRecursiveUpdates(seen, job);\r\n            }\r\n            callWithErrorHandling(job, null, 14 /* SCHEDULER */);\r\n        }\r\n    }\r\n    flushIndex = -1;\r\n    queue.length = 0;\r\n    flushPostFlushCbs(seen);\r\n    isFlushing = false;\r\n    currentFlushPromise = null;\r\n    // some postFlushCb queued jobs!\r\n    // keep flushing until it drains.\r\n    if (queue.length || postFlushCbs.length) {\r\n        flushJobs(seen);\r\n    }\r\n}\r\nfunction checkRecursiveUpdates(seen, fn) {\r\n    if (!seen.has(fn)) {\r\n        seen.set(fn, 1);\r\n    }\r\n    else {\r\n        const count = seen.get(fn);\r\n        if (count > RECURSION_LIMIT) {\r\n            throw new Error('Maximum recursive updates exceeded. ' +\r\n                \"You may have code that is mutating state in your component's \" +\r\n                'render function or updated hook or watcher source function.');\r\n        }\r\n        else {\r\n            seen.set(fn, count + 1);\r\n        }\r\n    }\r\n}\n\nlet isHmrUpdating = false;\r\nconst hmrDirtyComponents = new Set();\r\n// Expose the HMR runtime on the global object\r\n// This makes it entirely tree-shakable without polluting the exports and makes\r\n// it easier to be used in toolings like vue-loader\r\n// Note: for a component to be eligible for HMR it also needs the __hmrId option\r\n// to be set so that its instances can be registered / removed.\r\nif ((process.env.NODE_ENV !== 'production')) {\r\n    const globalObject = typeof global !== 'undefined'\r\n        ? global\r\n        : typeof self !== 'undefined'\r\n            ? self\r\n            : typeof window !== 'undefined'\r\n                ? window\r\n                : {};\r\n    globalObject.__VUE_HMR_RUNTIME__ = {\r\n        createRecord: tryWrap(createRecord),\r\n        rerender: tryWrap(rerender),\r\n        reload: tryWrap(reload)\r\n    };\r\n}\r\nconst map = new Map();\r\nfunction registerHMR(instance) {\r\n    const id = instance.type.__hmrId;\r\n    let record = map.get(id);\r\n    if (!record) {\r\n        createRecord(id);\r\n        record = map.get(id);\r\n    }\r\n    record.add(instance);\r\n}\r\nfunction unregisterHMR(instance) {\r\n    map.get(instance.type.__hmrId).delete(instance);\r\n}\r\nfunction createRecord(id) {\r\n    if (map.has(id)) {\r\n        return false;\r\n    }\r\n    map.set(id, new Set());\r\n    return true;\r\n}\r\nfunction rerender(id, newRender) {\r\n    const record = map.get(id);\r\n    if (!record)\r\n        return;\r\n    // Array.from creates a snapshot which avoids the set being mutated during\r\n    // updates\r\n    Array.from(record).forEach(instance => {\r\n        if (newRender) {\r\n            instance.render = newRender;\r\n        }\r\n        instance.renderCache = [];\r\n        // this flag forces child components with slot content to update\r\n        isHmrUpdating = true;\r\n        instance.update();\r\n        isHmrUpdating = false;\r\n    });\r\n}\r\nfunction reload(id, newComp) {\r\n    const record = map.get(id);\r\n    if (!record)\r\n        return;\r\n    // Array.from creates a snapshot which avoids the set being mutated during\r\n    // updates\r\n    Array.from(record).forEach(instance => {\r\n        const comp = instance.type;\r\n        if (!hmrDirtyComponents.has(comp)) {\r\n            // 1. Update existing comp definition to match new one\r\n            extend(comp, newComp);\r\n            for (const key in comp) {\r\n                if (!(key in newComp)) {\r\n                    delete comp[key];\r\n                }\r\n            }\r\n            // 2. Mark component dirty. This forces the renderer to replace the component\r\n            // on patch.\r\n            hmrDirtyComponents.add(comp);\r\n            // 3. Make sure to unmark the component after the reload.\r\n            queuePostFlushCb(() => {\r\n                hmrDirtyComponents.delete(comp);\r\n            });\r\n        }\r\n        if (instance.parent) {\r\n            // 4. Force the parent instance to re-render. This will cause all updated\r\n            // components to be unmounted and re-mounted. Queue the update so that we\r\n            // don't end up forcing the same parent to re-render multiple times.\r\n            queueJob(instance.parent.update);\r\n        }\r\n        else if (instance.appContext.reload) {\r\n            // root instance mounted via createApp() has a reload method\r\n            instance.appContext.reload();\r\n        }\r\n        else if (typeof window !== 'undefined') {\r\n            // root instance inside tree created via raw render(). Force reload.\r\n            window.location.reload();\r\n        }\r\n        else {\r\n            console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');\r\n        }\r\n    });\r\n}\r\nfunction tryWrap(fn) {\r\n    return (id, arg) => {\r\n        try {\r\n            return fn(id, arg);\r\n        }\r\n        catch (e) {\r\n            console.error(e);\r\n            console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` +\r\n                `Full reload required.`);\r\n        }\r\n    };\r\n}\n\n// mark the current rendering instance for asset resolution (e.g.\r\n// resolveComponent, resolveDirective) during render\r\nlet currentRenderingInstance = null;\r\nfunction setCurrentRenderingInstance(instance) {\r\n    currentRenderingInstance = instance;\r\n}\r\n// dev only flag to track whether $attrs was used during render.\r\n// If $attrs was used during render then the warning for failed attrs\r\n// fallthrough can be suppressed.\r\nlet accessedAttrs = false;\r\nfunction markAttrsAccessed() {\r\n    accessedAttrs = true;\r\n}\r\nfunction renderComponentRoot(instance) {\r\n    const { type: Component, parent, vnode, proxy, withProxy, props, slots, attrs, emit, render, renderCache, data, setupState, ctx } = instance;\r\n    let result;\r\n    currentRenderingInstance = instance;\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        accessedAttrs = false;\r\n    }\r\n    try {\r\n        let fallthroughAttrs;\r\n        if (vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */) {\r\n            // withProxy is a proxy with a different `has` trap only for\r\n            // runtime-compiled render functions using `with` block.\r\n            const proxyToUse = withProxy || proxy;\r\n            result = normalizeVNode(render.call(proxyToUse, proxyToUse, renderCache, props, setupState, data, ctx));\r\n            fallthroughAttrs = attrs;\r\n        }\r\n        else {\r\n            // functional\r\n            const render = Component;\r\n            // in dev, mark attrs accessed if optional props (attrs === props)\r\n            if ((process.env.NODE_ENV !== 'production') && attrs === props) {\r\n                markAttrsAccessed();\r\n            }\r\n            result = normalizeVNode(render.length > 1\r\n                ? render(props, (process.env.NODE_ENV !== 'production')\r\n                    ? {\r\n                        get attrs() {\r\n                            markAttrsAccessed();\r\n                            return attrs;\r\n                        },\r\n                        slots,\r\n                        emit\r\n                    }\r\n                    : { attrs, slots, emit })\r\n                : render(props, null /* we know it doesn't need it */));\r\n            fallthroughAttrs = Component.props\r\n                ? attrs\r\n                : getFunctionalFallthrough(attrs);\r\n        }\r\n        // attr merging\r\n        // in dev mode, comments are preserved, and it's possible for a template\r\n        // to have comments along side the root element which makes it a fragment\r\n        let root = result;\r\n        let setRoot = undefined;\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            ;\r\n            [root, setRoot] = getChildRoot(result);\r\n        }\r\n        if (Component.inheritAttrs !== false && fallthroughAttrs) {\r\n            const keys = Object.keys(fallthroughAttrs);\r\n            const { shapeFlag } = root;\r\n            if (keys.length) {\r\n                if (shapeFlag & 1 /* ELEMENT */ ||\r\n                    shapeFlag & 6 /* COMPONENT */) {\r\n                    if (shapeFlag & 1 /* ELEMENT */ && keys.some(isModelListener)) {\r\n                        // #1643, #1543\r\n                        // component v-model listeners should only fallthrough for component\r\n                        // HOCs\r\n                        fallthroughAttrs = filterModelListeners(fallthroughAttrs);\r\n                    }\r\n                    root = cloneVNode(root, fallthroughAttrs);\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production') && !accessedAttrs && root.type !== Comment) {\r\n                    const allAttrs = Object.keys(attrs);\r\n                    const eventAttrs = [];\r\n                    const extraAttrs = [];\r\n                    for (let i = 0, l = allAttrs.length; i < l; i++) {\r\n                        const key = allAttrs[i];\r\n                        if (isOn(key)) {\r\n                            // ignore v-model handlers when they fail to fallthrough\r\n                            if (!isModelListener(key)) {\r\n                                // remove `on`, lowercase first letter to reflect event casing\r\n                                // accurately\r\n                                eventAttrs.push(key[2].toLowerCase() + key.slice(3));\r\n                            }\r\n                        }\r\n                        else {\r\n                            extraAttrs.push(key);\r\n                        }\r\n                    }\r\n                    if (extraAttrs.length) {\r\n                        warn(`Extraneous non-props attributes (` +\r\n                            `${extraAttrs.join(', ')}) ` +\r\n                            `were passed to component but could not be automatically inherited ` +\r\n                            `because component renders fragment or text root nodes.`);\r\n                    }\r\n                    if (eventAttrs.length) {\r\n                        warn(`Extraneous non-emits event listeners (` +\r\n                            `${eventAttrs.join(', ')}) ` +\r\n                            `were passed to component but could not be automatically inherited ` +\r\n                            `because component renders fragment or text root nodes. ` +\r\n                            `If the listener is intended to be a component custom event listener only, ` +\r\n                            `declare it using the \"emits\" option.`);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        // inherit scopeId\r\n        const scopeId = vnode.scopeId;\r\n        // vite#536: if subtree root is created from parent slot if would already\r\n        // have the correct scopeId, in this case adding the scopeId will cause\r\n        // it to be removed if the original slot vnode is reused.\r\n        const needScopeId = scopeId && root.scopeId !== scopeId;\r\n        const treeOwnerId = parent && parent.type.__scopeId;\r\n        const slotScopeId = treeOwnerId && treeOwnerId !== scopeId ? treeOwnerId + '-s' : null;\r\n        if (needScopeId || slotScopeId) {\r\n            const extras = {};\r\n            if (needScopeId)\r\n                extras[scopeId] = '';\r\n            if (slotScopeId)\r\n                extras[slotScopeId] = '';\r\n            root = cloneVNode(root, extras);\r\n        }\r\n        // inherit directives\r\n        if (vnode.dirs) {\r\n            if ((process.env.NODE_ENV !== 'production') && !isElementRoot(root)) {\r\n                warn(`Runtime directive used on component with non-element root node. ` +\r\n                    `The directives will not function as intended.`);\r\n            }\r\n            root.dirs = vnode.dirs;\r\n        }\r\n        // inherit transition data\r\n        if (vnode.transition) {\r\n            if ((process.env.NODE_ENV !== 'production') && !isElementRoot(root)) {\r\n                warn(`Component inside <Transition> renders non-element root node ` +\r\n                    `that cannot be animated.`);\r\n            }\r\n            root.transition = vnode.transition;\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production') && setRoot) {\r\n            setRoot(root);\r\n        }\r\n        else {\r\n            result = root;\r\n        }\r\n    }\r\n    catch (err) {\r\n        handleError(err, instance, 1 /* RENDER_FUNCTION */);\r\n        result = createVNode(Comment);\r\n    }\r\n    currentRenderingInstance = null;\r\n    return result;\r\n}\r\n/**\r\n * dev only\r\n */\r\nconst getChildRoot = (vnode) => {\r\n    if (vnode.type !== Fragment) {\r\n        return [vnode, undefined];\r\n    }\r\n    const rawChildren = vnode.children;\r\n    const dynamicChildren = vnode.dynamicChildren;\r\n    const children = rawChildren.filter(child => {\r\n        return !(isVNode(child) &&\r\n            child.type === Comment &&\r\n            child.children !== 'v-if');\r\n    });\r\n    if (children.length !== 1) {\r\n        return [vnode, undefined];\r\n    }\r\n    const childRoot = children[0];\r\n    const index = rawChildren.indexOf(childRoot);\r\n    const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1;\r\n    const setRoot = (updatedRoot) => {\r\n        rawChildren[index] = updatedRoot;\r\n        if (dynamicIndex > -1) {\r\n            dynamicChildren[dynamicIndex] = updatedRoot;\r\n        }\r\n        else if (dynamicChildren && updatedRoot.patchFlag > 0) {\r\n            dynamicChildren.push(updatedRoot);\r\n        }\r\n    };\r\n    return [normalizeVNode(childRoot), setRoot];\r\n};\r\nconst getFunctionalFallthrough = (attrs) => {\r\n    let res;\r\n    for (const key in attrs) {\r\n        if (key === 'class' || key === 'style' || isOn(key)) {\r\n            (res || (res = {}))[key] = attrs[key];\r\n        }\r\n    }\r\n    return res;\r\n};\r\nconst filterModelListeners = (attrs) => {\r\n    const res = {};\r\n    for (const key in attrs) {\r\n        if (!isModelListener(key)) {\r\n            res[key] = attrs[key];\r\n        }\r\n    }\r\n    return res;\r\n};\r\nconst isElementRoot = (vnode) => {\r\n    return (vnode.shapeFlag & 6 /* COMPONENT */ ||\r\n        vnode.shapeFlag & 1 /* ELEMENT */ ||\r\n        vnode.type === Comment // potential v-if branch switch\r\n    );\r\n};\r\nfunction shouldUpdateComponent(prevVNode, nextVNode, optimized) {\r\n    const { props: prevProps, children: prevChildren } = prevVNode;\r\n    const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;\r\n    // Parent component's render function was hot-updated. Since this may have\r\n    // caused the child component's slots content to have changed, we need to\r\n    // force the child to update as well.\r\n    if ((process.env.NODE_ENV !== 'production') && (prevChildren || nextChildren) && isHmrUpdating) {\r\n        return true;\r\n    }\r\n    // force child update for runtime directive or transition on component vnode.\r\n    if (nextVNode.dirs || nextVNode.transition) {\r\n        return true;\r\n    }\r\n    if (optimized && patchFlag > 0) {\r\n        if (patchFlag & 1024 /* DYNAMIC_SLOTS */) {\r\n            // slot content that references values that might have changed,\r\n            // e.g. in a v-for\r\n            return true;\r\n        }\r\n        if (patchFlag & 16 /* FULL_PROPS */) {\r\n            if (!prevProps) {\r\n                return !!nextProps;\r\n            }\r\n            // presence of this flag indicates props are always non-null\r\n            return hasPropsChanged(prevProps, nextProps);\r\n        }\r\n        else if (patchFlag & 8 /* PROPS */) {\r\n            const dynamicProps = nextVNode.dynamicProps;\r\n            for (let i = 0; i < dynamicProps.length; i++) {\r\n                const key = dynamicProps[i];\r\n                if (nextProps[key] !== prevProps[key]) {\r\n                    return true;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    else {\r\n        // this path is only taken by manually written render functions\r\n        // so presence of any children leads to a forced update\r\n        if (prevChildren || nextChildren) {\r\n            if (!nextChildren || !nextChildren.$stable) {\r\n                return true;\r\n            }\r\n        }\r\n        if (prevProps === nextProps) {\r\n            return false;\r\n        }\r\n        if (!prevProps) {\r\n            return !!nextProps;\r\n        }\r\n        if (!nextProps) {\r\n            return true;\r\n        }\r\n        return hasPropsChanged(prevProps, nextProps);\r\n    }\r\n    return false;\r\n}\r\nfunction hasPropsChanged(prevProps, nextProps) {\r\n    const nextKeys = Object.keys(nextProps);\r\n    if (nextKeys.length !== Object.keys(prevProps).length) {\r\n        return true;\r\n    }\r\n    for (let i = 0; i < nextKeys.length; i++) {\r\n        const key = nextKeys[i];\r\n        if (nextProps[key] !== prevProps[key]) {\r\n            return true;\r\n        }\r\n    }\r\n    return false;\r\n}\r\nfunction updateHOCHostEl({ vnode, parent }, el // HostNode\r\n) {\r\n    while (parent && parent.subTree === vnode) {\r\n        (vnode = parent.vnode).el = el;\r\n        parent = parent.parent;\r\n    }\r\n}\n\nconst isSuspense = (type) => type.__isSuspense;\r\n// Suspense exposes a component-like API, and is treated like a component\r\n// in the compiler, but internally it's a special built-in type that hooks\r\n// directly into the renderer.\r\nconst SuspenseImpl = {\r\n    // In order to make Suspense tree-shakable, we need to avoid importing it\r\n    // directly in the renderer. The renderer checks for the __isSuspense flag\r\n    // on a vnode's type and calls the `process` method, passing in renderer\r\n    // internals.\r\n    __isSuspense: true,\r\n    process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, \r\n    // platform-specific impl passed from renderer\r\n    rendererInternals) {\r\n        if (n1 == null) {\r\n            mountSuspense(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, rendererInternals);\r\n        }\r\n        else {\r\n            patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, optimized, rendererInternals);\r\n        }\r\n    },\r\n    hydrate: hydrateSuspense\r\n};\r\n// Force-casted public typing for h and TSX props inference\r\nconst Suspense = ( SuspenseImpl\r\n    );\r\nfunction mountSuspense(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, rendererInternals) {\r\n    const { p: patch, o: { createElement } } = rendererInternals;\r\n    const hiddenContainer = createElement('div');\r\n    const suspense = (n2.suspense = createSuspenseBoundary(n2, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, optimized, rendererInternals));\r\n    // start mounting the content subtree in an off-dom container\r\n    patch(null, suspense.subTree, hiddenContainer, null, parentComponent, suspense, isSVG, optimized);\r\n    // now check if we have encountered any async deps\r\n    if (suspense.deps > 0) {\r\n        // mount the fallback tree\r\n        patch(null, suspense.fallbackTree, container, anchor, parentComponent, null, // fallback tree will not have suspense context\r\n        isSVG, optimized);\r\n        n2.el = suspense.fallbackTree.el;\r\n    }\r\n    else {\r\n        // Suspense has no async deps. Just resolve.\r\n        suspense.resolve();\r\n    }\r\n}\r\nfunction patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, optimized, { p: patch }) {\r\n    const suspense = (n2.suspense = n1.suspense);\r\n    suspense.vnode = n2;\r\n    const { content, fallback } = normalizeSuspenseChildren(n2);\r\n    const oldSubTree = suspense.subTree;\r\n    const oldFallbackTree = suspense.fallbackTree;\r\n    if (!suspense.isResolved) {\r\n        patch(oldSubTree, content, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, optimized);\r\n        if (suspense.deps > 0) {\r\n            // still pending. patch the fallback tree.\r\n            patch(oldFallbackTree, fallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context\r\n            isSVG, optimized);\r\n            n2.el = fallback.el;\r\n        }\r\n        // If deps somehow becomes 0 after the patch it means the patch caused an\r\n        // async dep component to unmount and removed its dep. It will cause the\r\n        // suspense to resolve and we don't need to do anything here.\r\n    }\r\n    else {\r\n        // just normal patch inner content as a fragment\r\n        patch(oldSubTree, content, container, anchor, parentComponent, suspense, isSVG, optimized);\r\n        n2.el = content.el;\r\n    }\r\n    suspense.subTree = content;\r\n    suspense.fallbackTree = fallback;\r\n}\r\nlet hasWarned = false;\r\nfunction createSuspenseBoundary(vnode, parent, parentComponent, container, hiddenContainer, anchor, isSVG, optimized, rendererInternals, isHydrating = false) {\r\n    /* istanbul ignore if */\r\n    if ((process.env.NODE_ENV !== 'production') && !false && !hasWarned) {\r\n        hasWarned = true;\r\n        // @ts-ignore `console.info` cannot be null error\r\n        console[console.info ? 'info' : 'log'](`<Suspense> is an experimental feature and its API will likely change.`);\r\n    }\r\n    const { p: patch, m: move, um: unmount, n: next, o: { parentNode } } = rendererInternals;\r\n    const getCurrentTree = () => suspense.isResolved || suspense.isHydrating\r\n        ? suspense.subTree\r\n        : suspense.fallbackTree;\r\n    const { content, fallback } = normalizeSuspenseChildren(vnode);\r\n    const suspense = {\r\n        vnode,\r\n        parent,\r\n        parentComponent,\r\n        isSVG,\r\n        optimized,\r\n        container,\r\n        hiddenContainer,\r\n        anchor,\r\n        deps: 0,\r\n        subTree: content,\r\n        fallbackTree: fallback,\r\n        isHydrating,\r\n        isResolved: false,\r\n        isUnmounted: false,\r\n        effects: [],\r\n        resolve() {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                if (suspense.isResolved) {\r\n                    throw new Error(`resolveSuspense() is called on an already resolved suspense boundary.`);\r\n                }\r\n                if (suspense.isUnmounted) {\r\n                    throw new Error(`resolveSuspense() is called on an already unmounted suspense boundary.`);\r\n                }\r\n            }\r\n            const { vnode, subTree, fallbackTree, effects, parentComponent, container } = suspense;\r\n            if (suspense.isHydrating) {\r\n                suspense.isHydrating = false;\r\n            }\r\n            else {\r\n                // this is initial anchor on mount\r\n                let { anchor } = suspense;\r\n                // unmount fallback tree\r\n                if (fallbackTree.el) {\r\n                    // if the fallback tree was mounted, it may have been moved\r\n                    // as part of a parent suspense. get the latest anchor for insertion\r\n                    anchor = next(fallbackTree);\r\n                    unmount(fallbackTree, parentComponent, suspense, true);\r\n                }\r\n                // move content from off-dom container to actual container\r\n                move(subTree, container, anchor, 0 /* ENTER */);\r\n            }\r\n            const el = (vnode.el = subTree.el);\r\n            // suspense as the root node of a component...\r\n            if (parentComponent && parentComponent.subTree === vnode) {\r\n                parentComponent.vnode.el = el;\r\n                updateHOCHostEl(parentComponent, el);\r\n            }\r\n            // check if there is a pending parent suspense\r\n            let parent = suspense.parent;\r\n            let hasUnresolvedAncestor = false;\r\n            while (parent) {\r\n                if (!parent.isResolved) {\r\n                    // found a pending parent suspense, merge buffered post jobs\r\n                    // into that parent\r\n                    parent.effects.push(...effects);\r\n                    hasUnresolvedAncestor = true;\r\n                    break;\r\n                }\r\n                parent = parent.parent;\r\n            }\r\n            // no pending parent suspense, flush all jobs\r\n            if (!hasUnresolvedAncestor) {\r\n                queuePostFlushCb(effects);\r\n            }\r\n            suspense.isResolved = true;\r\n            suspense.effects = [];\r\n            // invoke @resolve event\r\n            const onResolve = vnode.props && vnode.props.onResolve;\r\n            if (isFunction(onResolve)) {\r\n                onResolve();\r\n            }\r\n        },\r\n        recede() {\r\n            suspense.isResolved = false;\r\n            const { vnode, subTree, fallbackTree, parentComponent, container, hiddenContainer, isSVG, optimized } = suspense;\r\n            // move content tree back to the off-dom container\r\n            const anchor = next(subTree);\r\n            move(subTree, hiddenContainer, null, 1 /* LEAVE */);\r\n            // remount the fallback tree\r\n            patch(null, fallbackTree, container, anchor, parentComponent, null, // fallback tree will not have suspense context\r\n            isSVG, optimized);\r\n            const el = (vnode.el = fallbackTree.el);\r\n            // suspense as the root node of a component...\r\n            if (parentComponent && parentComponent.subTree === vnode) {\r\n                parentComponent.vnode.el = el;\r\n                updateHOCHostEl(parentComponent, el);\r\n            }\r\n            // invoke @recede event\r\n            const onRecede = vnode.props && vnode.props.onRecede;\r\n            if (isFunction(onRecede)) {\r\n                onRecede();\r\n            }\r\n        },\r\n        move(container, anchor, type) {\r\n            move(getCurrentTree(), container, anchor, type);\r\n            suspense.container = container;\r\n        },\r\n        next() {\r\n            return next(getCurrentTree());\r\n        },\r\n        registerDep(instance, setupRenderEffect) {\r\n            // suspense is already resolved, need to recede.\r\n            // use queueJob so it's handled synchronously after patching the current\r\n            // suspense tree\r\n            if (suspense.isResolved) {\r\n                queueJob(() => {\r\n                    suspense.recede();\r\n                });\r\n            }\r\n            const hydratedEl = instance.vnode.el;\r\n            suspense.deps++;\r\n            instance\r\n                .asyncDep.catch(err => {\r\n                handleError(err, instance, 0 /* SETUP_FUNCTION */);\r\n            })\r\n                .then(asyncSetupResult => {\r\n                // retry when the setup() promise resolves.\r\n                // component may have been unmounted before resolve.\r\n                if (instance.isUnmounted || suspense.isUnmounted) {\r\n                    return;\r\n                }\r\n                suspense.deps--;\r\n                // retry from this component\r\n                instance.asyncResolved = true;\r\n                const { vnode } = instance;\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    pushWarningContext(vnode);\r\n                }\r\n                handleSetupResult(instance, asyncSetupResult);\r\n                if (hydratedEl) {\r\n                    // vnode may have been replaced if an update happened before the\r\n                    // async dep is resolved.\r\n                    vnode.el = hydratedEl;\r\n                }\r\n                setupRenderEffect(instance, vnode, \r\n                // component may have been moved before resolve.\r\n                // if this is not a hydration, instance.subTree will be the comment\r\n                // placeholder.\r\n                hydratedEl\r\n                    ? parentNode(hydratedEl)\r\n                    : parentNode(instance.subTree.el), \r\n                // anchor will not be used if this is hydration, so only need to\r\n                // consider the comment placeholder case.\r\n                hydratedEl ? null : next(instance.subTree), suspense, isSVG, optimized);\r\n                updateHOCHostEl(instance, vnode.el);\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    popWarningContext();\r\n                }\r\n                if (suspense.deps === 0) {\r\n                    suspense.resolve();\r\n                }\r\n            });\r\n        },\r\n        unmount(parentSuspense, doRemove) {\r\n            suspense.isUnmounted = true;\r\n            unmount(suspense.subTree, parentComponent, parentSuspense, doRemove);\r\n            if (!suspense.isResolved) {\r\n                unmount(suspense.fallbackTree, parentComponent, parentSuspense, doRemove);\r\n            }\r\n        }\r\n    };\r\n    return suspense;\r\n}\r\nfunction hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG, optimized, rendererInternals, hydrateNode) {\r\n    /* eslint-disable no-restricted-globals */\r\n    const suspense = (vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, node.parentNode, document.createElement('div'), null, isSVG, optimized, rendererInternals, true /* hydrating */));\r\n    // there are two possible scenarios for server-rendered suspense:\r\n    // - success: ssr content should be fully resolved\r\n    // - failure: ssr content should be the fallback branch.\r\n    // however, on the client we don't really know if it has failed or not\r\n    // attempt to hydrate the DOM assuming it has succeeded, but we still\r\n    // need to construct a suspense boundary first\r\n    const result = hydrateNode(node, suspense.subTree, parentComponent, suspense, optimized);\r\n    if (suspense.deps === 0) {\r\n        suspense.resolve();\r\n    }\r\n    return result;\r\n    /* eslint-enable no-restricted-globals */\r\n}\r\nfunction normalizeSuspenseChildren(vnode) {\r\n    const { shapeFlag, children } = vnode;\r\n    if (shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n        const { default: d, fallback } = children;\r\n        return {\r\n            content: normalizeVNode(isFunction(d) ? d() : d),\r\n            fallback: normalizeVNode(isFunction(fallback) ? fallback() : fallback)\r\n        };\r\n    }\r\n    else {\r\n        return {\r\n            content: normalizeVNode(children),\r\n            fallback: normalizeVNode(null)\r\n        };\r\n    }\r\n}\r\nfunction queueEffectWithSuspense(fn, suspense) {\r\n    if (suspense && !suspense.isResolved) {\r\n        if (isArray(fn)) {\r\n            suspense.effects.push(...fn);\r\n        }\r\n        else {\r\n            suspense.effects.push(fn);\r\n        }\r\n    }\r\n    else {\r\n        queuePostFlushCb(fn);\r\n    }\r\n}\n\n/**\r\n * Wrap a slot function to memoize current rendering instance\r\n * @private\r\n */\r\nfunction withCtx(fn, ctx = currentRenderingInstance) {\r\n    if (!ctx)\r\n        return fn;\r\n    return function renderFnWithContext() {\r\n        const owner = currentRenderingInstance;\r\n        setCurrentRenderingInstance(ctx);\r\n        const res = fn.apply(null, arguments);\r\n        setCurrentRenderingInstance(owner);\r\n        return res;\r\n    };\r\n}\n\n// SFC scoped style ID management.\r\nlet currentScopeId = null;\r\nconst scopeIdStack = [];\r\n/**\r\n * @private\r\n */\r\nfunction pushScopeId(id) {\r\n    scopeIdStack.push((currentScopeId = id));\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction popScopeId() {\r\n    scopeIdStack.pop();\r\n    currentScopeId = scopeIdStack[scopeIdStack.length - 1] || null;\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction withScopeId(id) {\r\n    return ((fn) => withCtx(function () {\r\n        pushScopeId(id);\r\n        const res = fn.apply(this, arguments);\r\n        popScopeId();\r\n        return res;\r\n    }));\r\n}\n\nconst isTeleport = (type) => type.__isTeleport;\r\nconst isTeleportDisabled = (props) => props && (props.disabled || props.disabled === '');\r\nconst resolveTarget = (props, select) => {\r\n    const targetSelector = props && props.to;\r\n    if (isString(targetSelector)) {\r\n        if (!select) {\r\n            (process.env.NODE_ENV !== 'production') &&\r\n                warn(`Current renderer does not support string target for Teleports. ` +\r\n                    `(missing querySelector renderer option)`);\r\n            return null;\r\n        }\r\n        else {\r\n            const target = select(targetSelector);\r\n            if (!target) {\r\n                (process.env.NODE_ENV !== 'production') &&\r\n                    warn(`Failed to locate Teleport target with selector \"${targetSelector}\". ` +\r\n                        `Note the target element must exist before the component is mounted - ` +\r\n                        `i.e. the target cannot be rendered by the component itself, and ` +\r\n                        `ideally should be outside of the entire Vue component tree.`);\r\n            }\r\n            return target;\r\n        }\r\n    }\r\n    else {\r\n        if ((process.env.NODE_ENV !== 'production') && !targetSelector) {\r\n            warn(`Invalid Teleport target: ${targetSelector}`);\r\n        }\r\n        return targetSelector;\r\n    }\r\n};\r\nconst TeleportImpl = {\r\n    __isTeleport: true,\r\n    process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals) {\r\n        const { mc: mountChildren, pc: patchChildren, pbc: patchBlockChildren, o: { insert, querySelector, createText, createComment } } = internals;\r\n        const disabled = isTeleportDisabled(n2.props);\r\n        const { shapeFlag, children } = n2;\r\n        if (n1 == null) {\r\n            // insert anchors in the main view\r\n            const placeholder = (n2.el = (process.env.NODE_ENV !== 'production')\r\n                ? createComment('teleport start')\r\n                : createText(''));\r\n            const mainAnchor = (n2.anchor = (process.env.NODE_ENV !== 'production')\r\n                ? createComment('teleport end')\r\n                : createText(''));\r\n            insert(placeholder, container, anchor);\r\n            insert(mainAnchor, container, anchor);\r\n            const target = (n2.target = resolveTarget(n2.props, querySelector));\r\n            const targetAnchor = (n2.targetAnchor = createText(''));\r\n            if (target) {\r\n                insert(targetAnchor, target);\r\n            }\r\n            else if ((process.env.NODE_ENV !== 'production')) {\r\n                warn('Invalid Teleport target on mount:', target, `(${typeof target})`);\r\n            }\r\n            const mount = (container, anchor) => {\r\n                // Teleport *always* has Array children. This is enforced in both the\r\n                // compiler and vnode children normalization.\r\n                if (shapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n                    mountChildren(children, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n                }\r\n            };\r\n            if (disabled) {\r\n                mount(container, mainAnchor);\r\n            }\r\n            else if (target) {\r\n                mount(target, targetAnchor);\r\n            }\r\n        }\r\n        else {\r\n            // update content\r\n            n2.el = n1.el;\r\n            const mainAnchor = (n2.anchor = n1.anchor);\r\n            const target = (n2.target = n1.target);\r\n            const targetAnchor = (n2.targetAnchor = n1.targetAnchor);\r\n            const wasDisabled = isTeleportDisabled(n1.props);\r\n            const currentContainer = wasDisabled ? container : target;\r\n            const currentAnchor = wasDisabled ? mainAnchor : targetAnchor;\r\n            if (n2.dynamicChildren) {\r\n                // fast path when the teleport happens to be a block root\r\n                patchBlockChildren(n1.dynamicChildren, n2.dynamicChildren, currentContainer, parentComponent, parentSuspense, isSVG);\r\n                if (n2.patchFlag > 0 && n2.shapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n                    const oldChildren = n1.children;\r\n                    const children = n2.children;\r\n                    for (let i = 0; i < children.length; i++) {\r\n                        children[i].el = oldChildren[i].el;\r\n                    }\r\n                }\r\n            }\r\n            else if (!optimized) {\r\n                patchChildren(n1, n2, currentContainer, currentAnchor, parentComponent, parentSuspense, isSVG);\r\n            }\r\n            if (disabled) {\r\n                if (!wasDisabled) {\r\n                    // enabled -> disabled\r\n                    // move into main container\r\n                    moveTeleport(n2, container, mainAnchor, internals, 1 /* TOGGLE */);\r\n                }\r\n            }\r\n            else {\r\n                // target changed\r\n                if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {\r\n                    const nextTarget = (n2.target = resolveTarget(n2.props, querySelector));\r\n                    if (nextTarget) {\r\n                        moveTeleport(n2, nextTarget, null, internals, 0 /* TARGET_CHANGE */);\r\n                    }\r\n                    else if ((process.env.NODE_ENV !== 'production')) {\r\n                        warn('Invalid Teleport target on update:', target, `(${typeof target})`);\r\n                    }\r\n                }\r\n                else if (wasDisabled) {\r\n                    // disabled -> enabled\r\n                    // move into teleport target\r\n                    moveTeleport(n2, target, targetAnchor, internals, 1 /* TOGGLE */);\r\n                }\r\n            }\r\n        }\r\n    },\r\n    remove(vnode, { r: remove, o: { remove: hostRemove } }) {\r\n        const { shapeFlag, children, anchor } = vnode;\r\n        hostRemove(anchor);\r\n        if (shapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n            for (let i = 0; i < children.length; i++) {\r\n                remove(children[i]);\r\n            }\r\n        }\r\n    },\r\n    move: moveTeleport,\r\n    hydrate: hydrateTeleport\r\n};\r\nfunction moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2 /* REORDER */) {\r\n    // move target anchor if this is a target change.\r\n    if (moveType === 0 /* TARGET_CHANGE */) {\r\n        insert(vnode.targetAnchor, container, parentAnchor);\r\n    }\r\n    const { el, anchor, shapeFlag, children, props } = vnode;\r\n    const isReorder = moveType === 2 /* REORDER */;\r\n    // move main view anchor if this is a re-order.\r\n    if (isReorder) {\r\n        insert(el, container, parentAnchor);\r\n    }\r\n    // if this is a re-order and teleport is enabled (content is in target)\r\n    // do not move children. So the opposite is: only move children if this\r\n    // is not a reorder, or the teleport is disabled\r\n    if (!isReorder || isTeleportDisabled(props)) {\r\n        // Teleport has either Array children or no children.\r\n        if (shapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n            for (let i = 0; i < children.length; i++) {\r\n                move(children[i], container, parentAnchor, 2 /* REORDER */);\r\n            }\r\n        }\r\n    }\r\n    // move main view anchor if this is a re-order.\r\n    if (isReorder) {\r\n        insert(anchor, container, parentAnchor);\r\n    }\r\n}\r\nfunction hydrateTeleport(node, vnode, parentComponent, parentSuspense, optimized, { o: { nextSibling, parentNode, querySelector } }, hydrateChildren) {\r\n    const target = (vnode.target = resolveTarget(vnode.props, querySelector));\r\n    if (target) {\r\n        // if multiple teleports rendered to the same target element, we need to\r\n        // pick up from where the last teleport finished instead of the first node\r\n        const targetNode = target._lpa || target.firstChild;\r\n        if (vnode.shapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n            if (isTeleportDisabled(vnode.props)) {\r\n                vnode.anchor = hydrateChildren(nextSibling(node), vnode, parentNode(node), parentComponent, parentSuspense, optimized);\r\n                vnode.targetAnchor = targetNode;\r\n            }\r\n            else {\r\n                vnode.anchor = nextSibling(node);\r\n                vnode.targetAnchor = hydrateChildren(targetNode, vnode, target, parentComponent, parentSuspense, optimized);\r\n            }\r\n            target._lpa =\r\n                vnode.targetAnchor && nextSibling(vnode.targetAnchor);\r\n        }\r\n    }\r\n    return vnode.anchor && nextSibling(vnode.anchor);\r\n}\r\n// Force-casted public typing for h and TSX props inference\r\nconst Teleport = TeleportImpl;\n\nconst COMPONENTS = 'components';\r\nconst DIRECTIVES = 'directives';\r\n/**\r\n * @private\r\n */\r\nfunction resolveComponent(name) {\r\n    return resolveAsset(COMPONENTS, name) || name;\r\n}\r\nconst NULL_DYNAMIC_COMPONENT = Symbol();\r\n/**\r\n * @private\r\n */\r\nfunction resolveDynamicComponent(component) {\r\n    if (isString(component)) {\r\n        return resolveAsset(COMPONENTS, component, false) || component;\r\n    }\r\n    else {\r\n        // invalid types will fallthrough to createVNode and raise warning\r\n        return (component || NULL_DYNAMIC_COMPONENT);\r\n    }\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction resolveDirective(name) {\r\n    return resolveAsset(DIRECTIVES, name);\r\n}\r\n// implementation\r\nfunction resolveAsset(type, name, warnMissing = true) {\r\n    const instance = currentRenderingInstance || currentInstance;\r\n    if (instance) {\r\n        const Component = instance.type;\r\n        // self name has highest priority\r\n        if (type === COMPONENTS) {\r\n            const selfName = Component.displayName || Component.name;\r\n            if (selfName &&\r\n                (selfName === name ||\r\n                    selfName === camelize(name) ||\r\n                    selfName === capitalize(camelize(name)))) {\r\n                return Component;\r\n            }\r\n        }\r\n        const res = \r\n        // local registration\r\n        resolve(Component[type], name) ||\r\n            // global registration\r\n            resolve(instance.appContext[type], name);\r\n        if ((process.env.NODE_ENV !== 'production') && warnMissing && !res) {\r\n            warn(`Failed to resolve ${type.slice(0, -1)}: ${name}`);\r\n        }\r\n        return res;\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        warn(`resolve${capitalize(type.slice(0, -1))} ` +\r\n            `can only be used in render() or setup().`);\r\n    }\r\n}\r\nfunction resolve(registry, name) {\r\n    return (registry &&\r\n        (registry[name] ||\r\n            registry[camelize(name)] ||\r\n            registry[capitalize(camelize(name))]));\r\n}\n\nconst Fragment = Symbol((process.env.NODE_ENV !== 'production') ? 'Fragment' : undefined);\r\nconst Text = Symbol((process.env.NODE_ENV !== 'production') ? 'Text' : undefined);\r\nconst Comment = Symbol((process.env.NODE_ENV !== 'production') ? 'Comment' : undefined);\r\nconst Static = Symbol((process.env.NODE_ENV !== 'production') ? 'Static' : undefined);\r\n// Since v-if and v-for are the two possible ways node structure can dynamically\r\n// change, once we consider v-if branches and each v-for fragment a block, we\r\n// can divide a template into nested blocks, and within each block the node\r\n// structure would be stable. This allows us to skip most children diffing\r\n// and only worry about the dynamic nodes (indicated by patch flags).\r\nconst blockStack = [];\r\nlet currentBlock = null;\r\n/**\r\n * Open a block.\r\n * This must be called before `createBlock`. It cannot be part of `createBlock`\r\n * because the children of the block are evaluated before `createBlock` itself\r\n * is called. The generated code typically looks like this:\r\n *\r\n * ```js\r\n * function render() {\r\n *   return (openBlock(),createBlock('div', null, [...]))\r\n * }\r\n * ```\r\n * disableTracking is true when creating a v-for fragment block, since a v-for\r\n * fragment always diffs its children.\r\n *\r\n * @private\r\n */\r\nfunction openBlock(disableTracking = false) {\r\n    blockStack.push((currentBlock = disableTracking ? null : []));\r\n}\r\n// Whether we should be tracking dynamic child nodes inside a block.\r\n// Only tracks when this value is > 0\r\n// We are not using a simple boolean because this value may need to be\r\n// incremented/decremented by nested usage of v-once (see below)\r\nlet shouldTrack = 1;\r\n/**\r\n * Block tracking sometimes needs to be disabled, for example during the\r\n * creation of a tree that needs to be cached by v-once. The compiler generates\r\n * code like this:\r\n *\r\n * ``` js\r\n * _cache[1] || (\r\n *   setBlockTracking(-1),\r\n *   _cache[1] = createVNode(...),\r\n *   setBlockTracking(1),\r\n *   _cache[1]\r\n * )\r\n * ```\r\n *\r\n * @private\r\n */\r\nfunction setBlockTracking(value) {\r\n    shouldTrack += value;\r\n}\r\n/**\r\n * Create a block root vnode. Takes the same exact arguments as `createVNode`.\r\n * A block root keeps track of dynamic nodes within the block in the\r\n * `dynamicChildren` array.\r\n *\r\n * @private\r\n */\r\nfunction createBlock(type, props, children, patchFlag, dynamicProps) {\r\n    const vnode = createVNode(type, props, children, patchFlag, dynamicProps, true /* isBlock: prevent a block from tracking itself */);\r\n    // save current block children on the block vnode\r\n    vnode.dynamicChildren = currentBlock || EMPTY_ARR;\r\n    // close block\r\n    blockStack.pop();\r\n    currentBlock = blockStack[blockStack.length - 1] || null;\r\n    // a block is always going to be patched, so track it as a child of its\r\n    // parent block\r\n    if (currentBlock) {\r\n        currentBlock.push(vnode);\r\n    }\r\n    return vnode;\r\n}\r\nfunction isVNode(value) {\r\n    return value ? value.__v_isVNode === true : false;\r\n}\r\nfunction isSameVNodeType(n1, n2) {\r\n    if ((process.env.NODE_ENV !== 'production') &&\r\n        n2.shapeFlag & 6 /* COMPONENT */ &&\r\n        hmrDirtyComponents.has(n2.type)) {\r\n        // HMR only: if the component has been hot-updated, force a reload.\r\n        return false;\r\n    }\r\n    return n1.type === n2.type && n1.key === n2.key;\r\n}\r\nlet vnodeArgsTransformer;\r\n/**\r\n * Internal API for registering an arguments transform for createVNode\r\n * used for creating stubs in the test-utils\r\n * It is *internal* but needs to be exposed for test-utils to pick up proper\r\n * typings\r\n */\r\nfunction transformVNodeArgs(transformer) {\r\n    vnodeArgsTransformer = transformer;\r\n}\r\nconst createVNodeWithArgsTransform = (...args) => {\r\n    return _createVNode(...(vnodeArgsTransformer\r\n        ? vnodeArgsTransformer(args, currentRenderingInstance)\r\n        : args));\r\n};\r\nconst InternalObjectKey = `__vInternal`;\r\nconst normalizeKey = ({ key }) => key != null ? key : null;\r\nconst normalizeRef = ({ ref }) => {\r\n    return (ref != null\r\n        ? isArray(ref)\r\n            ? ref\r\n            : [currentRenderingInstance, ref]\r\n        : null);\r\n};\r\nconst createVNode = ((process.env.NODE_ENV !== 'production')\r\n    ? createVNodeWithArgsTransform\r\n    : _createVNode);\r\nfunction _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {\r\n    if (!type || type === NULL_DYNAMIC_COMPONENT) {\r\n        if ((process.env.NODE_ENV !== 'production') && !type) {\r\n            warn(`Invalid vnode type when creating vnode: ${type}.`);\r\n        }\r\n        type = Comment;\r\n    }\r\n    if (isVNode(type)) {\r\n        const cloned = cloneVNode(type, props);\r\n        if (children) {\r\n            normalizeChildren(cloned, children);\r\n        }\r\n        return cloned;\r\n    }\r\n    // class component normalization.\r\n    if (isFunction(type) && '__vccOpts' in type) {\r\n        type = type.__vccOpts;\r\n    }\r\n    // class & style normalization.\r\n    if (props) {\r\n        // for reactive or proxy objects, we need to clone it to enable mutation.\r\n        if (isProxy(props) || InternalObjectKey in props) {\r\n            props = extend({}, props);\r\n        }\r\n        let { class: klass, style } = props;\r\n        if (klass && !isString(klass)) {\r\n            props.class = normalizeClass(klass);\r\n        }\r\n        if (isObject(style)) {\r\n            // reactive state objects need to be cloned since they are likely to be\r\n            // mutated\r\n            if (isProxy(style) && !isArray(style)) {\r\n                style = extend({}, style);\r\n            }\r\n            props.style = normalizeStyle(style);\r\n        }\r\n    }\r\n    // encode the vnode type information into a bitmap\r\n    const shapeFlag = isString(type)\r\n        ? 1 /* ELEMENT */\r\n        :  isSuspense(type)\r\n            ? 128 /* SUSPENSE */\r\n            : isTeleport(type)\r\n                ? 64 /* TELEPORT */\r\n                : isObject(type)\r\n                    ? 4 /* STATEFUL_COMPONENT */\r\n                    : isFunction(type)\r\n                        ? 2 /* FUNCTIONAL_COMPONENT */\r\n                        : 0;\r\n    if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {\r\n        type = toRaw(type);\r\n        warn(`Vue received a Component which was made a reactive object. This can ` +\r\n            `lead to unnecessary performance overhead, and should be avoided by ` +\r\n            `marking the component with \\`markRaw\\` or using \\`shallowRef\\` ` +\r\n            `instead of \\`ref\\`.`, `\\nComponent that was made reactive: `, type);\r\n    }\r\n    const vnode = {\r\n        __v_isVNode: true,\r\n        __v_skip: true,\r\n        type,\r\n        props,\r\n        key: props && normalizeKey(props),\r\n        ref: props && normalizeRef(props),\r\n        scopeId: currentScopeId,\r\n        children: null,\r\n        component: null,\r\n        suspense: null,\r\n        dirs: null,\r\n        transition: null,\r\n        el: null,\r\n        anchor: null,\r\n        target: null,\r\n        targetAnchor: null,\r\n        staticCount: 0,\r\n        shapeFlag,\r\n        patchFlag,\r\n        dynamicProps,\r\n        dynamicChildren: null,\r\n        appContext: null\r\n    };\r\n    // validate key\r\n    if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) {\r\n        warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);\r\n    }\r\n    normalizeChildren(vnode, children);\r\n    // presence of a patch flag indicates this node needs patching on updates.\r\n    // component nodes also should always be patched, because even if the\r\n    // component doesn't need to update, it needs to persist the instance on to\r\n    // the next vnode so that it can be properly unmounted later.\r\n    if (shouldTrack > 0 &&\r\n        !isBlockNode &&\r\n        currentBlock &&\r\n        // the EVENTS flag is only for hydration and if it is the only flag, the\r\n        // vnode should not be considered dynamic due to handler caching.\r\n        patchFlag !== 32 /* HYDRATE_EVENTS */ &&\r\n        (patchFlag > 0 || shapeFlag & 6 /* COMPONENT */)) {\r\n        currentBlock.push(vnode);\r\n    }\r\n    return vnode;\r\n}\r\nfunction cloneVNode(vnode, extraProps) {\r\n    // This is intentionally NOT using spread or extend to avoid the runtime\r\n    // key enumeration cost.\r\n    const { props, patchFlag } = vnode;\r\n    const mergedProps = extraProps\r\n        ? props\r\n            ? mergeProps(props, extraProps)\r\n            : extend({}, extraProps)\r\n        : props;\r\n    return {\r\n        __v_isVNode: true,\r\n        __v_skip: true,\r\n        type: vnode.type,\r\n        props: mergedProps,\r\n        key: mergedProps && normalizeKey(mergedProps),\r\n        ref: extraProps && extraProps.ref ? normalizeRef(extraProps) : vnode.ref,\r\n        scopeId: vnode.scopeId,\r\n        children: vnode.children,\r\n        target: vnode.target,\r\n        targetAnchor: vnode.targetAnchor,\r\n        staticCount: vnode.staticCount,\r\n        shapeFlag: vnode.shapeFlag,\r\n        // if the vnode is cloned with extra props, we can no longer assume its\r\n        // existing patch flag to be reliable and need to add the FULL_PROPS flag.\r\n        // note: perserve flag for fragments since they use the flag for children\r\n        // fast paths only.\r\n        patchFlag: extraProps && vnode.type !== Fragment\r\n            ? patchFlag === -1 // hoisted node\r\n                ? 16 /* FULL_PROPS */\r\n                : patchFlag | 16 /* FULL_PROPS */\r\n            : patchFlag,\r\n        dynamicProps: vnode.dynamicProps,\r\n        dynamicChildren: vnode.dynamicChildren,\r\n        appContext: vnode.appContext,\r\n        dirs: vnode.dirs,\r\n        transition: vnode.transition,\r\n        // These should technically only be non-null on mounted VNodes. However,\r\n        // they *should* be copied for kept-alive vnodes. So we just always copy\r\n        // them since them being non-null during a mount doesn't affect the logic as\r\n        // they will simply be overwritten.\r\n        component: vnode.component,\r\n        suspense: vnode.suspense,\r\n        el: vnode.el,\r\n        anchor: vnode.anchor\r\n    };\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createTextVNode(text = ' ', flag = 0) {\r\n    return createVNode(Text, null, text, flag);\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createStaticVNode(content, numberOfNodes) {\r\n    // A static vnode can contain multiple stringified elements, and the number\r\n    // of elements is necessary for hydration.\r\n    const vnode = createVNode(Static, null, content);\r\n    vnode.staticCount = numberOfNodes;\r\n    return vnode;\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createCommentVNode(text = '', \r\n// when used as the v-else branch, the comment node must be created as a\r\n// block to ensure correct updates.\r\nasBlock = false) {\r\n    return asBlock\r\n        ? (openBlock(), createBlock(Comment, null, text))\r\n        : createVNode(Comment, null, text);\r\n}\r\nfunction normalizeVNode(child) {\r\n    if (child == null || typeof child === 'boolean') {\r\n        // empty placeholder\r\n        return createVNode(Comment);\r\n    }\r\n    else if (isArray(child)) {\r\n        // fragment\r\n        return createVNode(Fragment, null, child);\r\n    }\r\n    else if (typeof child === 'object') {\r\n        // already vnode, this should be the most common since compiled templates\r\n        // always produce all-vnode children arrays\r\n        return child.el === null ? child : cloneVNode(child);\r\n    }\r\n    else {\r\n        // strings and numbers\r\n        return createVNode(Text, null, String(child));\r\n    }\r\n}\r\n// optimized normalization for template-compiled render fns\r\nfunction cloneIfMounted(child) {\r\n    return child.el === null ? child : cloneVNode(child);\r\n}\r\nfunction normalizeChildren(vnode, children) {\r\n    let type = 0;\r\n    const { shapeFlag } = vnode;\r\n    if (children == null) {\r\n        children = null;\r\n    }\r\n    else if (isArray(children)) {\r\n        type = 16 /* ARRAY_CHILDREN */;\r\n    }\r\n    else if (typeof children === 'object') {\r\n        // Normalize slot to plain children\r\n        if ((shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) &&\r\n            children.default) {\r\n            normalizeChildren(vnode, children.default());\r\n            return;\r\n        }\r\n        else {\r\n            type = 32 /* SLOTS_CHILDREN */;\r\n            const slotFlag = children._;\r\n            if (!slotFlag && !(InternalObjectKey in children)) {\r\n                children._ctx = currentRenderingInstance;\r\n            }\r\n            else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {\r\n                // a child component receives forwarded slots from the parent.\r\n                // its slot type is determined by its parent's slot type.\r\n                if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) {\r\n                    children._ = 2 /* DYNAMIC */;\r\n                    vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;\r\n                }\r\n                else {\r\n                    children._ = 1 /* STABLE */;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    else if (isFunction(children)) {\r\n        children = { default: children, _ctx: currentRenderingInstance };\r\n        type = 32 /* SLOTS_CHILDREN */;\r\n    }\r\n    else {\r\n        children = String(children);\r\n        // force teleport children to array so it can be moved around\r\n        if (shapeFlag & 64 /* TELEPORT */) {\r\n            type = 16 /* ARRAY_CHILDREN */;\r\n            children = [createTextVNode(children)];\r\n        }\r\n        else {\r\n            type = 8 /* TEXT_CHILDREN */;\r\n        }\r\n    }\r\n    vnode.children = children;\r\n    vnode.shapeFlag |= type;\r\n}\r\nfunction mergeProps(...args) {\r\n    const ret = extend({}, args[0]);\r\n    for (let i = 1; i < args.length; i++) {\r\n        const toMerge = args[i];\r\n        for (const key in toMerge) {\r\n            if (key === 'class') {\r\n                if (ret.class !== toMerge.class) {\r\n                    ret.class = normalizeClass([ret.class, toMerge.class]);\r\n                }\r\n            }\r\n            else if (key === 'style') {\r\n                ret.style = normalizeStyle([ret.style, toMerge.style]);\r\n            }\r\n            else if (isOn(key)) {\r\n                const existing = ret[key];\r\n                const incoming = toMerge[key];\r\n                if (existing !== incoming) {\r\n                    ret[key] = existing\r\n                        ? [].concat(existing, toMerge[key])\r\n                        : incoming;\r\n                }\r\n            }\r\n            else {\r\n                ret[key] = toMerge[key];\r\n            }\r\n        }\r\n    }\r\n    return ret;\r\n}\n\nfunction emit(instance, event, ...args) {\r\n    const props = instance.vnode.props || EMPTY_OBJ;\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        const options = normalizeEmitsOptions(instance.type);\r\n        if (options) {\r\n            if (!(event in options)) {\r\n                const propsOptions = normalizePropsOptions(instance.type)[0];\r\n                if (!propsOptions || !(`on` + capitalize(event) in propsOptions)) {\r\n                    warn(`Component emitted event \"${event}\" but it is neither declared in ` +\r\n                        `the emits option nor as an \"on${capitalize(event)}\" prop.`);\r\n                }\r\n            }\r\n            else {\r\n                const validator = options[event];\r\n                if (isFunction(validator)) {\r\n                    const isValid = validator(...args);\r\n                    if (!isValid) {\r\n                        warn(`Invalid event arguments: event validation failed for event \"${event}\".`);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n    let handlerName = `on${capitalize(event)}`;\r\n    let handler = props[handlerName];\r\n    // for v-model update:xxx events, also trigger kebab-case equivalent\r\n    // for props passed via kebab-case\r\n    if (!handler && event.startsWith('update:')) {\r\n        handlerName = `on${capitalize(hyphenate(event))}`;\r\n        handler = props[handlerName];\r\n    }\r\n    if (!handler) {\r\n        handler = props[handlerName + `Once`];\r\n        if (!instance.emitted) {\r\n            (instance.emitted = {})[handlerName] = true;\r\n        }\r\n        else if (instance.emitted[handlerName]) {\r\n            return;\r\n        }\r\n    }\r\n    if (handler) {\r\n        callWithAsyncErrorHandling(handler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args);\r\n    }\r\n}\r\nfunction normalizeEmitsOptions(comp) {\r\n    if (hasOwn(comp, '__emits')) {\r\n        return comp.__emits;\r\n    }\r\n    const raw = comp.emits;\r\n    let normalized = {};\r\n    // apply mixin/extends props\r\n    let hasExtends = false;\r\n    if (__VUE_OPTIONS_API__ && !isFunction(comp)) {\r\n        if (comp.extends) {\r\n            hasExtends = true;\r\n            extend(normalized, normalizeEmitsOptions(comp.extends));\r\n        }\r\n        if (comp.mixins) {\r\n            hasExtends = true;\r\n            comp.mixins.forEach(m => extend(normalized, normalizeEmitsOptions(m)));\r\n        }\r\n    }\r\n    if (!raw && !hasExtends) {\r\n        return (comp.__emits = undefined);\r\n    }\r\n    if (isArray(raw)) {\r\n        raw.forEach(key => (normalized[key] = null));\r\n    }\r\n    else {\r\n        extend(normalized, raw);\r\n    }\r\n    return (comp.__emits = normalized);\r\n}\r\n// Check if an incoming prop key is a declared emit event listener.\r\n// e.g. With `emits: { click: null }`, props named `onClick` and `onclick` are\r\n// both considered matched listeners.\r\nfunction isEmitListener(comp, key) {\r\n    let emits;\r\n    if (!isOn(key) || !(emits = normalizeEmitsOptions(comp))) {\r\n        return false;\r\n    }\r\n    key = key.replace(/Once$/, '');\r\n    return (hasOwn(emits, key[2].toLowerCase() + key.slice(3)) ||\r\n        hasOwn(emits, key.slice(2)));\r\n}\n\nfunction initProps(instance, rawProps, isStateful, // result of bitwise flag comparison\r\nisSSR = false) {\r\n    const props = {};\r\n    const attrs = {};\r\n    def(attrs, InternalObjectKey, 1);\r\n    setFullProps(instance, rawProps, props, attrs);\r\n    // validation\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        validateProps(props, instance.type);\r\n    }\r\n    if (isStateful) {\r\n        // stateful\r\n        instance.props = isSSR ? props : shallowReactive(props);\r\n    }\r\n    else {\r\n        if (!instance.type.props) {\r\n            // functional w/ optional props, props === attrs\r\n            instance.props = attrs;\r\n        }\r\n        else {\r\n            // functional w/ declared props\r\n            instance.props = props;\r\n        }\r\n    }\r\n    instance.attrs = attrs;\r\n}\r\nfunction updateProps(instance, rawProps, rawPrevProps, optimized) {\r\n    const { props, attrs, vnode: { patchFlag } } = instance;\r\n    const rawCurrentProps = toRaw(props);\r\n    const [options] = normalizePropsOptions(instance.type);\r\n    if ((optimized || patchFlag > 0) && !(patchFlag & 16 /* FULL_PROPS */)) {\r\n        if (patchFlag & 8 /* PROPS */) {\r\n            // Compiler-generated props & no keys change, just set the updated\r\n            // the props.\r\n            const propsToUpdate = instance.vnode.dynamicProps;\r\n            for (let i = 0; i < propsToUpdate.length; i++) {\r\n                const key = propsToUpdate[i];\r\n                // PROPS flag guarantees rawProps to be non-null\r\n                const value = rawProps[key];\r\n                if (options) {\r\n                    // attr / props separation was done on init and will be consistent\r\n                    // in this code path, so just check if attrs have it.\r\n                    if (hasOwn(attrs, key)) {\r\n                        attrs[key] = value;\r\n                    }\r\n                    else {\r\n                        const camelizedKey = camelize(key);\r\n                        props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value);\r\n                    }\r\n                }\r\n                else {\r\n                    attrs[key] = value;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    else {\r\n        // full props update.\r\n        setFullProps(instance, rawProps, props, attrs);\r\n        // in case of dynamic props, check if we need to delete keys from\r\n        // the props object\r\n        let kebabKey;\r\n        for (const key in rawCurrentProps) {\r\n            if (!rawProps ||\r\n                // for camelCase\r\n                (!hasOwn(rawProps, key) &&\r\n                    // it's possible the original props was passed in as kebab-case\r\n                    // and converted to camelCase (#955)\r\n                    ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey)))) {\r\n                if (options) {\r\n                    if (rawPrevProps &&\r\n                        // for camelCase\r\n                        (rawPrevProps[key] !== undefined ||\r\n                            // for kebab-case\r\n                            rawPrevProps[kebabKey] !== undefined)) {\r\n                        props[key] = resolvePropValue(options, rawProps || EMPTY_OBJ, key, undefined);\r\n                    }\r\n                }\r\n                else {\r\n                    delete props[key];\r\n                }\r\n            }\r\n        }\r\n        // in the case of functional component w/o props declaration, props and\r\n        // attrs point to the same object so it should already have been updated.\r\n        if (attrs !== rawCurrentProps) {\r\n            for (const key in attrs) {\r\n                if (!rawProps || !hasOwn(rawProps, key)) {\r\n                    delete attrs[key];\r\n                }\r\n            }\r\n        }\r\n    }\r\n    // trigger updates for $attrs in case it's used in component slots\r\n    trigger(instance, \"set\" /* SET */, '$attrs');\r\n    if ((process.env.NODE_ENV !== 'production') && rawProps) {\r\n        validateProps(props, instance.type);\r\n    }\r\n}\r\nfunction setFullProps(instance, rawProps, props, attrs) {\r\n    const [options, needCastKeys] = normalizePropsOptions(instance.type);\r\n    if (rawProps) {\r\n        for (const key in rawProps) {\r\n            const value = rawProps[key];\r\n            // key, ref are reserved and never passed down\r\n            if (isReservedProp(key)) {\r\n                continue;\r\n            }\r\n            // prop option names are camelized during normalization, so to support\r\n            // kebab -> camel conversion here we need to camelize the key.\r\n            let camelKey;\r\n            if (options && hasOwn(options, (camelKey = camelize(key)))) {\r\n                props[camelKey] = value;\r\n            }\r\n            else if (!isEmitListener(instance.type, key)) {\r\n                // Any non-declared (either as a prop or an emitted event) props are put\r\n                // into a separate `attrs` object for spreading. Make sure to preserve\r\n                // original key casing\r\n                attrs[key] = value;\r\n            }\r\n        }\r\n    }\r\n    if (needCastKeys) {\r\n        const rawCurrentProps = toRaw(props);\r\n        for (let i = 0; i < needCastKeys.length; i++) {\r\n            const key = needCastKeys[i];\r\n            props[key] = resolvePropValue(options, rawCurrentProps, key, rawCurrentProps[key]);\r\n        }\r\n    }\r\n}\r\nfunction resolvePropValue(options, props, key, value) {\r\n    const opt = options[key];\r\n    if (opt != null) {\r\n        const hasDefault = hasOwn(opt, 'default');\r\n        // default values\r\n        if (hasDefault && value === undefined) {\r\n            const defaultValue = opt.default;\r\n            value =\r\n                opt.type !== Function && isFunction(defaultValue)\r\n                    ? defaultValue()\r\n                    : defaultValue;\r\n        }\r\n        // boolean casting\r\n        if (opt[0 /* shouldCast */]) {\r\n            if (!hasOwn(props, key) && !hasDefault) {\r\n                value = false;\r\n            }\r\n            else if (opt[1 /* shouldCastTrue */] &&\r\n                (value === '' || value === hyphenate(key))) {\r\n                value = true;\r\n            }\r\n        }\r\n    }\r\n    return value;\r\n}\r\nfunction normalizePropsOptions(comp) {\r\n    if (comp.__props) {\r\n        return comp.__props;\r\n    }\r\n    const raw = comp.props;\r\n    const normalized = {};\r\n    const needCastKeys = [];\r\n    // apply mixin/extends props\r\n    let hasExtends = false;\r\n    if (__VUE_OPTIONS_API__ && !isFunction(comp)) {\r\n        const extendProps = (raw) => {\r\n            const [props, keys] = normalizePropsOptions(raw);\r\n            extend(normalized, props);\r\n            if (keys)\r\n                needCastKeys.push(...keys);\r\n        };\r\n        if (comp.extends) {\r\n            hasExtends = true;\r\n            extendProps(comp.extends);\r\n        }\r\n        if (comp.mixins) {\r\n            hasExtends = true;\r\n            comp.mixins.forEach(extendProps);\r\n        }\r\n    }\r\n    if (!raw && !hasExtends) {\r\n        return (comp.__props = EMPTY_ARR);\r\n    }\r\n    if (isArray(raw)) {\r\n        for (let i = 0; i < raw.length; i++) {\r\n            if ((process.env.NODE_ENV !== 'production') && !isString(raw[i])) {\r\n                warn(`props must be strings when using array syntax.`, raw[i]);\r\n            }\r\n            const normalizedKey = camelize(raw[i]);\r\n            if (validatePropName(normalizedKey)) {\r\n                normalized[normalizedKey] = EMPTY_OBJ;\r\n            }\r\n        }\r\n    }\r\n    else if (raw) {\r\n        if ((process.env.NODE_ENV !== 'production') && !isObject(raw)) {\r\n            warn(`invalid props options`, raw);\r\n        }\r\n        for (const key in raw) {\r\n            const normalizedKey = camelize(key);\r\n            if (validatePropName(normalizedKey)) {\r\n                const opt = raw[key];\r\n                const prop = (normalized[normalizedKey] =\r\n                    isArray(opt) || isFunction(opt) ? { type: opt } : opt);\r\n                if (prop) {\r\n                    const booleanIndex = getTypeIndex(Boolean, prop.type);\r\n                    const stringIndex = getTypeIndex(String, prop.type);\r\n                    prop[0 /* shouldCast */] = booleanIndex > -1;\r\n                    prop[1 /* shouldCastTrue */] =\r\n                        stringIndex < 0 || booleanIndex < stringIndex;\r\n                    // if the prop needs boolean casting or default value\r\n                    if (booleanIndex > -1 || hasOwn(prop, 'default')) {\r\n                        needCastKeys.push(normalizedKey);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n    const normalizedEntry = [normalized, needCastKeys];\r\n    comp.__props = normalizedEntry;\r\n    return normalizedEntry;\r\n}\r\n// use function string name to check type constructors\r\n// so that it works across vms / iframes.\r\nfunction getType(ctor) {\r\n    const match = ctor && ctor.toString().match(/^\\s*function (\\w+)/);\r\n    return match ? match[1] : '';\r\n}\r\nfunction isSameType(a, b) {\r\n    return getType(a) === getType(b);\r\n}\r\nfunction getTypeIndex(type, expectedTypes) {\r\n    if (isArray(expectedTypes)) {\r\n        for (let i = 0, len = expectedTypes.length; i < len; i++) {\r\n            if (isSameType(expectedTypes[i], type)) {\r\n                return i;\r\n            }\r\n        }\r\n    }\r\n    else if (isFunction(expectedTypes)) {\r\n        return isSameType(expectedTypes, type) ? 0 : -1;\r\n    }\r\n    return -1;\r\n}\r\n/**\r\n * dev only\r\n */\r\nfunction validateProps(props, comp) {\r\n    const rawValues = toRaw(props);\r\n    const options = normalizePropsOptions(comp)[0];\r\n    for (const key in options) {\r\n        let opt = options[key];\r\n        if (opt == null)\r\n            continue;\r\n        validateProp(key, rawValues[key], opt, !hasOwn(rawValues, key));\r\n    }\r\n}\r\n/**\r\n * dev only\r\n */\r\nfunction validatePropName(key) {\r\n    if (key[0] !== '$') {\r\n        return true;\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        warn(`Invalid prop name: \"${key}\" is a reserved property.`);\r\n    }\r\n    return false;\r\n}\r\n/**\r\n * dev only\r\n */\r\nfunction validateProp(name, value, prop, isAbsent) {\r\n    const { type, required, validator } = prop;\r\n    // required!\r\n    if (required && isAbsent) {\r\n        warn('Missing required prop: \"' + name + '\"');\r\n        return;\r\n    }\r\n    // missing but optional\r\n    if (value == null && !prop.required) {\r\n        return;\r\n    }\r\n    // type check\r\n    if (type != null && type !== true) {\r\n        let isValid = false;\r\n        const types = isArray(type) ? type : [type];\r\n        const expectedTypes = [];\r\n        // value is valid as long as one of the specified types match\r\n        for (let i = 0; i < types.length && !isValid; i++) {\r\n            const { valid, expectedType } = assertType(value, types[i]);\r\n            expectedTypes.push(expectedType || '');\r\n            isValid = valid;\r\n        }\r\n        if (!isValid) {\r\n            warn(getInvalidTypeMessage(name, value, expectedTypes));\r\n            return;\r\n        }\r\n    }\r\n    // custom validator\r\n    if (validator && !validator(value)) {\r\n        warn('Invalid prop: custom validator check failed for prop \"' + name + '\".');\r\n    }\r\n}\r\nconst isSimpleType = /*#__PURE__*/ makeMap('String,Number,Boolean,Function,Symbol');\r\n/**\r\n * dev only\r\n */\r\nfunction assertType(value, type) {\r\n    let valid;\r\n    const expectedType = getType(type);\r\n    if (isSimpleType(expectedType)) {\r\n        const t = typeof value;\r\n        valid = t === expectedType.toLowerCase();\r\n        // for primitive wrapper objects\r\n        if (!valid && t === 'object') {\r\n            valid = value instanceof type;\r\n        }\r\n    }\r\n    else if (expectedType === 'Object') {\r\n        valid = toRawType(value) === 'Object';\r\n    }\r\n    else if (expectedType === 'Array') {\r\n        valid = isArray(value);\r\n    }\r\n    else {\r\n        valid = value instanceof type;\r\n    }\r\n    return {\r\n        valid,\r\n        expectedType\r\n    };\r\n}\r\n/**\r\n * dev only\r\n */\r\nfunction getInvalidTypeMessage(name, value, expectedTypes) {\r\n    let message = `Invalid prop: type check failed for prop \"${name}\".` +\r\n        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;\r\n    const expectedType = expectedTypes[0];\r\n    const receivedType = toRawType(value);\r\n    const expectedValue = styleValue(value, expectedType);\r\n    const receivedValue = styleValue(value, receivedType);\r\n    // check if we need to specify expected value\r\n    if (expectedTypes.length === 1 &&\r\n        isExplicable(expectedType) &&\r\n        !isBoolean(expectedType, receivedType)) {\r\n        message += ` with value ${expectedValue}`;\r\n    }\r\n    message += `, got ${receivedType} `;\r\n    // check if we need to specify received value\r\n    if (isExplicable(receivedType)) {\r\n        message += `with value ${receivedValue}.`;\r\n    }\r\n    return message;\r\n}\r\n/**\r\n * dev only\r\n */\r\nfunction styleValue(value, type) {\r\n    if (type === 'String') {\r\n        return `\"${value}\"`;\r\n    }\r\n    else if (type === 'Number') {\r\n        return `${Number(value)}`;\r\n    }\r\n    else {\r\n        return `${value}`;\r\n    }\r\n}\r\n/**\r\n * dev only\r\n */\r\nfunction isExplicable(type) {\r\n    const explicitTypes = ['string', 'number', 'boolean'];\r\n    return explicitTypes.some(elem => type.toLowerCase() === elem);\r\n}\r\n/**\r\n * dev only\r\n */\r\nfunction isBoolean(...args) {\r\n    return args.some(elem => elem.toLowerCase() === 'boolean');\r\n}\n\nfunction injectHook(type, hook, target = currentInstance, prepend = false) {\r\n    if (target) {\r\n        const hooks = target[type] || (target[type] = []);\r\n        // cache the error handling wrapper for injected hooks so the same hook\r\n        // can be properly deduped by the scheduler. \"__weh\" stands for \"with error\r\n        // handling\".\r\n        const wrappedHook = hook.__weh ||\r\n            (hook.__weh = (...args) => {\r\n                if (target.isUnmounted) {\r\n                    return;\r\n                }\r\n                // disable tracking inside all lifecycle hooks\r\n                // since they can potentially be called inside effects.\r\n                pauseTracking();\r\n                // Set currentInstance during hook invocation.\r\n                // This assumes the hook does not synchronously trigger other hooks, which\r\n                // can only be false when the user does something really funky.\r\n                setCurrentInstance(target);\r\n                const res = callWithAsyncErrorHandling(hook, target, type, args);\r\n                setCurrentInstance(null);\r\n                resetTracking();\r\n                return res;\r\n            });\r\n        if (prepend) {\r\n            hooks.unshift(wrappedHook);\r\n        }\r\n        else {\r\n            hooks.push(wrappedHook);\r\n        }\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        const apiName = `on${capitalize(ErrorTypeStrings[type].replace(/ hook$/, ''))}`;\r\n        warn(`${apiName} is called when there is no active component instance to be ` +\r\n            `associated with. ` +\r\n            `Lifecycle injection APIs can only be used during execution of setup().` +\r\n            ( ` If you are using async setup(), make sure to register lifecycle ` +\r\n                    `hooks before the first await statement.`\r\n                ));\r\n    }\r\n}\r\nconst createHook = (lifecycle) => (hook, target = currentInstance) => \r\n// post-create lifecycle registrations are noops during SSR\r\n!isInSSRComponentSetup && injectHook(lifecycle, hook, target);\r\nconst onBeforeMount = createHook(\"bm\" /* BEFORE_MOUNT */);\r\nconst onMounted = createHook(\"m\" /* MOUNTED */);\r\nconst onBeforeUpdate = createHook(\"bu\" /* BEFORE_UPDATE */);\r\nconst onUpdated = createHook(\"u\" /* UPDATED */);\r\nconst onBeforeUnmount = createHook(\"bum\" /* BEFORE_UNMOUNT */);\r\nconst onUnmounted = createHook(\"um\" /* UNMOUNTED */);\r\nconst onRenderTriggered = createHook(\"rtg\" /* RENDER_TRIGGERED */);\r\nconst onRenderTracked = createHook(\"rtc\" /* RENDER_TRACKED */);\r\nconst onErrorCaptured = (hook, target = currentInstance) => {\r\n    injectHook(\"ec\" /* ERROR_CAPTURED */, hook, target);\r\n};\n\nfunction useTransitionState() {\r\n    const state = {\r\n        isMounted: false,\r\n        isLeaving: false,\r\n        isUnmounting: false,\r\n        leavingVNodes: new Map()\r\n    };\r\n    onMounted(() => {\r\n        state.isMounted = true;\r\n    });\r\n    onBeforeUnmount(() => {\r\n        state.isUnmounting = true;\r\n    });\r\n    return state;\r\n}\r\nconst BaseTransitionImpl = {\r\n    name: `BaseTransition`,\r\n    props: {\r\n        mode: String,\r\n        appear: Boolean,\r\n        persisted: Boolean,\r\n        // enter\r\n        onBeforeEnter: Function,\r\n        onEnter: Function,\r\n        onAfterEnter: Function,\r\n        onEnterCancelled: Function,\r\n        // leave\r\n        onBeforeLeave: Function,\r\n        onLeave: Function,\r\n        onAfterLeave: Function,\r\n        onLeaveCancelled: Function,\r\n        // appear\r\n        onBeforeAppear: Function,\r\n        onAppear: Function,\r\n        onAfterAppear: Function,\r\n        onAppearCancelled: Function\r\n    },\r\n    setup(props, { slots }) {\r\n        const instance = getCurrentInstance();\r\n        const state = useTransitionState();\r\n        let prevTransitionKey;\r\n        return () => {\r\n            const children = slots.default && getTransitionRawChildren(slots.default(), true);\r\n            if (!children || !children.length) {\r\n                return;\r\n            }\r\n            // warn multiple elements\r\n            if ((process.env.NODE_ENV !== 'production') && children.length > 1) {\r\n                warn('<transition> can only be used on a single element or component. Use ' +\r\n                    '<transition-group> for lists.');\r\n            }\r\n            // there's no need to track reactivity for these props so use the raw\r\n            // props for a bit better perf\r\n            const rawProps = toRaw(props);\r\n            const { mode } = rawProps;\r\n            // check mode\r\n            if ((process.env.NODE_ENV !== 'production') && mode && !['in-out', 'out-in', 'default'].includes(mode)) {\r\n                warn(`invalid <transition> mode: ${mode}`);\r\n            }\r\n            // at this point children has a guaranteed length of 1.\r\n            const child = children[0];\r\n            if (state.isLeaving) {\r\n                return emptyPlaceholder(child);\r\n            }\r\n            // in the case of <transition><keep-alive/></transition>, we need to\r\n            // compare the type of the kept-alive children.\r\n            const innerChild = getKeepAliveChild(child);\r\n            if (!innerChild) {\r\n                return emptyPlaceholder(child);\r\n            }\r\n            const enterHooks = (innerChild.transition = resolveTransitionHooks(innerChild, rawProps, state, instance));\r\n            const oldChild = instance.subTree;\r\n            const oldInnerChild = oldChild && getKeepAliveChild(oldChild);\r\n            let transitionKeyChanged = false;\r\n            const { getTransitionKey } = innerChild.type;\r\n            if (getTransitionKey) {\r\n                const key = getTransitionKey();\r\n                if (prevTransitionKey === undefined) {\r\n                    prevTransitionKey = key;\r\n                }\r\n                else if (key !== prevTransitionKey) {\r\n                    prevTransitionKey = key;\r\n                    transitionKeyChanged = true;\r\n                }\r\n            }\r\n            // handle mode\r\n            if (oldInnerChild &&\r\n                oldInnerChild.type !== Comment &&\r\n                (!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged)) {\r\n                const leavingHooks = resolveTransitionHooks(oldInnerChild, rawProps, state, instance);\r\n                // update old tree's hooks in case of dynamic transition\r\n                setTransitionHooks(oldInnerChild, leavingHooks);\r\n                // switching between different views\r\n                if (mode === 'out-in') {\r\n                    state.isLeaving = true;\r\n                    // return placeholder node and queue update when leave finishes\r\n                    leavingHooks.afterLeave = () => {\r\n                        state.isLeaving = false;\r\n                        instance.update();\r\n                    };\r\n                    return emptyPlaceholder(child);\r\n                }\r\n                else if (mode === 'in-out') {\r\n                    leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {\r\n                        const leavingVNodesCache = getLeavingNodesForType(state, oldInnerChild);\r\n                        leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;\r\n                        // early removal callback\r\n                        el._leaveCb = () => {\r\n                            earlyRemove();\r\n                            el._leaveCb = undefined;\r\n                            delete enterHooks.delayedLeave;\r\n                        };\r\n                        enterHooks.delayedLeave = delayedLeave;\r\n                    };\r\n                }\r\n            }\r\n            return child;\r\n        };\r\n    }\r\n};\r\n// export the public type for h/tsx inference\r\n// also to avoid inline import() in generated d.ts files\r\nconst BaseTransition = BaseTransitionImpl;\r\nfunction getLeavingNodesForType(state, vnode) {\r\n    const { leavingVNodes } = state;\r\n    let leavingVNodesCache = leavingVNodes.get(vnode.type);\r\n    if (!leavingVNodesCache) {\r\n        leavingVNodesCache = Object.create(null);\r\n        leavingVNodes.set(vnode.type, leavingVNodesCache);\r\n    }\r\n    return leavingVNodesCache;\r\n}\r\n// The transition hooks are attached to the vnode as vnode.transition\r\n// and will be called at appropriate timing in the renderer.\r\nfunction resolveTransitionHooks(vnode, { appear, persisted = false, onBeforeEnter, onEnter, onAfterEnter, onEnterCancelled, onBeforeLeave, onLeave, onAfterLeave, onLeaveCancelled, onBeforeAppear, onAppear, onAfterAppear, onAppearCancelled }, state, instance) {\r\n    const key = String(vnode.key);\r\n    const leavingVNodesCache = getLeavingNodesForType(state, vnode);\r\n    const callHook = (hook, args) => {\r\n        hook &&\r\n            callWithAsyncErrorHandling(hook, instance, 9 /* TRANSITION_HOOK */, args);\r\n    };\r\n    const hooks = {\r\n        persisted,\r\n        beforeEnter(el) {\r\n            let hook = onBeforeEnter;\r\n            if (!state.isMounted) {\r\n                if (appear) {\r\n                    hook = onBeforeAppear || onBeforeEnter;\r\n                }\r\n                else {\r\n                    return;\r\n                }\r\n            }\r\n            // for same element (v-show)\r\n            if (el._leaveCb) {\r\n                el._leaveCb(true /* cancelled */);\r\n            }\r\n            // for toggled element with same key (v-if)\r\n            const leavingVNode = leavingVNodesCache[key];\r\n            if (leavingVNode &&\r\n                isSameVNodeType(vnode, leavingVNode) &&\r\n                leavingVNode.el._leaveCb) {\r\n                // force early removal (not cancelled)\r\n                leavingVNode.el._leaveCb();\r\n            }\r\n            callHook(hook, [el]);\r\n        },\r\n        enter(el) {\r\n            let hook = onEnter;\r\n            let afterHook = onAfterEnter;\r\n            let cancelHook = onEnterCancelled;\r\n            if (!state.isMounted) {\r\n                if (appear) {\r\n                    hook = onAppear || onEnter;\r\n                    afterHook = onAfterAppear || onAfterEnter;\r\n                    cancelHook = onAppearCancelled || onEnterCancelled;\r\n                }\r\n                else {\r\n                    return;\r\n                }\r\n            }\r\n            let called = false;\r\n            const done = (el._enterCb = (cancelled) => {\r\n                if (called)\r\n                    return;\r\n                called = true;\r\n                if (cancelled) {\r\n                    callHook(cancelHook, [el]);\r\n                }\r\n                else {\r\n                    callHook(afterHook, [el]);\r\n                }\r\n                if (hooks.delayedLeave) {\r\n                    hooks.delayedLeave();\r\n                }\r\n                el._enterCb = undefined;\r\n            });\r\n            if (hook) {\r\n                hook(el, done);\r\n                if (hook.length <= 1) {\r\n                    done();\r\n                }\r\n            }\r\n            else {\r\n                done();\r\n            }\r\n        },\r\n        leave(el, remove) {\r\n            const key = String(vnode.key);\r\n            if (el._enterCb) {\r\n                el._enterCb(true /* cancelled */);\r\n            }\r\n            if (state.isUnmounting) {\r\n                return remove();\r\n            }\r\n            callHook(onBeforeLeave, [el]);\r\n            let called = false;\r\n            const done = (el._leaveCb = (cancelled) => {\r\n                if (called)\r\n                    return;\r\n                called = true;\r\n                remove();\r\n                if (cancelled) {\r\n                    callHook(onLeaveCancelled, [el]);\r\n                }\r\n                else {\r\n                    callHook(onAfterLeave, [el]);\r\n                }\r\n                el._leaveCb = undefined;\r\n                if (leavingVNodesCache[key] === vnode) {\r\n                    delete leavingVNodesCache[key];\r\n                }\r\n            });\r\n            leavingVNodesCache[key] = vnode;\r\n            if (onLeave) {\r\n                onLeave(el, done);\r\n                if (onLeave.length <= 1) {\r\n                    done();\r\n                }\r\n            }\r\n            else {\r\n                done();\r\n            }\r\n        }\r\n    };\r\n    return hooks;\r\n}\r\n// the placeholder really only handles one special case: KeepAlive\r\n// in the case of a KeepAlive in a leave phase we need to return a KeepAlive\r\n// placeholder with empty content to avoid the KeepAlive instance from being\r\n// unmounted.\r\nfunction emptyPlaceholder(vnode) {\r\n    if (isKeepAlive(vnode)) {\r\n        vnode = cloneVNode(vnode);\r\n        vnode.children = null;\r\n        return vnode;\r\n    }\r\n}\r\nfunction getKeepAliveChild(vnode) {\r\n    return isKeepAlive(vnode)\r\n        ? vnode.children\r\n            ? vnode.children[0]\r\n            : undefined\r\n        : vnode;\r\n}\r\nfunction setTransitionHooks(vnode, hooks) {\r\n    if (vnode.shapeFlag & 6 /* COMPONENT */ && vnode.component) {\r\n        setTransitionHooks(vnode.component.subTree, hooks);\r\n    }\r\n    else {\r\n        vnode.transition = hooks;\r\n    }\r\n}\r\nfunction getTransitionRawChildren(children, keepComment = false) {\r\n    let ret = [];\r\n    let keyedFragmentCount = 0;\r\n    for (let i = 0; i < children.length; i++) {\r\n        const child = children[i];\r\n        // handle fragment children case, e.g. v-for\r\n        if (child.type === Fragment) {\r\n            if (child.patchFlag & 128 /* KEYED_FRAGMENT */)\r\n                keyedFragmentCount++;\r\n            ret = ret.concat(getTransitionRawChildren(child.children, keepComment));\r\n        }\r\n        // comment placeholders should be skipped, e.g. v-if\r\n        else if (keepComment || child.type !== Comment) {\r\n            ret.push(child);\r\n        }\r\n    }\r\n    // #1126 if a transition children list contains multiple sub fragments, these\r\n    // fragments will be merged into a flat children array. Since each v-for\r\n    // fragment may contain different static bindings inside, we need to de-top\r\n    // these children to force full diffs to ensure correct behavior.\r\n    if (keyedFragmentCount > 1) {\r\n        for (let i = 0; i < ret.length; i++) {\r\n            ret[i].patchFlag = -2 /* BAIL */;\r\n        }\r\n    }\r\n    return ret;\r\n}\n\nconst isKeepAlive = (vnode) => vnode.type.__isKeepAlive;\r\nconst KeepAliveImpl = {\r\n    name: `KeepAlive`,\r\n    // Marker for special handling inside the renderer. We are not using a ===\r\n    // check directly on KeepAlive in the renderer, because importing it directly\r\n    // would prevent it from being tree-shaken.\r\n    __isKeepAlive: true,\r\n    inheritRef: true,\r\n    props: {\r\n        include: [String, RegExp, Array],\r\n        exclude: [String, RegExp, Array],\r\n        max: [String, Number]\r\n    },\r\n    setup(props, { slots }) {\r\n        const cache = new Map();\r\n        const keys = new Set();\r\n        let current = null;\r\n        const instance = getCurrentInstance();\r\n        const parentSuspense = instance.suspense;\r\n        // KeepAlive communicates with the instantiated renderer via the\r\n        // ctx where the renderer passes in its internals,\r\n        // and the KeepAlive instance exposes activate/deactivate implementations.\r\n        // The whole point of this is to avoid importing KeepAlive directly in the\r\n        // renderer to facilitate tree-shaking.\r\n        const sharedContext = instance.ctx;\r\n        const { renderer: { p: patch, m: move, um: _unmount, o: { createElement } } } = sharedContext;\r\n        const storageContainer = createElement('div');\r\n        sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => {\r\n            const instance = vnode.component;\r\n            move(vnode, container, anchor, 0 /* ENTER */, parentSuspense);\r\n            // in case props have changed\r\n            patch(instance.vnode, vnode, container, anchor, instance, parentSuspense, isSVG, optimized);\r\n            queuePostRenderEffect(() => {\r\n                instance.isDeactivated = false;\r\n                if (instance.a) {\r\n                    invokeArrayFns(instance.a);\r\n                }\r\n                const vnodeHook = vnode.props && vnode.props.onVnodeMounted;\r\n                if (vnodeHook) {\r\n                    invokeVNodeHook(vnodeHook, instance.parent, vnode);\r\n                }\r\n            }, parentSuspense);\r\n        };\r\n        sharedContext.deactivate = (vnode) => {\r\n            const instance = vnode.component;\r\n            move(vnode, storageContainer, null, 1 /* LEAVE */, parentSuspense);\r\n            queuePostRenderEffect(() => {\r\n                if (instance.da) {\r\n                    invokeArrayFns(instance.da);\r\n                }\r\n                const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;\r\n                if (vnodeHook) {\r\n                    invokeVNodeHook(vnodeHook, instance.parent, vnode);\r\n                }\r\n                instance.isDeactivated = true;\r\n            }, parentSuspense);\r\n        };\r\n        function unmount(vnode) {\r\n            // reset the shapeFlag so it can be properly unmounted\r\n            resetShapeFlag(vnode);\r\n            _unmount(vnode, instance, parentSuspense);\r\n        }\r\n        function pruneCache(filter) {\r\n            cache.forEach((vnode, key) => {\r\n                const name = getName(vnode.type);\r\n                if (name && (!filter || !filter(name))) {\r\n                    pruneCacheEntry(key);\r\n                }\r\n            });\r\n        }\r\n        function pruneCacheEntry(key) {\r\n            const cached = cache.get(key);\r\n            if (!current || cached.type !== current.type) {\r\n                unmount(cached);\r\n            }\r\n            else if (current) {\r\n                // current active instance should no longer be kept-alive.\r\n                // we can't unmount it now but it might be later, so reset its flag now.\r\n                resetShapeFlag(current);\r\n            }\r\n            cache.delete(key);\r\n            keys.delete(key);\r\n        }\r\n        watch(() => [props.include, props.exclude], ([include, exclude]) => {\r\n            include && pruneCache(name => matches(include, name));\r\n            exclude && pruneCache(name => matches(exclude, name));\r\n        });\r\n        // cache sub tree in beforeMount/Update (i.e. right after the render)\r\n        let pendingCacheKey = null;\r\n        const cacheSubtree = () => {\r\n            // fix #1621, the pendingCacheKey could be 0\r\n            if (pendingCacheKey != null) {\r\n                cache.set(pendingCacheKey, instance.subTree);\r\n            }\r\n        };\r\n        onBeforeMount(cacheSubtree);\r\n        onBeforeUpdate(cacheSubtree);\r\n        onBeforeUnmount(() => {\r\n            cache.forEach(cached => {\r\n                const { subTree, suspense } = instance;\r\n                if (cached.type === subTree.type) {\r\n                    // current instance will be unmounted as part of keep-alive's unmount\r\n                    resetShapeFlag(subTree);\r\n                    // but invoke its deactivated hook here\r\n                    const da = subTree.component.da;\r\n                    da && queuePostRenderEffect(da, suspense);\r\n                    return;\r\n                }\r\n                unmount(cached);\r\n            });\r\n        });\r\n        return () => {\r\n            pendingCacheKey = null;\r\n            if (!slots.default) {\r\n                return null;\r\n            }\r\n            const children = slots.default();\r\n            let vnode = children[0];\r\n            if (children.length > 1) {\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn(`KeepAlive should contain exactly one component child.`);\r\n                }\r\n                current = null;\r\n                return children;\r\n            }\r\n            else if (!isVNode(vnode) ||\r\n                !(vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */)) {\r\n                current = null;\r\n                return vnode;\r\n            }\r\n            const comp = vnode.type;\r\n            const name = getName(comp);\r\n            const { include, exclude, max } = props;\r\n            if ((include && (!name || !matches(include, name))) ||\r\n                (exclude && name && matches(exclude, name))) {\r\n                return (current = vnode);\r\n            }\r\n            const key = vnode.key == null ? comp : vnode.key;\r\n            const cachedVNode = cache.get(key);\r\n            // clone vnode if it's reused because we are going to mutate it\r\n            if (vnode.el) {\r\n                vnode = cloneVNode(vnode);\r\n            }\r\n            // #1513 it's possible for the returned vnode to be cloned due to attr\r\n            // fallthrough or scopeId, so the vnode here may not be the final vnode\r\n            // that is mounted. Instead of caching it directly, we store the pending\r\n            // key and cache `instance.subTree` (the normalized vnode) in\r\n            // beforeMount/beforeUpdate hooks.\r\n            pendingCacheKey = key;\r\n            if (cachedVNode) {\r\n                // copy over mounted state\r\n                vnode.el = cachedVNode.el;\r\n                vnode.component = cachedVNode.component;\r\n                if (vnode.transition) {\r\n                    // recursively update transition hooks on subTree\r\n                    setTransitionHooks(vnode, vnode.transition);\r\n                }\r\n                // avoid vnode being mounted as fresh\r\n                vnode.shapeFlag |= 512 /* COMPONENT_KEPT_ALIVE */;\r\n                // make this key the freshest\r\n                keys.delete(key);\r\n                keys.add(key);\r\n            }\r\n            else {\r\n                keys.add(key);\r\n                // prune oldest entry\r\n                if (max && keys.size > parseInt(max, 10)) {\r\n                    pruneCacheEntry(keys.values().next().value);\r\n                }\r\n            }\r\n            // avoid vnode being unmounted\r\n            vnode.shapeFlag |= 256 /* COMPONENT_SHOULD_KEEP_ALIVE */;\r\n            current = vnode;\r\n            return vnode;\r\n        };\r\n    }\r\n};\r\n// export the public type for h/tsx inference\r\n// also to avoid inline import() in generated d.ts files\r\nconst KeepAlive = KeepAliveImpl;\r\nfunction getName(comp) {\r\n    return comp.displayName || comp.name;\r\n}\r\nfunction matches(pattern, name) {\r\n    if (isArray(pattern)) {\r\n        return pattern.some((p) => matches(p, name));\r\n    }\r\n    else if (isString(pattern)) {\r\n        return pattern.split(',').indexOf(name) > -1;\r\n    }\r\n    else if (pattern.test) {\r\n        return pattern.test(name);\r\n    }\r\n    /* istanbul ignore next */\r\n    return false;\r\n}\r\nfunction onActivated(hook, target) {\r\n    registerKeepAliveHook(hook, \"a\" /* ACTIVATED */, target);\r\n}\r\nfunction onDeactivated(hook, target) {\r\n    registerKeepAliveHook(hook, \"da\" /* DEACTIVATED */, target);\r\n}\r\nfunction registerKeepAliveHook(hook, type, target = currentInstance) {\r\n    // cache the deactivate branch check wrapper for injected hooks so the same\r\n    // hook can be properly deduped by the scheduler. \"__wdc\" stands for \"with\r\n    // deactivation check\".\r\n    const wrappedHook = hook.__wdc ||\r\n        (hook.__wdc = () => {\r\n            // only fire the hook if the target instance is NOT in a deactivated branch.\r\n            let current = target;\r\n            while (current) {\r\n                if (current.isDeactivated) {\r\n                    return;\r\n                }\r\n                current = current.parent;\r\n            }\r\n            hook();\r\n        });\r\n    injectHook(type, wrappedHook, target);\r\n    // In addition to registering it on the target instance, we walk up the parent\r\n    // chain and register it on all ancestor instances that are keep-alive roots.\r\n    // This avoids the need to walk the entire component tree when invoking these\r\n    // hooks, and more importantly, avoids the need to track child components in\r\n    // arrays.\r\n    if (target) {\r\n        let current = target.parent;\r\n        while (current && current.parent) {\r\n            if (isKeepAlive(current.parent.vnode)) {\r\n                injectToKeepAliveRoot(wrappedHook, type, target, current);\r\n            }\r\n            current = current.parent;\r\n        }\r\n    }\r\n}\r\nfunction injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {\r\n    injectHook(type, hook, keepAliveRoot, true /* prepend */);\r\n    onUnmounted(() => {\r\n        remove(keepAliveRoot[type], hook);\r\n    }, target);\r\n}\r\nfunction resetShapeFlag(vnode) {\r\n    let shapeFlag = vnode.shapeFlag;\r\n    if (shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) {\r\n        shapeFlag -= 256 /* COMPONENT_SHOULD_KEEP_ALIVE */;\r\n    }\r\n    if (shapeFlag & 512 /* COMPONENT_KEPT_ALIVE */) {\r\n        shapeFlag -= 512 /* COMPONENT_KEPT_ALIVE */;\r\n    }\r\n    vnode.shapeFlag = shapeFlag;\r\n}\n\nconst isInternalKey = (key) => key[0] === '_' || key === '$stable';\r\nconst normalizeSlotValue = (value) => isArray(value)\r\n    ? value.map(normalizeVNode)\r\n    : [normalizeVNode(value)];\r\nconst normalizeSlot = (key, rawSlot, ctx) => withCtx((props) => {\r\n    if ((process.env.NODE_ENV !== 'production') && currentInstance) {\r\n        warn(`Slot \"${key}\" invoked outside of the render function: ` +\r\n            `this will not track dependencies used in the slot. ` +\r\n            `Invoke the slot function inside the render function instead.`);\r\n    }\r\n    return normalizeSlotValue(rawSlot(props));\r\n}, ctx);\r\nconst normalizeObjectSlots = (rawSlots, slots) => {\r\n    const ctx = rawSlots._ctx;\r\n    for (const key in rawSlots) {\r\n        if (isInternalKey(key))\r\n            continue;\r\n        const value = rawSlots[key];\r\n        if (isFunction(value)) {\r\n            slots[key] = normalizeSlot(key, value, ctx);\r\n        }\r\n        else if (value != null) {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                warn(`Non-function value encountered for slot \"${key}\". ` +\r\n                    `Prefer function slots for better performance.`);\r\n            }\r\n            const normalized = normalizeSlotValue(value);\r\n            slots[key] = () => normalized;\r\n        }\r\n    }\r\n};\r\nconst normalizeVNodeSlots = (instance, children) => {\r\n    if ((process.env.NODE_ENV !== 'production') && !isKeepAlive(instance.vnode)) {\r\n        warn(`Non-function value encountered for default slot. ` +\r\n            `Prefer function slots for better performance.`);\r\n    }\r\n    const normalized = normalizeSlotValue(children);\r\n    instance.slots.default = () => normalized;\r\n};\r\nconst initSlots = (instance, children) => {\r\n    if (instance.vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n        const type = children._;\r\n        if (type) {\r\n            instance.slots = children;\r\n            // make compiler marker non-enumerable\r\n            def(children, '_', type);\r\n        }\r\n        else {\r\n            normalizeObjectSlots(children, (instance.slots = {}));\r\n        }\r\n    }\r\n    else {\r\n        instance.slots = {};\r\n        if (children) {\r\n            normalizeVNodeSlots(instance, children);\r\n        }\r\n    }\r\n    def(instance.slots, InternalObjectKey, 1);\r\n};\r\nconst updateSlots = (instance, children) => {\r\n    const { vnode, slots } = instance;\r\n    let needDeletionCheck = true;\r\n    let deletionComparisonTarget = EMPTY_OBJ;\r\n    if (vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) {\r\n        const type = children._;\r\n        if (type) {\r\n            // compiled slots.\r\n            if ((process.env.NODE_ENV !== 'production') && isHmrUpdating) {\r\n                // Parent was HMR updated so slot content may have changed.\r\n                // force update slots and mark instance for hmr as well\r\n                extend(slots, children);\r\n            }\r\n            else if (type === 1 /* STABLE */) {\r\n                // compiled AND stable.\r\n                // no need to update, and skip stale slots removal.\r\n                needDeletionCheck = false;\r\n            }\r\n            else {\r\n                // compiled but dynamic (v-if/v-for on slots) - update slots, but skip\r\n                // normalization.\r\n                extend(slots, children);\r\n            }\r\n        }\r\n        else {\r\n            needDeletionCheck = !children.$stable;\r\n            normalizeObjectSlots(children, slots);\r\n        }\r\n        deletionComparisonTarget = children;\r\n    }\r\n    else if (children) {\r\n        // non slot object children (direct value) passed to a component\r\n        normalizeVNodeSlots(instance, children);\r\n        deletionComparisonTarget = { default: 1 };\r\n    }\r\n    // delete stale slots\r\n    if (needDeletionCheck) {\r\n        for (const key in slots) {\r\n            if (!isInternalKey(key) && !(key in deletionComparisonTarget)) {\r\n                delete slots[key];\r\n            }\r\n        }\r\n    }\r\n};\n\n/**\r\nRuntime helper for applying directives to a vnode. Example usage:\r\n\nconst comp = resolveComponent('comp')\r\nconst foo = resolveDirective('foo')\r\nconst bar = resolveDirective('bar')\r\n\nreturn withDirectives(h(comp), [\r\n  [foo, this.x],\r\n  [bar, this.y]\r\n])\r\n*/\r\nconst isBuiltInDirective = /*#__PURE__*/ makeMap('bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text');\r\nfunction validateDirectiveName(name) {\r\n    if (isBuiltInDirective(name)) {\r\n        warn('Do not use built-in directive ids as custom directive id: ' + name);\r\n    }\r\n}\r\n/**\r\n * Adds directives to a VNode.\r\n */\r\nfunction withDirectives(vnode, directives) {\r\n    const internalInstance = currentRenderingInstance;\r\n    if (internalInstance === null) {\r\n        (process.env.NODE_ENV !== 'production') && warn(`withDirectives can only be used inside render functions.`);\r\n        return vnode;\r\n    }\r\n    const instance = internalInstance.proxy;\r\n    const bindings = vnode.dirs || (vnode.dirs = []);\r\n    for (let i = 0; i < directives.length; i++) {\r\n        let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];\r\n        if (isFunction(dir)) {\r\n            dir = {\r\n                mounted: dir,\r\n                updated: dir\r\n            };\r\n        }\r\n        bindings.push({\r\n            dir,\r\n            instance,\r\n            value,\r\n            oldValue: void 0,\r\n            arg,\r\n            modifiers\r\n        });\r\n    }\r\n    return vnode;\r\n}\r\nfunction invokeDirectiveHook(vnode, prevVNode, instance, name) {\r\n    const bindings = vnode.dirs;\r\n    const oldBindings = prevVNode && prevVNode.dirs;\r\n    for (let i = 0; i < bindings.length; i++) {\r\n        const binding = bindings[i];\r\n        if (oldBindings) {\r\n            binding.oldValue = oldBindings[i].value;\r\n        }\r\n        const hook = binding.dir[name];\r\n        if (hook) {\r\n            callWithAsyncErrorHandling(hook, instance, 8 /* DIRECTIVE_HOOK */, [\r\n                vnode.el,\r\n                binding,\r\n                vnode,\r\n                prevVNode\r\n            ]);\r\n        }\r\n    }\r\n}\n\nlet devtools;\r\nfunction setDevtoolsHook(hook) {\r\n    devtools = hook;\r\n}\r\nfunction devtoolsInitApp(app, version) {\r\n    // TODO queue if devtools is undefined\r\n    if (!devtools)\r\n        return;\r\n    devtools.emit(\"app:init\" /* APP_INIT */, app, version, {\r\n        Fragment,\r\n        Text,\r\n        Comment,\r\n        Static\r\n    });\r\n}\r\nfunction devtoolsUnmountApp(app) {\r\n    if (!devtools)\r\n        return;\r\n    devtools.emit(\"app:unmount\" /* APP_UNMOUNT */, app);\r\n}\r\nconst devtoolsComponentAdded = /*#__PURE__*/ createDevtoolsHook(\"component:added\" /* COMPONENT_ADDED */);\r\nconst devtoolsComponentUpdated = /*#__PURE__*/ createDevtoolsHook(\"component:updated\" /* COMPONENT_UPDATED */);\r\nconst devtoolsComponentRemoved = /*#__PURE__*/ createDevtoolsHook(\"component:removed\" /* COMPONENT_REMOVED */);\r\nfunction createDevtoolsHook(hook) {\r\n    return (component) => {\r\n        if (!devtools)\r\n            return;\r\n        devtools.emit(hook, component.appContext.app, component.uid, component.parent ? component.parent.uid : undefined);\r\n    };\r\n}\n\nfunction createAppContext() {\r\n    return {\r\n        app: null,\r\n        config: {\r\n            isNativeTag: NO,\r\n            performance: false,\r\n            globalProperties: {},\r\n            optionMergeStrategies: {},\r\n            isCustomElement: NO,\r\n            errorHandler: undefined,\r\n            warnHandler: undefined\r\n        },\r\n        mixins: [],\r\n        components: {},\r\n        directives: {},\r\n        provides: Object.create(null)\r\n    };\r\n}\r\nfunction createAppAPI(render, hydrate) {\r\n    return function createApp(rootComponent, rootProps = null) {\r\n        if (rootProps != null && !isObject(rootProps)) {\r\n            (process.env.NODE_ENV !== 'production') && warn(`root props passed to app.mount() must be an object.`);\r\n            rootProps = null;\r\n        }\r\n        const context = createAppContext();\r\n        const installedPlugins = new Set();\r\n        let isMounted = false;\r\n        const app = (context.app = {\r\n            _component: rootComponent,\r\n            _props: rootProps,\r\n            _container: null,\r\n            _context: context,\r\n            version,\r\n            get config() {\r\n                return context.config;\r\n            },\r\n            set config(v) {\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn(`app.config cannot be replaced. Modify individual options instead.`);\r\n                }\r\n            },\r\n            use(plugin, ...options) {\r\n                if (installedPlugins.has(plugin)) {\r\n                    (process.env.NODE_ENV !== 'production') && warn(`Plugin has already been applied to target app.`);\r\n                }\r\n                else if (plugin && isFunction(plugin.install)) {\r\n                    installedPlugins.add(plugin);\r\n                    plugin.install(app, ...options);\r\n                }\r\n                else if (isFunction(plugin)) {\r\n                    installedPlugins.add(plugin);\r\n                    plugin(app, ...options);\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn(`A plugin must either be a function or an object with an \"install\" ` +\r\n                        `function.`);\r\n                }\r\n                return app;\r\n            },\r\n            mixin(mixin) {\r\n                if (__VUE_OPTIONS_API__) {\r\n                    if (!context.mixins.includes(mixin)) {\r\n                        context.mixins.push(mixin);\r\n                    }\r\n                    else if ((process.env.NODE_ENV !== 'production')) {\r\n                        warn('Mixin has already been applied to target app' +\r\n                            (mixin.name ? `: ${mixin.name}` : ''));\r\n                    }\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn('Mixins are only available in builds supporting Options API');\r\n                }\r\n                return app;\r\n            },\r\n            component(name, component) {\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    validateComponentName(name, context.config);\r\n                }\r\n                if (!component) {\r\n                    return context.components[name];\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production') && context.components[name]) {\r\n                    warn(`Component \"${name}\" has already been registered in target app.`);\r\n                }\r\n                context.components[name] = component;\r\n                return app;\r\n            },\r\n            directive(name, directive) {\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    validateDirectiveName(name);\r\n                }\r\n                if (!directive) {\r\n                    return context.directives[name];\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production') && context.directives[name]) {\r\n                    warn(`Directive \"${name}\" has already been registered in target app.`);\r\n                }\r\n                context.directives[name] = directive;\r\n                return app;\r\n            },\r\n            mount(rootContainer, isHydrate) {\r\n                if (!isMounted) {\r\n                    const vnode = createVNode(rootComponent, rootProps);\r\n                    // store app context on the root VNode.\r\n                    // this will be set on the root instance on initial mount.\r\n                    vnode.appContext = context;\r\n                    // HMR root reload\r\n                    if ((process.env.NODE_ENV !== 'production')) {\r\n                        context.reload = () => {\r\n                            render(cloneVNode(vnode), rootContainer);\r\n                        };\r\n                    }\r\n                    if (isHydrate && hydrate) {\r\n                        hydrate(vnode, rootContainer);\r\n                    }\r\n                    else {\r\n                        render(vnode, rootContainer);\r\n                    }\r\n                    isMounted = true;\r\n                    app._container = rootContainer;\r\n                    rootContainer.__vue_app__ = app;\r\n                    if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n                        devtoolsInitApp(app, version);\r\n                    }\r\n                    return vnode.component.proxy;\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn(`App has already been mounted.\\n` +\r\n                        `If you want to remount the same app, move your app creation logic ` +\r\n                        `into a factory function and create fresh app instances for each ` +\r\n                        `mount - e.g. \\`const createMyApp = () => createApp(App)\\``);\r\n                }\r\n            },\r\n            unmount() {\r\n                if (isMounted) {\r\n                    render(null, app._container);\r\n                    devtoolsUnmountApp(app);\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn(`Cannot unmount an app that is not mounted.`);\r\n                }\r\n            },\r\n            provide(key, value) {\r\n                if ((process.env.NODE_ENV !== 'production') && key in context.provides) {\r\n                    warn(`App already provides property with key \"${String(key)}\". ` +\r\n                        `It will be overwritten with the new value.`);\r\n                }\r\n                // TypeScript doesn't allow symbols as index type\r\n                // https://github.com/Microsoft/TypeScript/issues/24587\r\n                context.provides[key] = value;\r\n                return app;\r\n            }\r\n        });\r\n        return app;\r\n    };\r\n}\n\nlet hasMismatch = false;\r\nconst isSVGContainer = (container) => /svg/.test(container.namespaceURI) && container.tagName !== 'foreignObject';\r\nconst isComment = (node) => node.nodeType === 8 /* COMMENT */;\r\n// Note: hydration is DOM-specific\r\n// But we have to place it in core due to tight coupling with core - splitting\r\n// it out creates a ton of unnecessary complexity.\r\n// Hydration also depends on some renderer internal logic which needs to be\r\n// passed in via arguments.\r\nfunction createHydrationFunctions(rendererInternals) {\r\n    const { mt: mountComponent, p: patch, o: { patchProp, nextSibling, parentNode, remove, insert, createComment } } = rendererInternals;\r\n    const hydrate = (vnode, container) => {\r\n        if ((process.env.NODE_ENV !== 'production') && !container.hasChildNodes()) {\r\n            warn(`Attempting to hydrate existing markup but container is empty. ` +\r\n                `Performing full mount instead.`);\r\n            patch(null, vnode, container);\r\n            return;\r\n        }\r\n        hasMismatch = false;\r\n        hydrateNode(container.firstChild, vnode, null, null);\r\n        flushPostFlushCbs();\r\n        if (hasMismatch && !false) {\r\n            // this error should show up in production\r\n            console.error(`Hydration completed but contains mismatches.`);\r\n        }\r\n    };\r\n    const hydrateNode = (node, vnode, parentComponent, parentSuspense, optimized = false) => {\r\n        const isFragmentStart = isComment(node) && node.data === '[';\r\n        const onMismatch = () => handleMismatch(node, vnode, parentComponent, parentSuspense, isFragmentStart);\r\n        const { type, ref, shapeFlag } = vnode;\r\n        const domType = node.nodeType;\r\n        vnode.el = node;\r\n        let nextNode = null;\r\n        switch (type) {\r\n            case Text:\r\n                if (domType !== 3 /* TEXT */) {\r\n                    nextNode = onMismatch();\r\n                }\r\n                else {\r\n                    if (node.data !== vnode.children) {\r\n                        hasMismatch = true;\r\n                        (process.env.NODE_ENV !== 'production') &&\r\n                            warn(`Hydration text mismatch:` +\r\n                                `\\n- Client: ${JSON.stringify(node.data)}` +\r\n                                `\\n- Server: ${JSON.stringify(vnode.children)}`);\r\n                        node.data = vnode.children;\r\n                    }\r\n                    nextNode = nextSibling(node);\r\n                }\r\n                break;\r\n            case Comment:\r\n                if (domType !== 8 /* COMMENT */ || isFragmentStart) {\r\n                    nextNode = onMismatch();\r\n                }\r\n                else {\r\n                    nextNode = nextSibling(node);\r\n                }\r\n                break;\r\n            case Static:\r\n                if (domType !== 1 /* ELEMENT */) {\r\n                    nextNode = onMismatch();\r\n                }\r\n                else {\r\n                    // determine anchor, adopt content\r\n                    nextNode = node;\r\n                    // if the static vnode has its content stripped during build,\r\n                    // adopt it from the server-rendered HTML.\r\n                    const needToAdoptContent = !vnode.children.length;\r\n                    for (let i = 0; i < vnode.staticCount; i++) {\r\n                        if (needToAdoptContent)\r\n                            vnode.children += nextNode.outerHTML;\r\n                        if (i === vnode.staticCount - 1) {\r\n                            vnode.anchor = nextNode;\r\n                        }\r\n                        nextNode = nextSibling(nextNode);\r\n                    }\r\n                    return nextNode;\r\n                }\r\n                break;\r\n            case Fragment:\r\n                if (!isFragmentStart) {\r\n                    nextNode = onMismatch();\r\n                }\r\n                else {\r\n                    nextNode = hydrateFragment(node, vnode, parentComponent, parentSuspense, optimized);\r\n                }\r\n                break;\r\n            default:\r\n                if (shapeFlag & 1 /* ELEMENT */) {\r\n                    if (domType !== 1 /* ELEMENT */ ||\r\n                        vnode.type !== node.tagName.toLowerCase()) {\r\n                        nextNode = onMismatch();\r\n                    }\r\n                    else {\r\n                        nextNode = hydrateElement(node, vnode, parentComponent, parentSuspense, optimized);\r\n                    }\r\n                }\r\n                else if (shapeFlag & 6 /* COMPONENT */) {\r\n                    // when setting up the render effect, if the initial vnode already\r\n                    // has .el set, the component will perform hydration instead of mount\r\n                    // on its sub-tree.\r\n                    const container = parentNode(node);\r\n                    const hydrateComponent = () => {\r\n                        mountComponent(vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container), optimized);\r\n                    };\r\n                    // async component\r\n                    const loadAsync = vnode.type.__asyncLoader;\r\n                    if (loadAsync) {\r\n                        loadAsync().then(hydrateComponent);\r\n                    }\r\n                    else {\r\n                        hydrateComponent();\r\n                    }\r\n                    // component may be async, so in the case of fragments we cannot rely\r\n                    // on component's rendered output to determine the end of the fragment\r\n                    // instead, we do a lookahead to find the end anchor node.\r\n                    nextNode = isFragmentStart\r\n                        ? locateClosingAsyncAnchor(node)\r\n                        : nextSibling(node);\r\n                }\r\n                else if (shapeFlag & 64 /* TELEPORT */) {\r\n                    if (domType !== 8 /* COMMENT */) {\r\n                        nextNode = onMismatch();\r\n                    }\r\n                    else {\r\n                        nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, optimized, rendererInternals, hydrateChildren);\r\n                    }\r\n                }\r\n                else if ( shapeFlag & 128 /* SUSPENSE */) {\r\n                    nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, isSVGContainer(parentNode(node)), optimized, rendererInternals, hydrateNode);\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn('Invalid HostVNode type:', type, `(${typeof type})`);\r\n                }\r\n        }\r\n        if (ref != null && parentComponent) {\r\n            setRef(ref, null, parentComponent, parentSuspense, vnode);\r\n        }\r\n        return nextNode;\r\n    };\r\n    const hydrateElement = (el, vnode, parentComponent, parentSuspense, optimized) => {\r\n        optimized = optimized || !!vnode.dynamicChildren;\r\n        const { props, patchFlag, shapeFlag, dirs } = vnode;\r\n        // skip props & children if this is hoisted static nodes\r\n        if (patchFlag !== -1 /* HOISTED */) {\r\n            // props\r\n            if (props) {\r\n                if (!optimized ||\r\n                    (patchFlag & 16 /* FULL_PROPS */ ||\r\n                        patchFlag & 32 /* HYDRATE_EVENTS */)) {\r\n                    for (const key in props) {\r\n                        if (!isReservedProp(key) && isOn(key)) {\r\n                            patchProp(el, key, null, props[key]);\r\n                        }\r\n                    }\r\n                }\r\n                else if (props.onClick) {\r\n                    // Fast path for click listeners (which is most often) to avoid\r\n                    // iterating through props.\r\n                    patchProp(el, 'onClick', null, props.onClick);\r\n                }\r\n            }\r\n            // vnode / directive hooks\r\n            let vnodeHooks;\r\n            if ((vnodeHooks = props && props.onVnodeBeforeMount)) {\r\n                invokeVNodeHook(vnodeHooks, parentComponent, vnode);\r\n            }\r\n            if (dirs) {\r\n                invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount');\r\n            }\r\n            if ((vnodeHooks = props && props.onVnodeMounted) || dirs) {\r\n                queueEffectWithSuspense(() => {\r\n                    vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode);\r\n                    dirs && invokeDirectiveHook(vnode, null, parentComponent, 'mounted');\r\n                }, parentSuspense);\r\n            }\r\n            // children\r\n            if (shapeFlag & 16 /* ARRAY_CHILDREN */ &&\r\n                // skip if element has innerHTML / textContent\r\n                !(props && (props.innerHTML || props.textContent))) {\r\n                let next = hydrateChildren(el.firstChild, vnode, el, parentComponent, parentSuspense, optimized);\r\n                let hasWarned = false;\r\n                while (next) {\r\n                    hasMismatch = true;\r\n                    if ((process.env.NODE_ENV !== 'production') && !hasWarned) {\r\n                        warn(`Hydration children mismatch in <${vnode.type}>: ` +\r\n                            `server rendered element contains more child nodes than client vdom.`);\r\n                        hasWarned = true;\r\n                    }\r\n                    // The SSRed DOM contains more nodes than it should. Remove them.\r\n                    const cur = next;\r\n                    next = next.nextSibling;\r\n                    remove(cur);\r\n                }\r\n            }\r\n            else if (shapeFlag & 8 /* TEXT_CHILDREN */) {\r\n                if (el.textContent !== vnode.children) {\r\n                    hasMismatch = true;\r\n                    (process.env.NODE_ENV !== 'production') &&\r\n                        warn(`Hydration text content mismatch in <${vnode.type}>:\\n` +\r\n                            `- Client: ${el.textContent}\\n` +\r\n                            `- Server: ${vnode.children}`);\r\n                    el.textContent = vnode.children;\r\n                }\r\n            }\r\n        }\r\n        return el.nextSibling;\r\n    };\r\n    const hydrateChildren = (node, vnode, container, parentComponent, parentSuspense, optimized) => {\r\n        optimized = optimized || !!vnode.dynamicChildren;\r\n        const children = vnode.children;\r\n        const l = children.length;\r\n        let hasWarned = false;\r\n        for (let i = 0; i < l; i++) {\r\n            const vnode = optimized\r\n                ? children[i]\r\n                : (children[i] = normalizeVNode(children[i]));\r\n            if (node) {\r\n                node = hydrateNode(node, vnode, parentComponent, parentSuspense, optimized);\r\n            }\r\n            else {\r\n                hasMismatch = true;\r\n                if ((process.env.NODE_ENV !== 'production') && !hasWarned) {\r\n                    warn(`Hydration children mismatch in <${container.tagName.toLowerCase()}>: ` +\r\n                        `server rendered element contains fewer child nodes than client vdom.`);\r\n                    hasWarned = true;\r\n                }\r\n                // the SSRed DOM didn't contain enough nodes. Mount the missing ones.\r\n                patch(null, vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container));\r\n            }\r\n        }\r\n        return node;\r\n    };\r\n    const hydrateFragment = (node, vnode, parentComponent, parentSuspense, optimized) => {\r\n        const container = parentNode(node);\r\n        const next = hydrateChildren(nextSibling(node), vnode, container, parentComponent, parentSuspense, optimized);\r\n        if (next && isComment(next) && next.data === ']') {\r\n            return nextSibling((vnode.anchor = next));\r\n        }\r\n        else {\r\n            // fragment didn't hydrate successfully, since we didn't get a end anchor\r\n            // back. This should have led to node/children mismatch warnings.\r\n            hasMismatch = true;\r\n            // since the anchor is missing, we need to create one and insert it\r\n            insert((vnode.anchor = createComment(`]`)), container, next);\r\n            return next;\r\n        }\r\n    };\r\n    const handleMismatch = (node, vnode, parentComponent, parentSuspense, isFragment) => {\r\n        hasMismatch = true;\r\n        (process.env.NODE_ENV !== 'production') &&\r\n            warn(`Hydration node mismatch:\\n- Client vnode:`, vnode.type, `\\n- Server rendered DOM:`, node, node.nodeType === 3 /* TEXT */\r\n                ? `(text)`\r\n                : isComment(node) && node.data === '['\r\n                    ? `(start of fragment)`\r\n                    : ``);\r\n        vnode.el = null;\r\n        if (isFragment) {\r\n            // remove excessive fragment nodes\r\n            const end = locateClosingAsyncAnchor(node);\r\n            while (true) {\r\n                const next = nextSibling(node);\r\n                if (next && next !== end) {\r\n                    remove(next);\r\n                }\r\n                else {\r\n                    break;\r\n                }\r\n            }\r\n        }\r\n        const next = nextSibling(node);\r\n        const container = parentNode(node);\r\n        remove(node);\r\n        patch(null, vnode, container, next, parentComponent, parentSuspense, isSVGContainer(container));\r\n        return next;\r\n    };\r\n    const locateClosingAsyncAnchor = (node) => {\r\n        let match = 0;\r\n        while (node) {\r\n            node = nextSibling(node);\r\n            if (node && isComment(node)) {\r\n                if (node.data === '[')\r\n                    match++;\r\n                if (node.data === ']') {\r\n                    if (match === 0) {\r\n                        return nextSibling(node);\r\n                    }\r\n                    else {\r\n                        match--;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        return node;\r\n    };\r\n    return [hydrate, hydrateNode];\r\n}\n\nlet supported;\r\nlet perf;\r\nfunction startMeasure(instance, type) {\r\n    if (instance.appContext.config.performance && isSupported()) {\r\n        perf.mark(`vue-${type}-${instance.uid}`);\r\n    }\r\n}\r\nfunction endMeasure(instance, type) {\r\n    if (instance.appContext.config.performance && isSupported()) {\r\n        const startTag = `vue-${type}-${instance.uid}`;\r\n        const endTag = startTag + `:end`;\r\n        perf.mark(endTag);\r\n        perf.measure(`<${formatComponentName(instance, instance.type)}> ${type}`, startTag, endTag);\r\n        perf.clearMarks(startTag);\r\n        perf.clearMarks(endTag);\r\n    }\r\n}\r\nfunction isSupported() {\r\n    if (supported !== undefined) {\r\n        return supported;\r\n    }\r\n    /* eslint-disable no-restricted-globals */\r\n    if (typeof window !== 'undefined' && window.performance) {\r\n        supported = true;\r\n        perf = window.performance;\r\n    }\r\n    else {\r\n        supported = false;\r\n    }\r\n    /* eslint-enable no-restricted-globals */\r\n    return supported;\r\n}\n\n/**\r\n * This is only called in esm-bundler builds.\r\n * It is called when a renderer is created, in `baseCreateRenderer` so that\r\n * importing runtime-core is side-effects free.\r\n *\r\n * istanbul-ignore-next\r\n */\r\nfunction initFeatureFlags() {\r\n    let needWarn = false;\r\n    if (typeof __VUE_OPTIONS_API__ !== 'boolean') {\r\n        needWarn = true;\r\n        getGlobalThis().__VUE_OPTIONS_API__ = true;\r\n    }\r\n    if (typeof __VUE_PROD_DEVTOOLS__ !== 'boolean') {\r\n        needWarn = true;\r\n        getGlobalThis().__VUE_PROD_DEVTOOLS__ = false;\r\n    }\r\n    if ((process.env.NODE_ENV !== 'production') && needWarn) {\r\n        console.warn(`You are running the esm-bundler build of Vue. It is recommended to ` +\r\n            `configure your bundler to explicitly replace feature flag globals ` +\r\n            `with boolean literals to get proper tree-shaking in the final bundle. ` +\r\n            `See http://link.vuejs.org/feature-flags for more details.`);\r\n    }\r\n}\n\nconst prodEffectOptions = {\r\n    scheduler: queueJob\r\n};\r\nfunction createDevEffectOptions(instance) {\r\n    return {\r\n        scheduler: queueJob,\r\n        onTrack: instance.rtc ? e => invokeArrayFns(instance.rtc, e) : void 0,\r\n        onTrigger: instance.rtg ? e => invokeArrayFns(instance.rtg, e) : void 0\r\n    };\r\n}\r\nconst queuePostRenderEffect =  queueEffectWithSuspense\r\n    ;\r\nconst setRef = (rawRef, oldRawRef, parentComponent, parentSuspense, vnode) => {\r\n    let value;\r\n    if (!vnode) {\r\n        value = null;\r\n    }\r\n    else {\r\n        if (vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */) {\r\n            value = vnode.component.proxy;\r\n        }\r\n        else {\r\n            value = vnode.el;\r\n        }\r\n    }\r\n    const [owner, ref] = rawRef;\r\n    if ((process.env.NODE_ENV !== 'production') && !owner) {\r\n        warn(`Missing ref owner context. ref cannot be used on hoisted vnodes. ` +\r\n            `A vnode with ref must be created inside the render function.`);\r\n        return;\r\n    }\r\n    const oldRef = oldRawRef && oldRawRef[1];\r\n    const refs = owner.refs === EMPTY_OBJ ? (owner.refs = {}) : owner.refs;\r\n    const setupState = owner.setupState;\r\n    // unset old ref\r\n    if (oldRef != null && oldRef !== ref) {\r\n        if (isString(oldRef)) {\r\n            refs[oldRef] = null;\r\n            if (hasOwn(setupState, oldRef)) {\r\n                queuePostRenderEffect(() => {\r\n                    setupState[oldRef] = null;\r\n                }, parentSuspense);\r\n            }\r\n        }\r\n        else if (isRef(oldRef)) {\r\n            oldRef.value = null;\r\n        }\r\n    }\r\n    if (isString(ref)) {\r\n        refs[ref] = value;\r\n        if (hasOwn(setupState, ref)) {\r\n            queuePostRenderEffect(() => {\r\n                setupState[ref] = value;\r\n            }, parentSuspense);\r\n        }\r\n    }\r\n    else if (isRef(ref)) {\r\n        ref.value = value;\r\n    }\r\n    else if (isFunction(ref)) {\r\n        callWithErrorHandling(ref, parentComponent, 12 /* FUNCTION_REF */, [\r\n            value,\r\n            refs\r\n        ]);\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        warn('Invalid template ref type:', value, `(${typeof value})`);\r\n    }\r\n};\r\n/**\r\n * The createRenderer function accepts two generic arguments:\r\n * HostNode and HostElement, corresponding to Node and Element types in the\r\n * host environment. For example, for runtime-dom, HostNode would be the DOM\r\n * `Node` interface and HostElement would be the DOM `Element` interface.\r\n *\r\n * Custom renderers can pass in the platform specific types like this:\r\n *\r\n * ``` js\r\n * const { render, createApp } = createRenderer<Node, Element>({\r\n *   patchProp,\r\n *   ...nodeOps\r\n * })\r\n * ```\r\n */\r\nfunction createRenderer(options) {\r\n    return baseCreateRenderer(options);\r\n}\r\n// Separate API for creating hydration-enabled renderer.\r\n// Hydration logic is only used when calling this function, making it\r\n// tree-shakable.\r\nfunction createHydrationRenderer(options) {\r\n    return baseCreateRenderer(options, createHydrationFunctions);\r\n}\r\n// implementation\r\nfunction baseCreateRenderer(options, createHydrationFns) {\r\n    // compile-time feature flags check\r\n    {\r\n        initFeatureFlags();\r\n    }\r\n    const { insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, forcePatchProp: hostForcePatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, setScopeId: hostSetScopeId = NOOP, cloneNode: hostCloneNode, insertStaticContent: hostInsertStaticContent } = options;\r\n    // Note: functions inside this closure should use `const xxx = () => {}`\r\n    // style in order to prevent being inlined by minifiers.\r\n    const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, optimized = false) => {\r\n        // patching & not same type, unmount old tree\r\n        if (n1 && !isSameVNodeType(n1, n2)) {\r\n            anchor = getNextHostNode(n1);\r\n            unmount(n1, parentComponent, parentSuspense, true);\r\n            n1 = null;\r\n        }\r\n        if (n2.patchFlag === -2 /* BAIL */) {\r\n            optimized = false;\r\n            n2.dynamicChildren = null;\r\n        }\r\n        const { type, ref, shapeFlag } = n2;\r\n        switch (type) {\r\n            case Text:\r\n                processText(n1, n2, container, anchor);\r\n                break;\r\n            case Comment:\r\n                processCommentNode(n1, n2, container, anchor);\r\n                break;\r\n            case Static:\r\n                if (n1 == null) {\r\n                    mountStaticNode(n2, container, anchor, isSVG);\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    patchStaticNode(n1, n2, container, isSVG);\r\n                }\r\n                break;\r\n            case Fragment:\r\n                processFragment(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n                break;\r\n            default:\r\n                if (shapeFlag & 1 /* ELEMENT */) {\r\n                    processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n                }\r\n                else if (shapeFlag & 6 /* COMPONENT */) {\r\n                    processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n                }\r\n                else if (shapeFlag & 64 /* TELEPORT */) {\r\n                    type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals);\r\n                }\r\n                else if ( shapeFlag & 128 /* SUSPENSE */) {\r\n                    type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals);\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn('Invalid VNode type:', type, `(${typeof type})`);\r\n                }\r\n        }\r\n        // set ref\r\n        if (ref != null && parentComponent) {\r\n            setRef(ref, n1 && n1.ref, parentComponent, parentSuspense, n2);\r\n        }\r\n    };\r\n    const processText = (n1, n2, container, anchor) => {\r\n        if (n1 == null) {\r\n            hostInsert((n2.el = hostCreateText(n2.children)), container, anchor);\r\n        }\r\n        else {\r\n            const el = (n2.el = n1.el);\r\n            if (n2.children !== n1.children) {\r\n                hostSetText(el, n2.children);\r\n            }\r\n        }\r\n    };\r\n    const processCommentNode = (n1, n2, container, anchor) => {\r\n        if (n1 == null) {\r\n            hostInsert((n2.el = hostCreateComment(n2.children || '')), container, anchor);\r\n        }\r\n        else {\r\n            // there's no support for dynamic comments\r\n            n2.el = n1.el;\r\n        }\r\n    };\r\n    const mountStaticNode = (n2, container, anchor, isSVG) => {\r\n        [n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG);\r\n    };\r\n    /**\r\n     * Dev / HMR only\r\n     */\r\n    const patchStaticNode = (n1, n2, container, isSVG) => {\r\n        // static nodes are only patched during dev for HMR\r\n        if (n2.children !== n1.children) {\r\n            const anchor = hostNextSibling(n1.anchor);\r\n            // remove existing\r\n            removeStaticNode(n1);\r\n            [n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG);\r\n        }\r\n        else {\r\n            n2.el = n1.el;\r\n            n2.anchor = n1.anchor;\r\n        }\r\n    };\r\n    /**\r\n     * Dev / HMR only\r\n     */\r\n    const moveStaticNode = (vnode, container, anchor) => {\r\n        let cur = vnode.el;\r\n        const end = vnode.anchor;\r\n        while (cur && cur !== end) {\r\n            const next = hostNextSibling(cur);\r\n            hostInsert(cur, container, anchor);\r\n            cur = next;\r\n        }\r\n        hostInsert(end, container, anchor);\r\n    };\r\n    /**\r\n     * Dev / HMR only\r\n     */\r\n    const removeStaticNode = (vnode) => {\r\n        let cur = vnode.el;\r\n        while (cur && cur !== vnode.anchor) {\r\n            const next = hostNextSibling(cur);\r\n            hostRemove(cur);\r\n            cur = next;\r\n        }\r\n        hostRemove(vnode.anchor);\r\n    };\r\n    const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {\r\n        isSVG = isSVG || n2.type === 'svg';\r\n        if (n1 == null) {\r\n            mountElement(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n        }\r\n        else {\r\n            patchElement(n1, n2, parentComponent, parentSuspense, isSVG, optimized);\r\n        }\r\n    };\r\n    const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {\r\n        let el;\r\n        let vnodeHook;\r\n        const { type, props, shapeFlag, transition, scopeId, patchFlag, dirs } = vnode;\r\n        if (!(process.env.NODE_ENV !== 'production') &&\r\n            vnode.el &&\r\n            hostCloneNode !== undefined &&\r\n            patchFlag === -1 /* HOISTED */) {\r\n            // If a vnode has non-null el, it means it's being reused.\r\n            // Only static vnodes can be reused, so its mounted DOM nodes should be\r\n            // exactly the same, and we can simply do a clone here.\r\n            // only do this in production since cloned trees cannot be HMR updated.\r\n            el = vnode.el = hostCloneNode(vnode.el);\r\n        }\r\n        else {\r\n            el = vnode.el = hostCreateElement(vnode.type, isSVG, props && props.is);\r\n            // mount children first, since some props may rely on child content\r\n            // being already rendered, e.g. `<select value>`\r\n            if (shapeFlag & 8 /* TEXT_CHILDREN */) {\r\n                hostSetElementText(el, vnode.children);\r\n            }\r\n            else if (shapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n                mountChildren(vnode.children, el, null, parentComponent, parentSuspense, isSVG && type !== 'foreignObject', optimized || !!vnode.dynamicChildren);\r\n            }\r\n            // props\r\n            if (props) {\r\n                for (const key in props) {\r\n                    if (!isReservedProp(key)) {\r\n                        hostPatchProp(el, key, null, props[key], isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);\r\n                    }\r\n                }\r\n                if ((vnodeHook = props.onVnodeBeforeMount)) {\r\n                    invokeVNodeHook(vnodeHook, parentComponent, vnode);\r\n                }\r\n            }\r\n            if (dirs) {\r\n                invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount');\r\n            }\r\n            // scopeId\r\n            if (scopeId) {\r\n                hostSetScopeId(el, scopeId);\r\n            }\r\n            const treeOwnerId = parentComponent && parentComponent.type.__scopeId;\r\n            // vnode's own scopeId and the current patched component's scopeId is\r\n            // different - this is a slot content node.\r\n            if (treeOwnerId && treeOwnerId !== scopeId) {\r\n                hostSetScopeId(el, treeOwnerId + '-s');\r\n            }\r\n            if (transition && !transition.persisted) {\r\n                transition.beforeEnter(el);\r\n            }\r\n        }\r\n        hostInsert(el, container, anchor);\r\n        // #1583 For inside suspense + suspense not resolved case, enter hook should call when suspense resolved\r\n        // #1689 For inside suspense + suspense resolved case, just call it\r\n        const needCallTransitionHooks = (!parentSuspense || (parentSuspense && parentSuspense.isResolved)) &&\r\n            transition &&\r\n            !transition.persisted;\r\n        if ((vnodeHook = props && props.onVnodeMounted) ||\r\n            needCallTransitionHooks ||\r\n            dirs) {\r\n            queuePostRenderEffect(() => {\r\n                vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);\r\n                needCallTransitionHooks && transition.enter(el);\r\n                dirs && invokeDirectiveHook(vnode, null, parentComponent, 'mounted');\r\n            }, parentSuspense);\r\n        }\r\n    };\r\n    const mountChildren = (children, container, anchor, parentComponent, parentSuspense, isSVG, optimized, start = 0) => {\r\n        for (let i = start; i < children.length; i++) {\r\n            const child = (children[i] = optimized\r\n                ? cloneIfMounted(children[i])\r\n                : normalizeVNode(children[i]));\r\n            patch(null, child, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n        }\r\n    };\r\n    const patchElement = (n1, n2, parentComponent, parentSuspense, isSVG, optimized) => {\r\n        const el = (n2.el = n1.el);\r\n        let { patchFlag, dynamicChildren, dirs } = n2;\r\n        // #1426 take the old vnode's patch flag into account since user may clone a\r\n        // compiler-generated vnode, which de-opts to FULL_PROPS\r\n        patchFlag |= n1.patchFlag & 16 /* FULL_PROPS */;\r\n        const oldProps = n1.props || EMPTY_OBJ;\r\n        const newProps = n2.props || EMPTY_OBJ;\r\n        let vnodeHook;\r\n        if ((vnodeHook = newProps.onVnodeBeforeUpdate)) {\r\n            invokeVNodeHook(vnodeHook, parentComponent, n2, n1);\r\n        }\r\n        if (dirs) {\r\n            invokeDirectiveHook(n2, n1, parentComponent, 'beforeUpdate');\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production') && isHmrUpdating) {\r\n            // HMR updated, force full diff\r\n            patchFlag = 0;\r\n            optimized = false;\r\n            dynamicChildren = null;\r\n        }\r\n        if (patchFlag > 0) {\r\n            // the presence of a patchFlag means this element's render code was\r\n            // generated by the compiler and can take the fast path.\r\n            // in this path old node and new node are guaranteed to have the same shape\r\n            // (i.e. at the exact same position in the source template)\r\n            if (patchFlag & 16 /* FULL_PROPS */) {\r\n                // element props contain dynamic keys, full diff needed\r\n                patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG);\r\n            }\r\n            else {\r\n                // class\r\n                // this flag is matched when the element has dynamic class bindings.\r\n                if (patchFlag & 2 /* CLASS */) {\r\n                    if (oldProps.class !== newProps.class) {\r\n                        hostPatchProp(el, 'class', null, newProps.class, isSVG);\r\n                    }\r\n                }\r\n                // style\r\n                // this flag is matched when the element has dynamic style bindings\r\n                if (patchFlag & 4 /* STYLE */) {\r\n                    hostPatchProp(el, 'style', oldProps.style, newProps.style, isSVG);\r\n                }\r\n                // props\r\n                // This flag is matched when the element has dynamic prop/attr bindings\r\n                // other than class and style. The keys of dynamic prop/attrs are saved for\r\n                // faster iteration.\r\n                // Note dynamic keys like :[foo]=\"bar\" will cause this optimization to\r\n                // bail out and go through a full diff because we need to unset the old key\r\n                if (patchFlag & 8 /* PROPS */) {\r\n                    // if the flag is present then dynamicProps must be non-null\r\n                    const propsToUpdate = n2.dynamicProps;\r\n                    for (let i = 0; i < propsToUpdate.length; i++) {\r\n                        const key = propsToUpdate[i];\r\n                        const prev = oldProps[key];\r\n                        const next = newProps[key];\r\n                        if (next !== prev ||\r\n                            (hostForcePatchProp && hostForcePatchProp(el, key))) {\r\n                            hostPatchProp(el, key, prev, next, isSVG, n1.children, parentComponent, parentSuspense, unmountChildren);\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n            // text\r\n            // This flag is matched when the element has only dynamic text children.\r\n            if (patchFlag & 1 /* TEXT */) {\r\n                if (n1.children !== n2.children) {\r\n                    hostSetElementText(el, n2.children);\r\n                }\r\n            }\r\n        }\r\n        else if (!optimized && dynamicChildren == null) {\r\n            // unoptimized, full diff\r\n            patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG);\r\n        }\r\n        const areChildrenSVG = isSVG && n2.type !== 'foreignObject';\r\n        if (dynamicChildren) {\r\n            patchBlockChildren(n1.dynamicChildren, dynamicChildren, el, parentComponent, parentSuspense, areChildrenSVG);\r\n            if ((process.env.NODE_ENV !== 'production') && parentComponent && parentComponent.type.__hmrId) {\r\n                traverseStaticChildren(n1, n2);\r\n            }\r\n        }\r\n        else if (!optimized) {\r\n            // full diff\r\n            patchChildren(n1, n2, el, null, parentComponent, parentSuspense, areChildrenSVG);\r\n        }\r\n        if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {\r\n            queuePostRenderEffect(() => {\r\n                vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);\r\n                dirs && invokeDirectiveHook(n2, n1, parentComponent, 'updated');\r\n            }, parentSuspense);\r\n        }\r\n    };\r\n    // The fast path for blocks.\r\n    const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, isSVG) => {\r\n        for (let i = 0; i < newChildren.length; i++) {\r\n            const oldVNode = oldChildren[i];\r\n            const newVNode = newChildren[i];\r\n            // Determine the container (parent element) for the patch.\r\n            const container = \r\n            // - In the case of a Fragment, we need to provide the actual parent\r\n            // of the Fragment itself so it can move its children.\r\n            oldVNode.type === Fragment ||\r\n                // - In the case of different nodes, there is going to be a replacement\r\n                // which also requires the correct parent container\r\n                !isSameVNodeType(oldVNode, newVNode) ||\r\n                // - In the case of a component, it could contain anything.\r\n                oldVNode.shapeFlag & 6 /* COMPONENT */ ||\r\n                oldVNode.shapeFlag & 64 /* TELEPORT */\r\n                ? hostParentNode(oldVNode.el)\r\n                : // In other cases, the parent container is not actually used so we\r\n                    // just pass the block element here to avoid a DOM parentNode call.\r\n                    fallbackContainer;\r\n            patch(oldVNode, newVNode, container, null, parentComponent, parentSuspense, isSVG, true);\r\n        }\r\n    };\r\n    const patchProps = (el, vnode, oldProps, newProps, parentComponent, parentSuspense, isSVG) => {\r\n        if (oldProps !== newProps) {\r\n            for (const key in newProps) {\r\n                if (isReservedProp(key))\r\n                    continue;\r\n                const next = newProps[key];\r\n                const prev = oldProps[key];\r\n                if (next !== prev ||\r\n                    (hostForcePatchProp && hostForcePatchProp(el, key))) {\r\n                    hostPatchProp(el, key, prev, next, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);\r\n                }\r\n            }\r\n            if (oldProps !== EMPTY_OBJ) {\r\n                for (const key in oldProps) {\r\n                    if (!isReservedProp(key) && !(key in newProps)) {\r\n                        hostPatchProp(el, key, oldProps[key], null, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    };\r\n    const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {\r\n        const fragmentStartAnchor = (n2.el = n1 ? n1.el : hostCreateText(''));\r\n        const fragmentEndAnchor = (n2.anchor = n1 ? n1.anchor : hostCreateText(''));\r\n        let { patchFlag, dynamicChildren } = n2;\r\n        if (patchFlag > 0) {\r\n            optimized = true;\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production') && isHmrUpdating) {\r\n            // HMR updated, force full diff\r\n            patchFlag = 0;\r\n            optimized = false;\r\n            dynamicChildren = null;\r\n        }\r\n        if (n1 == null) {\r\n            hostInsert(fragmentStartAnchor, container, anchor);\r\n            hostInsert(fragmentEndAnchor, container, anchor);\r\n            // a fragment can only have array children\r\n            // since they are either generated by the compiler, or implicitly created\r\n            // from arrays.\r\n            mountChildren(n2.children, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, optimized);\r\n        }\r\n        else {\r\n            if (patchFlag > 0 &&\r\n                patchFlag & 64 /* STABLE_FRAGMENT */ &&\r\n                dynamicChildren) {\r\n                // a stable fragment (template root or <template v-for>) doesn't need to\r\n                // patch children order, but it may contain dynamicChildren.\r\n                patchBlockChildren(n1.dynamicChildren, dynamicChildren, container, parentComponent, parentSuspense, isSVG);\r\n                if ((process.env.NODE_ENV !== 'production') && parentComponent && parentComponent.type.__hmrId) {\r\n                    traverseStaticChildren(n1, n2);\r\n                }\r\n            }\r\n            else {\r\n                // keyed / unkeyed, or manual fragments.\r\n                // for keyed & unkeyed, since they are compiler generated from v-for,\r\n                // each child is guaranteed to be a block so the fragment will never\r\n                // have dynamicChildren.\r\n                patchChildren(n1, n2, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, optimized);\r\n            }\r\n        }\r\n    };\r\n    const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {\r\n        if (n1 == null) {\r\n            if (n2.shapeFlag & 512 /* COMPONENT_KEPT_ALIVE */) {\r\n                parentComponent.ctx.activate(n2, container, anchor, isSVG, optimized);\r\n            }\r\n            else {\r\n                mountComponent(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n            }\r\n        }\r\n        else {\r\n            updateComponent(n1, n2, optimized);\r\n        }\r\n    };\r\n    const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {\r\n        const instance = (initialVNode.component = createComponentInstance(initialVNode, parentComponent, parentSuspense));\r\n        if ((process.env.NODE_ENV !== 'production') && instance.type.__hmrId) {\r\n            registerHMR(instance);\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            pushWarningContext(initialVNode);\r\n            startMeasure(instance, `mount`);\r\n        }\r\n        // inject renderer internals for keepAlive\r\n        if (isKeepAlive(initialVNode)) {\r\n            instance.ctx.renderer = internals;\r\n        }\r\n        // resolve props and slots for setup context\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            startMeasure(instance, `init`);\r\n        }\r\n        setupComponent(instance);\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            endMeasure(instance, `init`);\r\n        }\r\n        // setup() is async. This component relies on async logic to be resolved\r\n        // before proceeding\r\n        if ( instance.asyncDep) {\r\n            if (!parentSuspense) {\r\n                if ((process.env.NODE_ENV !== 'production'))\r\n                    warn('async setup() is used without a suspense boundary!');\r\n                return;\r\n            }\r\n            parentSuspense.registerDep(instance, setupRenderEffect);\r\n            // Give it a placeholder if this is not hydration\r\n            if (!initialVNode.el) {\r\n                const placeholder = (instance.subTree = createVNode(Comment));\r\n                processCommentNode(null, placeholder, container, anchor);\r\n            }\r\n            return;\r\n        }\r\n        setupRenderEffect(instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized);\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            popWarningContext();\r\n            endMeasure(instance, `mount`);\r\n        }\r\n    };\r\n    const updateComponent = (n1, n2, optimized) => {\r\n        const instance = (n2.component = n1.component);\r\n        if (shouldUpdateComponent(n1, n2, optimized)) {\r\n            if (\r\n                instance.asyncDep &&\r\n                !instance.asyncResolved) {\r\n                // async & still pending - just update props and slots\r\n                // since the component's reactive effect for render isn't set-up yet\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    pushWarningContext(n2);\r\n                }\r\n                updateComponentPreRender(instance, n2, optimized);\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    popWarningContext();\r\n                }\r\n                return;\r\n            }\r\n            else {\r\n                // normal update\r\n                instance.next = n2;\r\n                // in case the child component is also queued, remove it to avoid\r\n                // double updating the same child component in the same flush.\r\n                invalidateJob(instance.update);\r\n                // instance.update is the reactive effect runner.\r\n                instance.update();\r\n            }\r\n        }\r\n        else {\r\n            // no update needed. just copy over properties\r\n            n2.component = n1.component;\r\n            n2.el = n1.el;\r\n            instance.vnode = n2;\r\n        }\r\n    };\r\n    const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized) => {\r\n        // create reactive effect for rendering\r\n        instance.update = effect(function componentEffect() {\r\n            if (!instance.isMounted) {\r\n                let vnodeHook;\r\n                const { el, props } = initialVNode;\r\n                const { bm, m, a, parent } = instance;\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    startMeasure(instance, `render`);\r\n                }\r\n                const subTree = (instance.subTree = renderComponentRoot(instance));\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    endMeasure(instance, `render`);\r\n                }\r\n                // beforeMount hook\r\n                if (bm) {\r\n                    invokeArrayFns(bm);\r\n                }\r\n                // onVnodeBeforeMount\r\n                if ((vnodeHook = props && props.onVnodeBeforeMount)) {\r\n                    invokeVNodeHook(vnodeHook, parent, initialVNode);\r\n                }\r\n                if (el && hydrateNode) {\r\n                    if ((process.env.NODE_ENV !== 'production')) {\r\n                        startMeasure(instance, `hydrate`);\r\n                    }\r\n                    // vnode has adopted host node - perform hydration instead of mount.\r\n                    hydrateNode(initialVNode.el, subTree, instance, parentSuspense);\r\n                    if ((process.env.NODE_ENV !== 'production')) {\r\n                        endMeasure(instance, `hydrate`);\r\n                    }\r\n                }\r\n                else {\r\n                    if ((process.env.NODE_ENV !== 'production')) {\r\n                        startMeasure(instance, `patch`);\r\n                    }\r\n                    patch(null, subTree, container, anchor, instance, parentSuspense, isSVG);\r\n                    if ((process.env.NODE_ENV !== 'production')) {\r\n                        endMeasure(instance, `patch`);\r\n                    }\r\n                    initialVNode.el = subTree.el;\r\n                }\r\n                // mounted hook\r\n                if (m) {\r\n                    queuePostRenderEffect(m, parentSuspense);\r\n                }\r\n                // onVnodeMounted\r\n                if ((vnodeHook = props && props.onVnodeMounted)) {\r\n                    queuePostRenderEffect(() => {\r\n                        invokeVNodeHook(vnodeHook, parent, initialVNode);\r\n                    }, parentSuspense);\r\n                }\r\n                // activated hook for keep-alive roots.\r\n                if (a &&\r\n                    initialVNode.shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) {\r\n                    queuePostRenderEffect(a, parentSuspense);\r\n                }\r\n                instance.isMounted = true;\r\n            }\r\n            else {\r\n                // updateComponent\r\n                // This is triggered by mutation of component's own state (next: null)\r\n                // OR parent calling processComponent (next: VNode)\r\n                let { next, bu, u, parent, vnode } = instance;\r\n                let originNext = next;\r\n                let vnodeHook;\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    pushWarningContext(next || instance.vnode);\r\n                }\r\n                if (next) {\r\n                    updateComponentPreRender(instance, next, optimized);\r\n                }\r\n                else {\r\n                    next = vnode;\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    startMeasure(instance, `render`);\r\n                }\r\n                const nextTree = renderComponentRoot(instance);\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    endMeasure(instance, `render`);\r\n                }\r\n                const prevTree = instance.subTree;\r\n                instance.subTree = nextTree;\r\n                next.el = vnode.el;\r\n                // beforeUpdate hook\r\n                if (bu) {\r\n                    invokeArrayFns(bu);\r\n                }\r\n                // onVnodeBeforeUpdate\r\n                if ((vnodeHook = next.props && next.props.onVnodeBeforeUpdate)) {\r\n                    invokeVNodeHook(vnodeHook, parent, next, vnode);\r\n                }\r\n                // reset refs\r\n                // only needed if previous patch had refs\r\n                if (instance.refs !== EMPTY_OBJ) {\r\n                    instance.refs = {};\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    startMeasure(instance, `patch`);\r\n                }\r\n                patch(prevTree, nextTree, \r\n                // parent may have changed if it's in a teleport\r\n                hostParentNode(prevTree.el), \r\n                // anchor may have changed if it's in a fragment\r\n                getNextHostNode(prevTree), instance, parentSuspense, isSVG);\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    endMeasure(instance, `patch`);\r\n                }\r\n                next.el = nextTree.el;\r\n                if (originNext === null) {\r\n                    // self-triggered update. In case of HOC, update parent component\r\n                    // vnode el. HOC is indicated by parent instance's subTree pointing\r\n                    // to child component's vnode\r\n                    updateHOCHostEl(instance, nextTree.el);\r\n                }\r\n                // updated hook\r\n                if (u) {\r\n                    queuePostRenderEffect(u, parentSuspense);\r\n                }\r\n                // onVnodeUpdated\r\n                if ((vnodeHook = next.props && next.props.onVnodeUpdated)) {\r\n                    queuePostRenderEffect(() => {\r\n                        invokeVNodeHook(vnodeHook, parent, next, vnode);\r\n                    }, parentSuspense);\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n                    devtoolsComponentUpdated(instance);\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    popWarningContext();\r\n                }\r\n            }\r\n        }, (process.env.NODE_ENV !== 'production') ? createDevEffectOptions(instance) : prodEffectOptions);\r\n    };\r\n    const updateComponentPreRender = (instance, nextVNode, optimized) => {\r\n        if ((process.env.NODE_ENV !== 'production') && instance.type.__hmrId) {\r\n            optimized = false;\r\n        }\r\n        nextVNode.component = instance;\r\n        const prevProps = instance.vnode.props;\r\n        instance.vnode = nextVNode;\r\n        instance.next = null;\r\n        updateProps(instance, nextVNode.props, prevProps, optimized);\r\n        updateSlots(instance, nextVNode.children);\r\n    };\r\n    const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized = false) => {\r\n        const c1 = n1 && n1.children;\r\n        const prevShapeFlag = n1 ? n1.shapeFlag : 0;\r\n        const c2 = n2.children;\r\n        const { patchFlag, shapeFlag } = n2;\r\n        // fast path\r\n        if (patchFlag > 0) {\r\n            if (patchFlag & 128 /* KEYED_FRAGMENT */) {\r\n                // this could be either fully-keyed or mixed (some keyed some not)\r\n                // presence of patchFlag means children are guaranteed to be arrays\r\n                patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n                return;\r\n            }\r\n            else if (patchFlag & 256 /* UNKEYED_FRAGMENT */) {\r\n                // unkeyed\r\n                patchUnkeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n                return;\r\n            }\r\n        }\r\n        // children has 3 possibilities: text, array or no children.\r\n        if (shapeFlag & 8 /* TEXT_CHILDREN */) {\r\n            // text children fast path\r\n            if (prevShapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n                unmountChildren(c1, parentComponent, parentSuspense);\r\n            }\r\n            if (c2 !== c1) {\r\n                hostSetElementText(container, c2);\r\n            }\r\n        }\r\n        else {\r\n            if (prevShapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n                // prev children was array\r\n                if (shapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n                    // two arrays, cannot assume anything, do full diff\r\n                    patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n                }\r\n                else {\r\n                    // no new children, just unmount old\r\n                    unmountChildren(c1, parentComponent, parentSuspense, true);\r\n                }\r\n            }\r\n            else {\r\n                // prev children was text OR null\r\n                // new children is array OR null\r\n                if (prevShapeFlag & 8 /* TEXT_CHILDREN */) {\r\n                    hostSetElementText(container, '');\r\n                }\r\n                // mount new if array\r\n                if (shapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n                    mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n                }\r\n            }\r\n        }\r\n    };\r\n    const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {\r\n        c1 = c1 || EMPTY_ARR;\r\n        c2 = c2 || EMPTY_ARR;\r\n        const oldLength = c1.length;\r\n        const newLength = c2.length;\r\n        const commonLength = Math.min(oldLength, newLength);\r\n        let i;\r\n        for (i = 0; i < commonLength; i++) {\r\n            const nextChild = (c2[i] = optimized\r\n                ? cloneIfMounted(c2[i])\r\n                : normalizeVNode(c2[i]));\r\n            patch(c1[i], nextChild, container, null, parentComponent, parentSuspense, isSVG, optimized);\r\n        }\r\n        if (oldLength > newLength) {\r\n            // remove old\r\n            unmountChildren(c1, parentComponent, parentSuspense, true, commonLength);\r\n        }\r\n        else {\r\n            // mount new\r\n            mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, commonLength);\r\n        }\r\n    };\r\n    // can be all-keyed or mixed\r\n    const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, isSVG, optimized) => {\r\n        let i = 0;\r\n        const l2 = c2.length;\r\n        let e1 = c1.length - 1; // prev ending index\r\n        let e2 = l2 - 1; // next ending index\r\n        // 1. sync from start\r\n        // (a b) c\r\n        // (a b) d e\r\n        while (i <= e1 && i <= e2) {\r\n            const n1 = c1[i];\r\n            const n2 = (c2[i] = optimized\r\n                ? cloneIfMounted(c2[i])\r\n                : normalizeVNode(c2[i]));\r\n            if (isSameVNodeType(n1, n2)) {\r\n                patch(n1, n2, container, null, parentComponent, parentSuspense, isSVG, optimized);\r\n            }\r\n            else {\r\n                break;\r\n            }\r\n            i++;\r\n        }\r\n        // 2. sync from end\r\n        // a (b c)\r\n        // d e (b c)\r\n        while (i <= e1 && i <= e2) {\r\n            const n1 = c1[e1];\r\n            const n2 = (c2[e2] = optimized\r\n                ? cloneIfMounted(c2[e2])\r\n                : normalizeVNode(c2[e2]));\r\n            if (isSameVNodeType(n1, n2)) {\r\n                patch(n1, n2, container, null, parentComponent, parentSuspense, isSVG, optimized);\r\n            }\r\n            else {\r\n                break;\r\n            }\r\n            e1--;\r\n            e2--;\r\n        }\r\n        // 3. common sequence + mount\r\n        // (a b)\r\n        // (a b) c\r\n        // i = 2, e1 = 1, e2 = 2\r\n        // (a b)\r\n        // c (a b)\r\n        // i = 0, e1 = -1, e2 = 0\r\n        if (i > e1) {\r\n            if (i <= e2) {\r\n                const nextPos = e2 + 1;\r\n                const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;\r\n                while (i <= e2) {\r\n                    patch(null, (c2[i] = optimized\r\n                        ? cloneIfMounted(c2[i])\r\n                        : normalizeVNode(c2[i])), container, anchor, parentComponent, parentSuspense, isSVG);\r\n                    i++;\r\n                }\r\n            }\r\n        }\r\n        // 4. common sequence + unmount\r\n        // (a b) c\r\n        // (a b)\r\n        // i = 2, e1 = 2, e2 = 1\r\n        // a (b c)\r\n        // (b c)\r\n        // i = 0, e1 = 0, e2 = -1\r\n        else if (i > e2) {\r\n            while (i <= e1) {\r\n                unmount(c1[i], parentComponent, parentSuspense, true);\r\n                i++;\r\n            }\r\n        }\r\n        // 5. unknown sequence\r\n        // [i ... e1 + 1]: a b [c d e] f g\r\n        // [i ... e2 + 1]: a b [e d c h] f g\r\n        // i = 2, e1 = 4, e2 = 5\r\n        else {\r\n            const s1 = i; // prev starting index\r\n            const s2 = i; // next starting index\r\n            // 5.1 build key:index map for newChildren\r\n            const keyToNewIndexMap = new Map();\r\n            for (i = s2; i <= e2; i++) {\r\n                const nextChild = (c2[i] = optimized\r\n                    ? cloneIfMounted(c2[i])\r\n                    : normalizeVNode(c2[i]));\r\n                if (nextChild.key != null) {\r\n                    if ((process.env.NODE_ENV !== 'production') && keyToNewIndexMap.has(nextChild.key)) {\r\n                        warn(`Duplicate keys found during update:`, JSON.stringify(nextChild.key), `Make sure keys are unique.`);\r\n                    }\r\n                    keyToNewIndexMap.set(nextChild.key, i);\r\n                }\r\n            }\r\n            // 5.2 loop through old children left to be patched and try to patch\r\n            // matching nodes & remove nodes that are no longer present\r\n            let j;\r\n            let patched = 0;\r\n            const toBePatched = e2 - s2 + 1;\r\n            let moved = false;\r\n            // used to track whether any node has moved\r\n            let maxNewIndexSoFar = 0;\r\n            // works as Map<newIndex, oldIndex>\r\n            // Note that oldIndex is offset by +1\r\n            // and oldIndex = 0 is a special value indicating the new node has\r\n            // no corresponding old node.\r\n            // used for determining longest stable subsequence\r\n            const newIndexToOldIndexMap = new Array(toBePatched);\r\n            for (i = 0; i < toBePatched; i++)\r\n                newIndexToOldIndexMap[i] = 0;\r\n            for (i = s1; i <= e1; i++) {\r\n                const prevChild = c1[i];\r\n                if (patched >= toBePatched) {\r\n                    // all new children have been patched so this can only be a removal\r\n                    unmount(prevChild, parentComponent, parentSuspense, true);\r\n                    continue;\r\n                }\r\n                let newIndex;\r\n                if (prevChild.key != null) {\r\n                    newIndex = keyToNewIndexMap.get(prevChild.key);\r\n                }\r\n                else {\r\n                    // key-less node, try to locate a key-less node of the same type\r\n                    for (j = s2; j <= e2; j++) {\r\n                        if (newIndexToOldIndexMap[j - s2] === 0 &&\r\n                            isSameVNodeType(prevChild, c2[j])) {\r\n                            newIndex = j;\r\n                            break;\r\n                        }\r\n                    }\r\n                }\r\n                if (newIndex === undefined) {\r\n                    unmount(prevChild, parentComponent, parentSuspense, true);\r\n                }\r\n                else {\r\n                    newIndexToOldIndexMap[newIndex - s2] = i + 1;\r\n                    if (newIndex >= maxNewIndexSoFar) {\r\n                        maxNewIndexSoFar = newIndex;\r\n                    }\r\n                    else {\r\n                        moved = true;\r\n                    }\r\n                    patch(prevChild, c2[newIndex], container, null, parentComponent, parentSuspense, isSVG, optimized);\r\n                    patched++;\r\n                }\r\n            }\r\n            // 5.3 move and mount\r\n            // generate longest stable subsequence only when nodes have moved\r\n            const increasingNewIndexSequence = moved\r\n                ? getSequence(newIndexToOldIndexMap)\r\n                : EMPTY_ARR;\r\n            j = increasingNewIndexSequence.length - 1;\r\n            // looping backwards so that we can use last patched node as anchor\r\n            for (i = toBePatched - 1; i >= 0; i--) {\r\n                const nextIndex = s2 + i;\r\n                const nextChild = c2[nextIndex];\r\n                const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor;\r\n                if (newIndexToOldIndexMap[i] === 0) {\r\n                    // mount new\r\n                    patch(null, nextChild, container, anchor, parentComponent, parentSuspense, isSVG);\r\n                }\r\n                else if (moved) {\r\n                    // move if:\r\n                    // There is no stable subsequence (e.g. a reverse)\r\n                    // OR current node is not among the stable sequence\r\n                    if (j < 0 || i !== increasingNewIndexSequence[j]) {\r\n                        move(nextChild, container, anchor, 2 /* REORDER */);\r\n                    }\r\n                    else {\r\n                        j--;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    };\r\n    const move = (vnode, container, anchor, moveType, parentSuspense = null) => {\r\n        const { el, type, transition, children, shapeFlag } = vnode;\r\n        if (shapeFlag & 6 /* COMPONENT */) {\r\n            move(vnode.component.subTree, container, anchor, moveType);\r\n            return;\r\n        }\r\n        if ( shapeFlag & 128 /* SUSPENSE */) {\r\n            vnode.suspense.move(container, anchor, moveType);\r\n            return;\r\n        }\r\n        if (shapeFlag & 64 /* TELEPORT */) {\r\n            type.move(vnode, container, anchor, internals);\r\n            return;\r\n        }\r\n        if (type === Fragment) {\r\n            hostInsert(el, container, anchor);\r\n            for (let i = 0; i < children.length; i++) {\r\n                move(children[i], container, anchor, moveType);\r\n            }\r\n            hostInsert(vnode.anchor, container, anchor);\r\n            return;\r\n        }\r\n        // static node move can only happen when force updating HMR\r\n        if ((process.env.NODE_ENV !== 'production') && type === Static) {\r\n            moveStaticNode(vnode, container, anchor);\r\n            return;\r\n        }\r\n        // single nodes\r\n        const needTransition = moveType !== 2 /* REORDER */ &&\r\n            shapeFlag & 1 /* ELEMENT */ &&\r\n            transition;\r\n        if (needTransition) {\r\n            if (moveType === 0 /* ENTER */) {\r\n                transition.beforeEnter(el);\r\n                hostInsert(el, container, anchor);\r\n                queuePostRenderEffect(() => transition.enter(el), parentSuspense);\r\n            }\r\n            else {\r\n                const { leave, delayLeave, afterLeave } = transition;\r\n                const remove = () => hostInsert(el, container, anchor);\r\n                const performLeave = () => {\r\n                    leave(el, () => {\r\n                        remove();\r\n                        afterLeave && afterLeave();\r\n                    });\r\n                };\r\n                if (delayLeave) {\r\n                    delayLeave(el, remove, performLeave);\r\n                }\r\n                else {\r\n                    performLeave();\r\n                }\r\n            }\r\n        }\r\n        else {\r\n            hostInsert(el, container, anchor);\r\n        }\r\n    };\r\n    const unmount = (vnode, parentComponent, parentSuspense, doRemove = false) => {\r\n        const { type, props, ref, children, dynamicChildren, shapeFlag, patchFlag, dirs } = vnode;\r\n        // unset ref\r\n        if (ref != null && parentComponent) {\r\n            setRef(ref, null, parentComponent, parentSuspense, null);\r\n        }\r\n        if (shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) {\r\n            parentComponent.ctx.deactivate(vnode);\r\n            return;\r\n        }\r\n        const shouldInvokeDirs = shapeFlag & 1 /* ELEMENT */ && dirs;\r\n        let vnodeHook;\r\n        if ((vnodeHook = props && props.onVnodeBeforeUnmount)) {\r\n            invokeVNodeHook(vnodeHook, parentComponent, vnode);\r\n        }\r\n        if (shapeFlag & 6 /* COMPONENT */) {\r\n            unmountComponent(vnode.component, parentSuspense, doRemove);\r\n        }\r\n        else {\r\n            if ( shapeFlag & 128 /* SUSPENSE */) {\r\n                vnode.suspense.unmount(parentSuspense, doRemove);\r\n                return;\r\n            }\r\n            if (shouldInvokeDirs) {\r\n                invokeDirectiveHook(vnode, null, parentComponent, 'beforeUnmount');\r\n            }\r\n            if (dynamicChildren &&\r\n                // #1153: fast path should not be taken for non-stable (v-for) fragments\r\n                (type !== Fragment ||\r\n                    (patchFlag > 0 && patchFlag & 64 /* STABLE_FRAGMENT */))) {\r\n                // fast path for block nodes: only need to unmount dynamic children.\r\n                unmountChildren(dynamicChildren, parentComponent, parentSuspense);\r\n            }\r\n            else if (shapeFlag & 16 /* ARRAY_CHILDREN */) {\r\n                unmountChildren(children, parentComponent, parentSuspense);\r\n            }\r\n            // an unmounted teleport should always remove its children\r\n            if (shapeFlag & 64 /* TELEPORT */) {\r\n                vnode.type.remove(vnode, internals);\r\n            }\r\n            if (doRemove) {\r\n                remove(vnode);\r\n            }\r\n        }\r\n        if ((vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {\r\n            queuePostRenderEffect(() => {\r\n                vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);\r\n                shouldInvokeDirs &&\r\n                    invokeDirectiveHook(vnode, null, parentComponent, 'unmounted');\r\n            }, parentSuspense);\r\n        }\r\n    };\r\n    const remove = vnode => {\r\n        const { type, el, anchor, transition } = vnode;\r\n        if (type === Fragment) {\r\n            removeFragment(el, anchor);\r\n            return;\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production') && type === Static) {\r\n            removeStaticNode(vnode);\r\n            return;\r\n        }\r\n        const performRemove = () => {\r\n            hostRemove(el);\r\n            if (transition && !transition.persisted && transition.afterLeave) {\r\n                transition.afterLeave();\r\n            }\r\n        };\r\n        if (vnode.shapeFlag & 1 /* ELEMENT */ &&\r\n            transition &&\r\n            !transition.persisted) {\r\n            const { leave, delayLeave } = transition;\r\n            const performLeave = () => leave(el, performRemove);\r\n            if (delayLeave) {\r\n                delayLeave(vnode.el, performRemove, performLeave);\r\n            }\r\n            else {\r\n                performLeave();\r\n            }\r\n        }\r\n        else {\r\n            performRemove();\r\n        }\r\n    };\r\n    const removeFragment = (cur, end) => {\r\n        // For fragments, directly remove all contained DOM nodes.\r\n        // (fragment child nodes cannot have transition)\r\n        let next;\r\n        while (cur !== end) {\r\n            next = hostNextSibling(cur);\r\n            hostRemove(cur);\r\n            cur = next;\r\n        }\r\n        hostRemove(end);\r\n    };\r\n    const unmountComponent = (instance, parentSuspense, doRemove) => {\r\n        if ((process.env.NODE_ENV !== 'production') && instance.type.__hmrId) {\r\n            unregisterHMR(instance);\r\n        }\r\n        const { bum, effects, update, subTree, um, da, isDeactivated } = instance;\r\n        // beforeUnmount hook\r\n        if (bum) {\r\n            invokeArrayFns(bum);\r\n        }\r\n        if (effects) {\r\n            for (let i = 0; i < effects.length; i++) {\r\n                stop(effects[i]);\r\n            }\r\n        }\r\n        // update may be null if a component is unmounted before its async\r\n        // setup has resolved.\r\n        if (update) {\r\n            stop(update);\r\n            unmount(subTree, instance, parentSuspense, doRemove);\r\n        }\r\n        // unmounted hook\r\n        if (um) {\r\n            queuePostRenderEffect(um, parentSuspense);\r\n        }\r\n        // deactivated hook\r\n        if (da &&\r\n            !isDeactivated &&\r\n            instance.vnode.shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) {\r\n            queuePostRenderEffect(da, parentSuspense);\r\n        }\r\n        queuePostRenderEffect(() => {\r\n            instance.isUnmounted = true;\r\n        }, parentSuspense);\r\n        // A component with async dep inside a pending suspense is unmounted before\r\n        // its async dep resolves. This should remove the dep from the suspense, and\r\n        // cause the suspense to resolve immediately if that was the last dep.\r\n        if (\r\n            parentSuspense &&\r\n            !parentSuspense.isResolved &&\r\n            !parentSuspense.isUnmounted &&\r\n            instance.asyncDep &&\r\n            !instance.asyncResolved) {\r\n            parentSuspense.deps--;\r\n            if (parentSuspense.deps === 0) {\r\n                parentSuspense.resolve();\r\n            }\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n            devtoolsComponentRemoved(instance);\r\n        }\r\n    };\r\n    const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, start = 0) => {\r\n        for (let i = start; i < children.length; i++) {\r\n            unmount(children[i], parentComponent, parentSuspense, doRemove);\r\n        }\r\n    };\r\n    const getNextHostNode = vnode => {\r\n        if (vnode.shapeFlag & 6 /* COMPONENT */) {\r\n            return getNextHostNode(vnode.component.subTree);\r\n        }\r\n        if ( vnode.shapeFlag & 128 /* SUSPENSE */) {\r\n            return vnode.suspense.next();\r\n        }\r\n        return hostNextSibling((vnode.anchor || vnode.el));\r\n    };\r\n    /**\r\n     * #1156\r\n     * When a component is HMR-enabled, we need to make sure that all static nodes\r\n     * inside a block also inherit the DOM element from the previous tree so that\r\n     * HMR updates (which are full updates) can retrieve the element for patching.\r\n     *\r\n     * Dev only.\r\n     */\r\n    const traverseStaticChildren = (n1, n2) => {\r\n        const ch1 = n1.children;\r\n        const ch2 = n2.children;\r\n        if (isArray(ch1) && isArray(ch2)) {\r\n            for (let i = 0; i < ch1.length; i++) {\r\n                // this is only called in the optimized path so array children are\r\n                // guaranteed to be vnodes\r\n                const c1 = ch1[i];\r\n                const c2 = (ch2[i] = cloneIfMounted(ch2[i]));\r\n                if (c2.shapeFlag & 1 /* ELEMENT */ && !c2.dynamicChildren) {\r\n                    if (c2.patchFlag <= 0 || c2.patchFlag === 32 /* HYDRATE_EVENTS */) {\r\n                        c2.el = c1.el;\r\n                    }\r\n                    traverseStaticChildren(c1, c2);\r\n                }\r\n            }\r\n        }\r\n    };\r\n    const render = (vnode, container) => {\r\n        if (vnode == null) {\r\n            if (container._vnode) {\r\n                unmount(container._vnode, null, null, true);\r\n            }\r\n        }\r\n        else {\r\n            patch(container._vnode || null, vnode, container);\r\n        }\r\n        flushPostFlushCbs();\r\n        container._vnode = vnode;\r\n    };\r\n    const internals = {\r\n        p: patch,\r\n        um: unmount,\r\n        m: move,\r\n        r: remove,\r\n        mt: mountComponent,\r\n        mc: mountChildren,\r\n        pc: patchChildren,\r\n        pbc: patchBlockChildren,\r\n        n: getNextHostNode,\r\n        o: options\r\n    };\r\n    let hydrate;\r\n    let hydrateNode;\r\n    if (createHydrationFns) {\r\n        [hydrate, hydrateNode] = createHydrationFns(internals);\r\n    }\r\n    return {\r\n        render,\r\n        hydrate,\r\n        createApp: createAppAPI(render, hydrate)\r\n    };\r\n}\r\nfunction invokeVNodeHook(hook, instance, vnode, prevVNode = null) {\r\n    callWithAsyncErrorHandling(hook, instance, 7 /* VNODE_HOOK */, [\r\n        vnode,\r\n        prevVNode\r\n    ]);\r\n}\r\n// https://en.wikipedia.org/wiki/Longest_increasing_subsequence\r\nfunction getSequence(arr) {\r\n    const p = arr.slice();\r\n    const result = [0];\r\n    let i, j, u, v, c;\r\n    const len = arr.length;\r\n    for (i = 0; i < len; i++) {\r\n        const arrI = arr[i];\r\n        if (arrI !== 0) {\r\n            j = result[result.length - 1];\r\n            if (arr[j] < arrI) {\r\n                p[i] = j;\r\n                result.push(i);\r\n                continue;\r\n            }\r\n            u = 0;\r\n            v = result.length - 1;\r\n            while (u < v) {\r\n                c = ((u + v) / 2) | 0;\r\n                if (arr[result[c]] < arrI) {\r\n                    u = c + 1;\r\n                }\r\n                else {\r\n                    v = c;\r\n                }\r\n            }\r\n            if (arrI < arr[result[u]]) {\r\n                if (u > 0) {\r\n                    p[i] = result[u - 1];\r\n                }\r\n                result[u] = i;\r\n            }\r\n        }\r\n    }\r\n    u = result.length;\r\n    v = result[u - 1];\r\n    while (u-- > 0) {\r\n        result[u] = v;\r\n        v = p[v];\r\n    }\r\n    return result;\r\n}\n\n// Simple effect.\r\nfunction watchEffect(effect, options) {\r\n    return doWatch(effect, null, options);\r\n}\r\n// initial value for watchers to trigger on undefined initial values\r\nconst INITIAL_WATCHER_VALUE = {};\r\n// implementation\r\nfunction watch(source, cb, options) {\r\n    if ((process.env.NODE_ENV !== 'production') && !isFunction(cb)) {\r\n        warn(`\\`watch(fn, options?)\\` signature has been moved to a separate API. ` +\r\n            `Use \\`watchEffect(fn, options?)\\` instead. \\`watch\\` now only ` +\r\n            `supports \\`watch(source, cb, options?) signature.`);\r\n    }\r\n    return doWatch(source, cb, options);\r\n}\r\nfunction doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) {\r\n    if ((process.env.NODE_ENV !== 'production') && !cb) {\r\n        if (immediate !== undefined) {\r\n            warn(`watch() \"immediate\" option is only respected when using the ` +\r\n                `watch(source, callback, options?) signature.`);\r\n        }\r\n        if (deep !== undefined) {\r\n            warn(`watch() \"deep\" option is only respected when using the ` +\r\n                `watch(source, callback, options?) signature.`);\r\n        }\r\n    }\r\n    const warnInvalidSource = (s) => {\r\n        warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +\r\n            `a reactive object, or an array of these types.`);\r\n    };\r\n    let getter;\r\n    if (isRef(source)) {\r\n        getter = () => source.value;\r\n    }\r\n    else if (isReactive(source)) {\r\n        getter = () => source;\r\n        deep = true;\r\n    }\r\n    else if (isArray(source)) {\r\n        getter = () => source.map(s => {\r\n            if (isRef(s)) {\r\n                return s.value;\r\n            }\r\n            else if (isReactive(s)) {\r\n                return traverse(s);\r\n            }\r\n            else if (isFunction(s)) {\r\n                return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);\r\n            }\r\n            else {\r\n                (process.env.NODE_ENV !== 'production') && warnInvalidSource(s);\r\n            }\r\n        });\r\n    }\r\n    else if (isFunction(source)) {\r\n        if (cb) {\r\n            // getter with cb\r\n            getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);\r\n        }\r\n        else {\r\n            // no cb -> simple effect\r\n            getter = () => {\r\n                if (instance && instance.isUnmounted) {\r\n                    return;\r\n                }\r\n                if (cleanup) {\r\n                    cleanup();\r\n                }\r\n                return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]);\r\n            };\r\n        }\r\n    }\r\n    else {\r\n        getter = NOOP;\r\n        (process.env.NODE_ENV !== 'production') && warnInvalidSource(source);\r\n    }\r\n    if (cb && deep) {\r\n        const baseGetter = getter;\r\n        getter = () => traverse(baseGetter());\r\n    }\r\n    let cleanup;\r\n    const onInvalidate = (fn) => {\r\n        cleanup = runner.options.onStop = () => {\r\n            callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);\r\n        };\r\n    };\r\n    let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;\r\n    const job = () => {\r\n        if (!runner.active) {\r\n            return;\r\n        }\r\n        if (cb) {\r\n            // watch(source, cb)\r\n            const newValue = runner();\r\n            if (deep || hasChanged(newValue, oldValue)) {\r\n                // cleanup before running cb again\r\n                if (cleanup) {\r\n                    cleanup();\r\n                }\r\n                callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [\r\n                    newValue,\r\n                    // pass undefined as the old value when it's changed for the first time\r\n                    oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,\r\n                    onInvalidate\r\n                ]);\r\n                oldValue = newValue;\r\n            }\r\n        }\r\n        else {\r\n            // watchEffect\r\n            runner();\r\n        }\r\n    };\r\n    let scheduler;\r\n    if (flush === 'sync') {\r\n        scheduler = job;\r\n    }\r\n    else if (flush === 'pre') {\r\n        // ensure it's queued before component updates (which have positive ids)\r\n        job.id = -1;\r\n        scheduler = () => {\r\n            if (!instance || instance.isMounted) {\r\n                queueJob(job);\r\n            }\r\n            else {\r\n                // with 'pre' option, the first call must happen before\r\n                // the component is mounted so it is called synchronously.\r\n                job();\r\n            }\r\n        };\r\n    }\r\n    else {\r\n        scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);\r\n    }\r\n    const runner = effect(getter, {\r\n        lazy: true,\r\n        onTrack,\r\n        onTrigger,\r\n        scheduler\r\n    });\r\n    recordInstanceBoundEffect(runner);\r\n    // initial run\r\n    if (cb) {\r\n        if (immediate) {\r\n            job();\r\n        }\r\n        else {\r\n            oldValue = runner();\r\n        }\r\n    }\r\n    else {\r\n        runner();\r\n    }\r\n    return () => {\r\n        stop(runner);\r\n        if (instance) {\r\n            remove(instance.effects, runner);\r\n        }\r\n    };\r\n}\r\n// this.$watch\r\nfunction instanceWatch(source, cb, options) {\r\n    const publicThis = this.proxy;\r\n    const getter = isString(source)\r\n        ? () => publicThis[source]\r\n        : source.bind(publicThis);\r\n    return doWatch(getter, cb.bind(publicThis), options, this);\r\n}\r\nfunction traverse(value, seen = new Set()) {\r\n    if (!isObject(value) || seen.has(value)) {\r\n        return value;\r\n    }\r\n    seen.add(value);\r\n    if (isArray(value)) {\r\n        for (let i = 0; i < value.length; i++) {\r\n            traverse(value[i], seen);\r\n        }\r\n    }\r\n    else if (value instanceof Map) {\r\n        value.forEach((v, key) => {\r\n            // to register mutation dep for existing keys\r\n            traverse(value.get(key), seen);\r\n        });\r\n    }\r\n    else if (value instanceof Set) {\r\n        value.forEach(v => {\r\n            traverse(v, seen);\r\n        });\r\n    }\r\n    else {\r\n        for (const key in value) {\r\n            traverse(value[key], seen);\r\n        }\r\n    }\r\n    return value;\r\n}\n\nfunction provide(key, value) {\r\n    if (!currentInstance) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            warn(`provide() can only be used inside setup().`);\r\n        }\r\n    }\r\n    else {\r\n        let provides = currentInstance.provides;\r\n        // by default an instance inherits its parent's provides object\r\n        // but when it needs to provide values of its own, it creates its\r\n        // own provides object using parent provides object as prototype.\r\n        // this way in `inject` we can simply look up injections from direct\r\n        // parent and let the prototype chain do the work.\r\n        const parentProvides = currentInstance.parent && currentInstance.parent.provides;\r\n        if (parentProvides === provides) {\r\n            provides = currentInstance.provides = Object.create(parentProvides);\r\n        }\r\n        // TS doesn't allow symbol as index type\r\n        provides[key] = value;\r\n    }\r\n}\r\nfunction inject(key, defaultValue) {\r\n    // fallback to `currentRenderingInstance` so that this can be called in\r\n    // a functional component\r\n    const instance = currentInstance || currentRenderingInstance;\r\n    if (instance) {\r\n        const provides = instance.provides;\r\n        if (key in provides) {\r\n            // TS doesn't allow symbol as index type\r\n            return provides[key];\r\n        }\r\n        else if (arguments.length > 1) {\r\n            return defaultValue;\r\n        }\r\n        else if ((process.env.NODE_ENV !== 'production')) {\r\n            warn(`injection \"${String(key)}\" not found.`);\r\n        }\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        warn(`inject() can only be used inside setup() or functional components.`);\r\n    }\r\n}\n\nfunction createDuplicateChecker() {\r\n    const cache = Object.create(null);\r\n    return (type, key) => {\r\n        if (cache[key]) {\r\n            warn(`${type} property \"${key}\" is already defined in ${cache[key]}.`);\r\n        }\r\n        else {\r\n            cache[key] = type;\r\n        }\r\n    };\r\n}\r\nfunction applyOptions(instance, options, deferredData = [], deferredWatch = [], asMixin = false) {\r\n    const { \r\n    // composition\r\n    mixins, extends: extendsOptions, \r\n    // state\r\n    data: dataOptions, computed: computedOptions, methods, watch: watchOptions, provide: provideOptions, inject: injectOptions, \r\n    // lifecycle\r\n    beforeMount, mounted, beforeUpdate, updated, activated, deactivated, beforeUnmount, unmounted, render, renderTracked, renderTriggered, errorCaptured } = options;\r\n    const publicThis = instance.proxy;\r\n    const ctx = instance.ctx;\r\n    const globalMixins = instance.appContext.mixins;\r\n    if (asMixin && render && instance.render === NOOP) {\r\n        instance.render = render;\r\n    }\r\n    // applyOptions is called non-as-mixin once per instance\r\n    if (!asMixin) {\r\n        callSyncHook('beforeCreate', options, publicThis, globalMixins);\r\n        // global mixins are applied first\r\n        applyMixins(instance, globalMixins, deferredData, deferredWatch);\r\n    }\r\n    // extending a base component...\r\n    if (extendsOptions) {\r\n        applyOptions(instance, extendsOptions, deferredData, deferredWatch, true);\r\n    }\r\n    // local mixins\r\n    if (mixins) {\r\n        applyMixins(instance, mixins, deferredData, deferredWatch);\r\n    }\r\n    const checkDuplicateProperties = (process.env.NODE_ENV !== 'production') ? createDuplicateChecker() : null;\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        const propsOptions = normalizePropsOptions(options)[0];\r\n        if (propsOptions) {\r\n            for (const key in propsOptions) {\r\n                checkDuplicateProperties(\"Props\" /* PROPS */, key);\r\n            }\r\n        }\r\n    }\r\n    // options initialization order (to be consistent with Vue 2):\r\n    // - props (already done outside of this function)\r\n    // - inject\r\n    // - methods\r\n    // - data (deferred since it relies on `this` access)\r\n    // - computed\r\n    // - watch (deferred since it relies on `this` access)\r\n    if (injectOptions) {\r\n        if (isArray(injectOptions)) {\r\n            for (let i = 0; i < injectOptions.length; i++) {\r\n                const key = injectOptions[i];\r\n                ctx[key] = inject(key);\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    checkDuplicateProperties(\"Inject\" /* INJECT */, key);\r\n                }\r\n            }\r\n        }\r\n        else {\r\n            for (const key in injectOptions) {\r\n                const opt = injectOptions[key];\r\n                if (isObject(opt)) {\r\n                    ctx[key] = inject(opt.from, opt.default);\r\n                }\r\n                else {\r\n                    ctx[key] = inject(opt);\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    checkDuplicateProperties(\"Inject\" /* INJECT */, key);\r\n                }\r\n            }\r\n        }\r\n    }\r\n    if (methods) {\r\n        for (const key in methods) {\r\n            const methodHandler = methods[key];\r\n            if (isFunction(methodHandler)) {\r\n                ctx[key] = methodHandler.bind(publicThis);\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    checkDuplicateProperties(\"Methods\" /* METHODS */, key);\r\n                }\r\n            }\r\n            else if ((process.env.NODE_ENV !== 'production')) {\r\n                warn(`Method \"${key}\" has type \"${typeof methodHandler}\" in the component definition. ` +\r\n                    `Did you reference the function correctly?`);\r\n            }\r\n        }\r\n    }\r\n    if (dataOptions) {\r\n        if ((process.env.NODE_ENV !== 'production') && !isFunction(dataOptions)) {\r\n            warn(`The data option must be a function. ` +\r\n                `Plain object usage is no longer supported.`);\r\n        }\r\n        if (asMixin) {\r\n            deferredData.push(dataOptions);\r\n        }\r\n        else {\r\n            resolveData(instance, dataOptions, publicThis);\r\n        }\r\n    }\r\n    if (!asMixin) {\r\n        if (deferredData.length) {\r\n            deferredData.forEach(dataFn => resolveData(instance, dataFn, publicThis));\r\n        }\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            const rawData = toRaw(instance.data);\r\n            for (const key in rawData) {\r\n                checkDuplicateProperties(\"Data\" /* DATA */, key);\r\n                // expose data on ctx during dev\r\n                if (key[0] !== '$' && key[0] !== '_') {\r\n                    Object.defineProperty(ctx, key, {\r\n                        configurable: true,\r\n                        enumerable: true,\r\n                        get: () => rawData[key],\r\n                        set: NOOP\r\n                    });\r\n                }\r\n            }\r\n        }\r\n    }\r\n    if (computedOptions) {\r\n        for (const key in computedOptions) {\r\n            const opt = computedOptions[key];\r\n            const get = isFunction(opt)\r\n                ? opt.bind(publicThis, publicThis)\r\n                : isFunction(opt.get)\r\n                    ? opt.get.bind(publicThis, publicThis)\r\n                    : NOOP;\r\n            if ((process.env.NODE_ENV !== 'production') && get === NOOP) {\r\n                warn(`Computed property \"${key}\" has no getter.`);\r\n            }\r\n            const set = !isFunction(opt) && isFunction(opt.set)\r\n                ? opt.set.bind(publicThis)\r\n                : (process.env.NODE_ENV !== 'production')\r\n                    ? () => {\r\n                        warn(`Write operation failed: computed property \"${key}\" is readonly.`);\r\n                    }\r\n                    : NOOP;\r\n            const c = computed({\r\n                get,\r\n                set\r\n            });\r\n            Object.defineProperty(ctx, key, {\r\n                enumerable: true,\r\n                configurable: true,\r\n                get: () => c.value,\r\n                set: v => (c.value = v)\r\n            });\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                checkDuplicateProperties(\"Computed\" /* COMPUTED */, key);\r\n            }\r\n        }\r\n    }\r\n    if (watchOptions) {\r\n        deferredWatch.push(watchOptions);\r\n    }\r\n    if (!asMixin && deferredWatch.length) {\r\n        deferredWatch.forEach(watchOptions => {\r\n            for (const key in watchOptions) {\r\n                createWatcher(watchOptions[key], ctx, publicThis, key);\r\n            }\r\n        });\r\n    }\r\n    if (provideOptions) {\r\n        const provides = isFunction(provideOptions)\r\n            ? provideOptions.call(publicThis)\r\n            : provideOptions;\r\n        for (const key in provides) {\r\n            provide(key, provides[key]);\r\n        }\r\n    }\r\n    // lifecycle options\r\n    if (!asMixin) {\r\n        callSyncHook('created', options, publicThis, globalMixins);\r\n    }\r\n    if (beforeMount) {\r\n        onBeforeMount(beforeMount.bind(publicThis));\r\n    }\r\n    if (mounted) {\r\n        onMounted(mounted.bind(publicThis));\r\n    }\r\n    if (beforeUpdate) {\r\n        onBeforeUpdate(beforeUpdate.bind(publicThis));\r\n    }\r\n    if (updated) {\r\n        onUpdated(updated.bind(publicThis));\r\n    }\r\n    if (activated) {\r\n        onActivated(activated.bind(publicThis));\r\n    }\r\n    if (deactivated) {\r\n        onDeactivated(deactivated.bind(publicThis));\r\n    }\r\n    if (errorCaptured) {\r\n        onErrorCaptured(errorCaptured.bind(publicThis));\r\n    }\r\n    if (renderTracked) {\r\n        onRenderTracked(renderTracked.bind(publicThis));\r\n    }\r\n    if (renderTriggered) {\r\n        onRenderTriggered(renderTriggered.bind(publicThis));\r\n    }\r\n    if (beforeUnmount) {\r\n        onBeforeUnmount(beforeUnmount.bind(publicThis));\r\n    }\r\n    if (unmounted) {\r\n        onUnmounted(unmounted.bind(publicThis));\r\n    }\r\n}\r\nfunction callSyncHook(name, options, ctx, globalMixins) {\r\n    callHookFromMixins(name, globalMixins, ctx);\r\n    const baseHook = options.extends && options.extends[name];\r\n    if (baseHook) {\r\n        baseHook.call(ctx);\r\n    }\r\n    const mixins = options.mixins;\r\n    if (mixins) {\r\n        callHookFromMixins(name, mixins, ctx);\r\n    }\r\n    const selfHook = options[name];\r\n    if (selfHook) {\r\n        selfHook.call(ctx);\r\n    }\r\n}\r\nfunction callHookFromMixins(name, mixins, ctx) {\r\n    for (let i = 0; i < mixins.length; i++) {\r\n        const fn = mixins[i][name];\r\n        if (fn) {\r\n            fn.call(ctx);\r\n        }\r\n    }\r\n}\r\nfunction applyMixins(instance, mixins, deferredData, deferredWatch) {\r\n    for (let i = 0; i < mixins.length; i++) {\r\n        applyOptions(instance, mixins[i], deferredData, deferredWatch, true);\r\n    }\r\n}\r\nfunction resolveData(instance, dataFn, publicThis) {\r\n    const data = dataFn.call(publicThis, publicThis);\r\n    if ((process.env.NODE_ENV !== 'production') && isPromise(data)) {\r\n        warn(`data() returned a Promise - note data() cannot be async; If you ` +\r\n            `intend to perform data fetching before component renders, use ` +\r\n            `async setup() + <Suspense>.`);\r\n    }\r\n    if (!isObject(data)) {\r\n        (process.env.NODE_ENV !== 'production') && warn(`data() should return an object.`);\r\n    }\r\n    else if (instance.data === EMPTY_OBJ) {\r\n        instance.data = reactive(data);\r\n    }\r\n    else {\r\n        // existing data: this is a mixin or extends.\r\n        extend(instance.data, data);\r\n    }\r\n}\r\nfunction createWatcher(raw, ctx, publicThis, key) {\r\n    const getter = () => publicThis[key];\r\n    if (isString(raw)) {\r\n        const handler = ctx[raw];\r\n        if (isFunction(handler)) {\r\n            watch(getter, handler);\r\n        }\r\n        else if ((process.env.NODE_ENV !== 'production')) {\r\n            warn(`Invalid watch handler specified by key \"${raw}\"`, handler);\r\n        }\r\n    }\r\n    else if (isFunction(raw)) {\r\n        watch(getter, raw.bind(publicThis));\r\n    }\r\n    else if (isObject(raw)) {\r\n        if (isArray(raw)) {\r\n            raw.forEach(r => createWatcher(r, ctx, publicThis, key));\r\n        }\r\n        else {\r\n            watch(getter, raw.handler.bind(publicThis), raw);\r\n        }\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        warn(`Invalid watch option: \"${key}\"`);\r\n    }\r\n}\r\nfunction resolveMergedOptions(instance) {\r\n    const raw = instance.type;\r\n    const { __merged, mixins, extends: extendsOptions } = raw;\r\n    if (__merged)\r\n        return __merged;\r\n    const globalMixins = instance.appContext.mixins;\r\n    if (!globalMixins.length && !mixins && !extendsOptions)\r\n        return raw;\r\n    const options = {};\r\n    globalMixins.forEach(m => mergeOptions(options, m, instance));\r\n    extendsOptions && mergeOptions(options, extendsOptions, instance);\r\n    mixins && mixins.forEach(m => mergeOptions(options, m, instance));\r\n    mergeOptions(options, raw, instance);\r\n    return (raw.__merged = options);\r\n}\r\nfunction mergeOptions(to, from, instance) {\r\n    const strats = instance.appContext.config.optionMergeStrategies;\r\n    for (const key in from) {\r\n        if (strats && hasOwn(strats, key)) {\r\n            to[key] = strats[key](to[key], from[key], instance.proxy, key);\r\n        }\r\n        else if (!hasOwn(to, key)) {\r\n            to[key] = from[key];\r\n        }\r\n    }\r\n}\n\nconst publicPropertiesMap = extend(Object.create(null), {\r\n    $: i => i,\r\n    $el: i => i.vnode.el,\r\n    $data: i => i.data,\r\n    $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props),\r\n    $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs),\r\n    $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots),\r\n    $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs),\r\n    $parent: i => i.parent && i.parent.proxy,\r\n    $root: i => i.root && i.root.proxy,\r\n    $emit: i => i.emit,\r\n    $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type),\r\n    $forceUpdate: i => () => queueJob(i.update),\r\n    $nextTick: () => nextTick,\r\n    $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP)\r\n});\r\nconst PublicInstanceProxyHandlers = {\r\n    get({ _: instance }, key) {\r\n        const { ctx, setupState, data, props, accessCache, type, appContext } = instance;\r\n        // let @vue/reactivity know it should never observe Vue public instances.\r\n        if (key === \"__v_skip\" /* SKIP */) {\r\n            return true;\r\n        }\r\n        // data / props / ctx\r\n        // This getter gets called for every property access on the render context\r\n        // during render and is a major hotspot. The most expensive part of this\r\n        // is the multiple hasOwn() calls. It's much faster to do a simple property\r\n        // access on a plain object, so we use an accessCache object (with null\r\n        // prototype) to memoize what access type a key corresponds to.\r\n        let normalizedProps;\r\n        if (key[0] !== '$') {\r\n            const n = accessCache[key];\r\n            if (n !== undefined) {\r\n                switch (n) {\r\n                    case 0 /* SETUP */:\r\n                        return setupState[key];\r\n                    case 1 /* DATA */:\r\n                        return data[key];\r\n                    case 3 /* CONTEXT */:\r\n                        return ctx[key];\r\n                    case 2 /* PROPS */:\r\n                        return props[key];\r\n                    // default: just fallthrough\r\n                }\r\n            }\r\n            else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n                accessCache[key] = 0 /* SETUP */;\r\n                return setupState[key];\r\n            }\r\n            else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n                accessCache[key] = 1 /* DATA */;\r\n                return data[key];\r\n            }\r\n            else if (\r\n            // only cache other properties when instance has declared (thus stable)\r\n            // props\r\n            (normalizedProps = normalizePropsOptions(type)[0]) &&\r\n                hasOwn(normalizedProps, key)) {\r\n                accessCache[key] = 2 /* PROPS */;\r\n                return props[key];\r\n            }\r\n            else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n                accessCache[key] = 3 /* CONTEXT */;\r\n                return ctx[key];\r\n            }\r\n            else {\r\n                accessCache[key] = 4 /* OTHER */;\r\n            }\r\n        }\r\n        const publicGetter = publicPropertiesMap[key];\r\n        let cssModule, globalProperties;\r\n        // public $xxx properties\r\n        if (publicGetter) {\r\n            if (key === '$attrs') {\r\n                track(instance, \"get\" /* GET */, key);\r\n                (process.env.NODE_ENV !== 'production') && markAttrsAccessed();\r\n            }\r\n            return publicGetter(instance);\r\n        }\r\n        else if (\r\n        // css module (injected by vue-loader)\r\n        (cssModule = type.__cssModules) &&\r\n            (cssModule = cssModule[key])) {\r\n            return cssModule;\r\n        }\r\n        else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n            // user may set custom properties to `this` that start with `$`\r\n            accessCache[key] = 3 /* CONTEXT */;\r\n            return ctx[key];\r\n        }\r\n        else if (\r\n        // global properties\r\n        ((globalProperties = appContext.config.globalProperties),\r\n            hasOwn(globalProperties, key))) {\r\n            return globalProperties[key];\r\n        }\r\n        else if ((process.env.NODE_ENV !== 'production') &&\r\n            currentRenderingInstance &&\r\n            // #1091 avoid internal isRef/isVNode checks on component instance leading\r\n            // to infinite warning loop\r\n            key.indexOf('__v') !== 0) {\r\n            if (data !== EMPTY_OBJ && key[0] === '$' && hasOwn(data, key)) {\r\n                warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +\r\n                    `character and is not proxied on the render context.`);\r\n            }\r\n            else {\r\n                warn(`Property ${JSON.stringify(key)} was accessed during render ` +\r\n                    `but is not defined on instance.`);\r\n            }\r\n        }\r\n    },\r\n    set({ _: instance }, key, value) {\r\n        const { data, setupState, ctx } = instance;\r\n        if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n            setupState[key] = value;\r\n        }\r\n        else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n            data[key] = value;\r\n        }\r\n        else if (key in instance.props) {\r\n            (process.env.NODE_ENV !== 'production') &&\r\n                warn(`Attempting to mutate prop \"${key}\". Props are readonly.`, instance);\r\n            return false;\r\n        }\r\n        if (key[0] === '$' && key.slice(1) in instance) {\r\n            (process.env.NODE_ENV !== 'production') &&\r\n                warn(`Attempting to mutate public property \"${key}\". ` +\r\n                    `Properties starting with $ are reserved and readonly.`, instance);\r\n            return false;\r\n        }\r\n        else {\r\n            if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) {\r\n                Object.defineProperty(ctx, key, {\r\n                    enumerable: true,\r\n                    configurable: true,\r\n                    value\r\n                });\r\n            }\r\n            else {\r\n                ctx[key] = value;\r\n            }\r\n        }\r\n        return true;\r\n    },\r\n    has({ _: { data, setupState, accessCache, ctx, type, appContext } }, key) {\r\n        let normalizedProps;\r\n        return (accessCache[key] !== undefined ||\r\n            (data !== EMPTY_OBJ && hasOwn(data, key)) ||\r\n            (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||\r\n            ((normalizedProps = normalizePropsOptions(type)[0]) &&\r\n                hasOwn(normalizedProps, key)) ||\r\n            hasOwn(ctx, key) ||\r\n            hasOwn(publicPropertiesMap, key) ||\r\n            hasOwn(appContext.config.globalProperties, key));\r\n    }\r\n};\r\nif ((process.env.NODE_ENV !== 'production') && !false) {\r\n    PublicInstanceProxyHandlers.ownKeys = (target) => {\r\n        warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +\r\n            `The keys will be empty in production mode to avoid performance overhead.`);\r\n        return Reflect.ownKeys(target);\r\n    };\r\n}\r\nconst RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {\r\n    get(target, key) {\r\n        // fast path for unscopables when using `with` block\r\n        if (key === Symbol.unscopables) {\r\n            return;\r\n        }\r\n        return PublicInstanceProxyHandlers.get(target, key, target);\r\n    },\r\n    has(_, key) {\r\n        const has = key[0] !== '_' && !isGloballyWhitelisted(key);\r\n        if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) {\r\n            warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);\r\n        }\r\n        return has;\r\n    }\r\n});\r\n// In dev mode, the proxy target exposes the same properties as seen on `this`\r\n// for easier console inspection. In prod mode it will be an empty object so\r\n// these properties definitions can be skipped.\r\nfunction createRenderContext(instance) {\r\n    const target = {};\r\n    // expose internal instance for proxy handlers\r\n    Object.defineProperty(target, `_`, {\r\n        configurable: true,\r\n        enumerable: false,\r\n        get: () => instance\r\n    });\r\n    // expose public properties\r\n    Object.keys(publicPropertiesMap).forEach(key => {\r\n        Object.defineProperty(target, key, {\r\n            configurable: true,\r\n            enumerable: false,\r\n            get: () => publicPropertiesMap[key](instance),\r\n            // intercepted by the proxy so no need for implementation,\r\n            // but needed to prevent set errors\r\n            set: NOOP\r\n        });\r\n    });\r\n    // expose global properties\r\n    const { globalProperties } = instance.appContext.config;\r\n    Object.keys(globalProperties).forEach(key => {\r\n        Object.defineProperty(target, key, {\r\n            configurable: true,\r\n            enumerable: false,\r\n            get: () => globalProperties[key],\r\n            set: NOOP\r\n        });\r\n    });\r\n    return target;\r\n}\r\n// dev only\r\nfunction exposePropsOnRenderContext(instance) {\r\n    const { ctx, type } = instance;\r\n    const propsOptions = normalizePropsOptions(type)[0];\r\n    if (propsOptions) {\r\n        Object.keys(propsOptions).forEach(key => {\r\n            Object.defineProperty(ctx, key, {\r\n                enumerable: true,\r\n                configurable: true,\r\n                get: () => instance.props[key],\r\n                set: NOOP\r\n            });\r\n        });\r\n    }\r\n}\r\n// dev only\r\nfunction exposeSetupStateOnRenderContext(instance) {\r\n    const { ctx, setupState } = instance;\r\n    Object.keys(toRaw(setupState)).forEach(key => {\r\n        Object.defineProperty(ctx, key, {\r\n            enumerable: true,\r\n            configurable: true,\r\n            get: () => setupState[key],\r\n            set: NOOP\r\n        });\r\n    });\r\n}\n\nconst emptyAppContext = createAppContext();\r\nlet uid = 0;\r\nfunction createComponentInstance(vnode, parent, suspense) {\r\n    const type = vnode.type;\r\n    // inherit parent app context - or - if root, adopt from root vnode\r\n    const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;\r\n    const instance = {\r\n        uid: uid++,\r\n        vnode,\r\n        type,\r\n        parent,\r\n        appContext,\r\n        root: null,\r\n        next: null,\r\n        subTree: null,\r\n        update: null,\r\n        render: null,\r\n        proxy: null,\r\n        withProxy: null,\r\n        effects: null,\r\n        provides: parent ? parent.provides : Object.create(appContext.provides),\r\n        accessCache: null,\r\n        renderCache: [],\r\n        // state\r\n        ctx: EMPTY_OBJ,\r\n        data: EMPTY_OBJ,\r\n        props: EMPTY_OBJ,\r\n        attrs: EMPTY_OBJ,\r\n        slots: EMPTY_OBJ,\r\n        refs: EMPTY_OBJ,\r\n        setupState: EMPTY_OBJ,\r\n        setupContext: null,\r\n        // suspense related\r\n        suspense,\r\n        asyncDep: null,\r\n        asyncResolved: false,\r\n        // lifecycle hooks\r\n        // not using enums here because it results in computed properties\r\n        isMounted: false,\r\n        isUnmounted: false,\r\n        isDeactivated: false,\r\n        bc: null,\r\n        c: null,\r\n        bm: null,\r\n        m: null,\r\n        bu: null,\r\n        u: null,\r\n        um: null,\r\n        bum: null,\r\n        da: null,\r\n        a: null,\r\n        rtg: null,\r\n        rtc: null,\r\n        ec: null,\r\n        emit: null,\r\n        emitted: null\r\n    };\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        instance.ctx = createRenderContext(instance);\r\n    }\r\n    else {\r\n        instance.ctx = { _: instance };\r\n    }\r\n    instance.root = parent ? parent.root : instance;\r\n    instance.emit = emit.bind(null, instance);\r\n    if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) {\r\n        devtoolsComponentAdded(instance);\r\n    }\r\n    return instance;\r\n}\r\nlet currentInstance = null;\r\nconst getCurrentInstance = () => currentInstance || currentRenderingInstance;\r\nconst setCurrentInstance = (instance) => {\r\n    currentInstance = instance;\r\n};\r\nconst isBuiltInTag = /*#__PURE__*/ makeMap('slot,component');\r\nfunction validateComponentName(name, config) {\r\n    const appIsNativeTag = config.isNativeTag || NO;\r\n    if (isBuiltInTag(name) || appIsNativeTag(name)) {\r\n        warn('Do not use built-in or reserved HTML elements as component id: ' + name);\r\n    }\r\n}\r\nlet isInSSRComponentSetup = false;\r\nfunction setupComponent(instance, isSSR = false) {\r\n    isInSSRComponentSetup = isSSR;\r\n    const { props, children, shapeFlag } = instance.vnode;\r\n    const isStateful = shapeFlag & 4 /* STATEFUL_COMPONENT */;\r\n    initProps(instance, props, isStateful, isSSR);\r\n    initSlots(instance, children);\r\n    const setupResult = isStateful\r\n        ? setupStatefulComponent(instance, isSSR)\r\n        : undefined;\r\n    isInSSRComponentSetup = false;\r\n    return setupResult;\r\n}\r\nfunction setupStatefulComponent(instance, isSSR) {\r\n    const Component = instance.type;\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        if (Component.name) {\r\n            validateComponentName(Component.name, instance.appContext.config);\r\n        }\r\n        if (Component.components) {\r\n            const names = Object.keys(Component.components);\r\n            for (let i = 0; i < names.length; i++) {\r\n                validateComponentName(names[i], instance.appContext.config);\r\n            }\r\n        }\r\n        if (Component.directives) {\r\n            const names = Object.keys(Component.directives);\r\n            for (let i = 0; i < names.length; i++) {\r\n                validateDirectiveName(names[i]);\r\n            }\r\n        }\r\n    }\r\n    // 0. create render proxy property access cache\r\n    instance.accessCache = {};\r\n    // 1. create public instance / render proxy\r\n    // also mark it raw so it's never observed\r\n    instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers);\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        exposePropsOnRenderContext(instance);\r\n    }\r\n    // 2. call setup()\r\n    const { setup } = Component;\r\n    if (setup) {\r\n        const setupContext = (instance.setupContext =\r\n            setup.length > 1 ? createSetupContext(instance) : null);\r\n        currentInstance = instance;\r\n        pauseTracking();\r\n        const setupResult = callWithErrorHandling(setup, instance, 0 /* SETUP_FUNCTION */, [(process.env.NODE_ENV !== 'production') ? shallowReadonly(instance.props) : instance.props, setupContext]);\r\n        resetTracking();\r\n        currentInstance = null;\r\n        if (isPromise(setupResult)) {\r\n            if (isSSR) {\r\n                // return the promise so server-renderer can wait on it\r\n                return setupResult.then((resolvedResult) => {\r\n                    handleSetupResult(instance, resolvedResult);\r\n                });\r\n            }\r\n            else {\r\n                // async setup returned Promise.\r\n                // bail here and wait for re-entry.\r\n                instance.asyncDep = setupResult;\r\n            }\r\n        }\r\n        else {\r\n            handleSetupResult(instance, setupResult);\r\n        }\r\n    }\r\n    else {\r\n        finishComponentSetup(instance);\r\n    }\r\n}\r\nfunction handleSetupResult(instance, setupResult, isSSR) {\r\n    if (isFunction(setupResult)) {\r\n        // setup returned an inline render function\r\n        instance.render = setupResult;\r\n    }\r\n    else if (isObject(setupResult)) {\r\n        if ((process.env.NODE_ENV !== 'production') && isVNode(setupResult)) {\r\n            warn(`setup() should not return VNodes directly - ` +\r\n                `return a render function instead.`);\r\n        }\r\n        // setup returned bindings.\r\n        // assuming a render function compiled from template is present.\r\n        instance.setupState = proxyRefs(setupResult);\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            exposeSetupStateOnRenderContext(instance);\r\n        }\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production') && setupResult !== undefined) {\r\n        warn(`setup() should return an object. Received: ${setupResult === null ? 'null' : typeof setupResult}`);\r\n    }\r\n    finishComponentSetup(instance);\r\n}\r\nlet compile;\r\n/**\r\n * For runtime-dom to register the compiler.\r\n * Note the exported method uses any to avoid d.ts relying on the compiler types.\r\n */\r\nfunction registerRuntimeCompiler(_compile) {\r\n    compile = _compile;\r\n}\r\nfunction finishComponentSetup(instance, isSSR) {\r\n    const Component = instance.type;\r\n    // template / render function normalization\r\n    if (!instance.render) {\r\n        // could be set from setup()\r\n        if (compile && Component.template && !Component.render) {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                startMeasure(instance, `compile`);\r\n            }\r\n            Component.render = compile(Component.template, {\r\n                isCustomElement: instance.appContext.config.isCustomElement,\r\n                delimiters: Component.delimiters\r\n            });\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                endMeasure(instance, `compile`);\r\n            }\r\n        }\r\n        instance.render = (Component.render || NOOP);\r\n        // for runtime-compiled render functions using `with` blocks, the render\r\n        // proxy used needs a different `has` handler which is more performant and\r\n        // also only allows a whitelist of globals to fallthrough.\r\n        if (instance.render._rc) {\r\n            instance.withProxy = new Proxy(instance.ctx, RuntimeCompiledPublicInstanceProxyHandlers);\r\n        }\r\n    }\r\n    // support for 2.x options\r\n    if (__VUE_OPTIONS_API__) {\r\n        currentInstance = instance;\r\n        applyOptions(instance, Component);\r\n        currentInstance = null;\r\n    }\r\n    // warn missing template/render\r\n    if ((process.env.NODE_ENV !== 'production') && !Component.render && instance.render === NOOP) {\r\n        /* istanbul ignore if */\r\n        if (!compile && Component.template) {\r\n            warn(`Component provided template option but ` +\r\n                `runtime compilation is not supported in this build of Vue.` +\r\n                ( ` Configure your bundler to alias \"vue\" to \"vue/dist/vue.esm-bundler.js\".`\r\n                    ) /* should not happen */);\r\n        }\r\n        else {\r\n            warn(`Component is missing template or render function.`);\r\n        }\r\n    }\r\n}\r\nconst attrHandlers = {\r\n    get: (target, key) => {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            markAttrsAccessed();\r\n        }\r\n        return target[key];\r\n    },\r\n    set: () => {\r\n        warn(`setupContext.attrs is readonly.`);\r\n        return false;\r\n    },\r\n    deleteProperty: () => {\r\n        warn(`setupContext.attrs is readonly.`);\r\n        return false;\r\n    }\r\n};\r\nfunction createSetupContext(instance) {\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        // We use getters in dev in case libs like test-utils overwrite instance\r\n        // properties (overwrites should not be done in prod)\r\n        return Object.freeze({\r\n            get attrs() {\r\n                return new Proxy(instance.attrs, attrHandlers);\r\n            },\r\n            get slots() {\r\n                return shallowReadonly(instance.slots);\r\n            },\r\n            get emit() {\r\n                return (event, ...args) => instance.emit(event, ...args);\r\n            }\r\n        });\r\n    }\r\n    else {\r\n        return {\r\n            attrs: instance.attrs,\r\n            slots: instance.slots,\r\n            emit: instance.emit\r\n        };\r\n    }\r\n}\r\n// record effects created during a component's setup() so that they can be\r\n// stopped when the component unmounts\r\nfunction recordInstanceBoundEffect(effect) {\r\n    if (currentInstance) {\r\n        (currentInstance.effects || (currentInstance.effects = [])).push(effect);\r\n    }\r\n}\r\nconst classifyRE = /(?:^|[-_])(\\w)/g;\r\nconst classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');\r\n/* istanbul ignore next */\r\nfunction formatComponentName(instance, Component, isRoot = false) {\r\n    let name = isFunction(Component)\r\n        ? Component.displayName || Component.name\r\n        : Component.name;\r\n    if (!name && Component.__file) {\r\n        const match = Component.__file.match(/([^/\\\\]+)\\.vue$/);\r\n        if (match) {\r\n            name = match[1];\r\n        }\r\n    }\r\n    if (!name && instance && instance.parent) {\r\n        // try to infer the name based on reverse resolution\r\n        const inferFromRegistry = (registry) => {\r\n            for (const key in registry) {\r\n                if (registry[key] === Component) {\r\n                    return key;\r\n                }\r\n            }\r\n        };\r\n        name =\r\n            inferFromRegistry(instance.parent.type.components) || inferFromRegistry(instance.appContext.components);\r\n    }\r\n    return name ? classify(name) : isRoot ? `App` : `Anonymous`;\r\n}\n\nfunction computed(getterOrOptions) {\r\n    const c = computed$1(getterOrOptions);\r\n    recordInstanceBoundEffect(c.effect);\r\n    return c;\r\n}\n\n// implementation, close to no-op\r\nfunction defineComponent(options) {\r\n    return isFunction(options)\r\n        ? { setup: options, name: options.name }\r\n        : options;\r\n}\n\nfunction defineAsyncComponent(source) {\r\n    if (isFunction(source)) {\r\n        source = { loader: source };\r\n    }\r\n    const { loader, loadingComponent: loadingComponent, errorComponent: errorComponent, delay = 200, timeout, // undefined = never times out\r\n    suspensible = true, onError: userOnError } = source;\r\n    let pendingRequest = null;\r\n    let resolvedComp;\r\n    let retries = 0;\r\n    const retry = () => {\r\n        retries++;\r\n        pendingRequest = null;\r\n        return load();\r\n    };\r\n    const load = () => {\r\n        let thisRequest;\r\n        return (pendingRequest ||\r\n            (thisRequest = pendingRequest = loader()\r\n                .catch(err => {\r\n                err = err instanceof Error ? err : new Error(String(err));\r\n                if (userOnError) {\r\n                    return new Promise((resolve, reject) => {\r\n                        const userRetry = () => resolve(retry());\r\n                        const userFail = () => reject(err);\r\n                        userOnError(err, userRetry, userFail, retries + 1);\r\n                    });\r\n                }\r\n                else {\r\n                    throw err;\r\n                }\r\n            })\r\n                .then((comp) => {\r\n                if (thisRequest !== pendingRequest && pendingRequest) {\r\n                    return pendingRequest;\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production') && !comp) {\r\n                    warn(`Async component loader resolved to undefined. ` +\r\n                        `If you are using retry(), make sure to return its return value.`);\r\n                }\r\n                // interop module default\r\n                if (comp &&\r\n                    (comp.__esModule || comp[Symbol.toStringTag] === 'Module')) {\r\n                    comp = comp.default;\r\n                }\r\n                if ((process.env.NODE_ENV !== 'production') && comp && !isObject(comp) && !isFunction(comp)) {\r\n                    throw new Error(`Invalid async component load result: ${comp}`);\r\n                }\r\n                resolvedComp = comp;\r\n                return comp;\r\n            })));\r\n    };\r\n    return defineComponent({\r\n        __asyncLoader: load,\r\n        name: 'AsyncComponentWrapper',\r\n        setup() {\r\n            const instance = currentInstance;\r\n            // already resolved\r\n            if (resolvedComp) {\r\n                return () => createInnerComp(resolvedComp, instance);\r\n            }\r\n            const onError = (err) => {\r\n                pendingRequest = null;\r\n                handleError(err, instance, 13 /* ASYNC_COMPONENT_LOADER */);\r\n            };\r\n            // suspense-controlled or SSR.\r\n            if (( suspensible && instance.suspense) ||\r\n                (false )) {\r\n                return load()\r\n                    .then(comp => {\r\n                    return () => createInnerComp(comp, instance);\r\n                })\r\n                    .catch(err => {\r\n                    onError(err);\r\n                    return () => errorComponent\r\n                        ? createVNode(errorComponent, { error: err })\r\n                        : null;\r\n                });\r\n            }\r\n            const loaded = ref(false);\r\n            const error = ref();\r\n            const delayed = ref(!!delay);\r\n            if (delay) {\r\n                setTimeout(() => {\r\n                    delayed.value = false;\r\n                }, delay);\r\n            }\r\n            if (timeout != null) {\r\n                setTimeout(() => {\r\n                    if (!loaded.value) {\r\n                        const err = new Error(`Async component timed out after ${timeout}ms.`);\r\n                        onError(err);\r\n                        error.value = err;\r\n                    }\r\n                }, timeout);\r\n            }\r\n            load()\r\n                .then(() => {\r\n                loaded.value = true;\r\n            })\r\n                .catch(err => {\r\n                onError(err);\r\n                error.value = err;\r\n            });\r\n            return () => {\r\n                if (loaded.value && resolvedComp) {\r\n                    return createInnerComp(resolvedComp, instance);\r\n                }\r\n                else if (error.value && errorComponent) {\r\n                    return createVNode(errorComponent, {\r\n                        error: error.value\r\n                    });\r\n                }\r\n                else if (loadingComponent && !delayed.value) {\r\n                    return createVNode(loadingComponent);\r\n                }\r\n            };\r\n        }\r\n    });\r\n}\r\nfunction createInnerComp(comp, { vnode: { props, children } }) {\r\n    return createVNode(comp, props, children);\r\n}\n\n// Actual implementation\r\nfunction h(type, propsOrChildren, children) {\r\n    if (arguments.length === 2) {\r\n        if (isObject(propsOrChildren) && !isArray(propsOrChildren)) {\r\n            // single vnode without props\r\n            if (isVNode(propsOrChildren)) {\r\n                return createVNode(type, null, [propsOrChildren]);\r\n            }\r\n            // props without children\r\n            return createVNode(type, propsOrChildren);\r\n        }\r\n        else {\r\n            // omit props\r\n            return createVNode(type, null, propsOrChildren);\r\n        }\r\n    }\r\n    else {\r\n        if (isVNode(children)) {\r\n            children = [children];\r\n        }\r\n        return createVNode(type, propsOrChildren, children);\r\n    }\r\n}\n\nconst ssrContextKey = Symbol((process.env.NODE_ENV !== 'production') ? `ssrContext` : ``);\r\nconst useSSRContext = () => {\r\n    {\r\n        const ctx = inject(ssrContextKey);\r\n        if (!ctx) {\r\n            warn(`Server rendering context not provided. Make sure to only call ` +\r\n                `useSsrContext() conditionally in the server build.`);\r\n        }\r\n        return ctx;\r\n    }\r\n};\n\n/**\r\n * Actual implementation\r\n */\r\nfunction renderList(source, renderItem) {\r\n    let ret;\r\n    if (isArray(source) || isString(source)) {\r\n        ret = new Array(source.length);\r\n        for (let i = 0, l = source.length; i < l; i++) {\r\n            ret[i] = renderItem(source[i], i);\r\n        }\r\n    }\r\n    else if (typeof source === 'number') {\r\n        ret = new Array(source);\r\n        for (let i = 0; i < source; i++) {\r\n            ret[i] = renderItem(i + 1, i);\r\n        }\r\n    }\r\n    else if (isObject(source)) {\r\n        if (source[Symbol.iterator]) {\r\n            ret = Array.from(source, renderItem);\r\n        }\r\n        else {\r\n            const keys = Object.keys(source);\r\n            ret = new Array(keys.length);\r\n            for (let i = 0, l = keys.length; i < l; i++) {\r\n                const key = keys[i];\r\n                ret[i] = renderItem(source[key], key, i);\r\n            }\r\n        }\r\n    }\r\n    else {\r\n        ret = [];\r\n    }\r\n    return ret;\r\n}\n\n/**\r\n * For prefixing keys in v-on=\"obj\" with \"on\"\r\n * @private\r\n */\r\nfunction toHandlers(obj) {\r\n    const ret = {};\r\n    if ((process.env.NODE_ENV !== 'production') && !isObject(obj)) {\r\n        warn(`v-on with no argument expects an object value.`);\r\n        return ret;\r\n    }\r\n    for (const key in obj) {\r\n        ret[`on${capitalize(key)}`] = obj[key];\r\n    }\r\n    return ret;\r\n}\n\n/**\r\n * Compiler runtime helper for rendering `<slot/>`\r\n * @private\r\n */\r\nfunction renderSlot(slots, name, props = {}, \r\n// this is not a user-facing function, so the fallback is always generated by\r\n// the compiler and guaranteed to be a function returning an array\r\nfallback) {\r\n    let slot = slots[name];\r\n    if ((process.env.NODE_ENV !== 'production') && slot && slot.length > 1) {\r\n        warn(`SSR-optimized slot function detected in a non-SSR-optimized render ` +\r\n            `function. You need to mark this component with $dynamic-slots in the ` +\r\n            `parent template.`);\r\n        slot = () => [];\r\n    }\r\n    return (openBlock(),\r\n        createBlock(Fragment, { key: props.key }, slot ? slot(props) : fallback ? fallback() : [], slots._ === 1 /* STABLE */\r\n            ? 64 /* STABLE_FRAGMENT */\r\n            : -2 /* BAIL */));\r\n}\n\n/**\r\n * Compiler runtime helper for creating dynamic slots object\r\n * @private\r\n */\r\nfunction createSlots(slots, dynamicSlots) {\r\n    for (let i = 0; i < dynamicSlots.length; i++) {\r\n        const slot = dynamicSlots[i];\r\n        // array of dynamic slot generated by <template v-for=\"...\" #[...]>\r\n        if (isArray(slot)) {\r\n            for (let j = 0; j < slot.length; j++) {\r\n                slots[slot[j].name] = slot[j].fn;\r\n            }\r\n        }\r\n        else if (slot) {\r\n            // conditional single slot generated by <template v-if=\"...\" #foo>\r\n            slots[slot.name] = slot.fn;\r\n        }\r\n    }\r\n    return slots;\r\n}\n\n// Core API ------------------------------------------------------------------\r\nconst version = \"3.0.0-rc.5\";\r\n/**\r\n * SSR utils for \\@vue/server-renderer. Only exposed in cjs builds.\r\n * @internal\r\n */\r\nconst ssrUtils = ( null);\n\nexport { BaseTransition, Comment, Fragment, KeepAlive, Static, Suspense, Teleport, Text, callWithAsyncErrorHandling, callWithErrorHandling, cloneVNode, computed, createBlock, createCommentVNode, createHydrationRenderer, createRenderer, createSlots, createStaticVNode, createTextVNode, createVNode, defineAsyncComponent, defineComponent, devtools, getCurrentInstance, getTransitionRawChildren, h, handleError, inject, isVNode, mergeProps, nextTick, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onUnmounted, onUpdated, openBlock, popScopeId, provide, pushScopeId, queuePostFlushCb, registerRuntimeCompiler, renderList, renderSlot, resolveComponent, resolveDirective, resolveDynamicComponent, resolveTransitionHooks, setBlockTracking, setDevtoolsHook, setTransitionHooks, ssrContextKey, ssrUtils, toHandlers, transformVNodeArgs, useSSRContext, useTransitionState, version, warn, watch, watchEffect, withCtx, withDirectives, withScopeId };\n","module.exports = function (bitmap, value) {\n  return {\n    enumerable: !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable: !(bitmap & 4),\n    value: value\n  };\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\n\nvar nativeAssign = Object.assign;\nvar defineProperty = Object.defineProperty;\n\n// `Object.assign` method\n// https://tc39.github.io/ecma262/#sec-object.assign\nmodule.exports = !nativeAssign || fails(function () {\n  // should have correct order of operations (Edge bug)\n  if (DESCRIPTORS && nativeAssign({ b: 1 }, nativeAssign(defineProperty({}, 'a', {\n    enumerable: true,\n    get: function () {\n      defineProperty(this, 'b', {\n        value: 3,\n        enumerable: false\n      });\n    }\n  }), { b: 2 })).b !== 1) return true;\n  // should work with symbols and should have deterministic property order (V8 bug)\n  var A = {};\n  var B = {};\n  // eslint-disable-next-line no-undef\n  var symbol = Symbol();\n  var alphabet = 'abcdefghijklmnopqrst';\n  A[symbol] = 7;\n  alphabet.split('').forEach(function (chr) { B[chr] = chr; });\n  return nativeAssign({}, A)[symbol] != 7 || objectKeys(nativeAssign({}, B)).join('') != alphabet;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars\n  var T = toObject(target);\n  var argumentsLength = arguments.length;\n  var index = 1;\n  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n  var propertyIsEnumerable = propertyIsEnumerableModule.f;\n  while (argumentsLength > index) {\n    var S = IndexedObject(arguments[index++]);\n    var keys = getOwnPropertySymbols ? objectKeys(S).concat(getOwnPropertySymbols(S)) : objectKeys(S);\n    var length = keys.length;\n    var j = 0;\n    var key;\n    while (length > j) {\n      key = keys[j++];\n      if (!DESCRIPTORS || propertyIsEnumerable.call(S, key)) T[key] = S[key];\n    }\n  } return T;\n} : nativeAssign;\n","var isObject = require('../internals/is-object');\nvar isArray = require('../internals/is-array');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `ArraySpeciesCreate` abstract operation\n// https://tc39.github.io/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray, length) {\n  var C;\n  if (isArray(originalArray)) {\n    C = originalArray.constructor;\n    // cross-realm fallback\n    if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;\n    else if (isObject(C)) {\n      C = C[SPECIES];\n      if (C === null) C = undefined;\n    }\n  } return new (C === undefined ? Array : C)(length === 0 ? 0 : length);\n};\n","var NATIVE_WEAK_MAP = require('../internals/native-weak-map');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar objectHas = require('../internals/has');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n  return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n  return function (it) {\n    var state;\n    if (!isObject(it) || (state = get(it)).type !== TYPE) {\n      throw TypeError('Incompatible receiver, ' + TYPE + ' required');\n    } return state;\n  };\n};\n\nif (NATIVE_WEAK_MAP) {\n  var store = new WeakMap();\n  var wmget = store.get;\n  var wmhas = store.has;\n  var wmset = store.set;\n  set = function (it, metadata) {\n    wmset.call(store, it, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return wmget.call(store, it) || {};\n  };\n  has = function (it) {\n    return wmhas.call(store, it);\n  };\n} else {\n  var STATE = sharedKey('state');\n  hiddenKeys[STATE] = true;\n  set = function (it, metadata) {\n    createNonEnumerableProperty(it, STATE, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return objectHas(it, STATE) ? it[STATE] : {};\n  };\n  has = function (it) {\n    return objectHas(it, STATE);\n  };\n}\n\nmodule.exports = {\n  set: set,\n  get: get,\n  has: has,\n  enforce: enforce,\n  getterFor: getterFor\n};\n","var global = require('../internals/global');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar has = require('../internals/has');\nvar setGlobal = require('../internals/set-global');\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar getInternalState = InternalStateModule.get;\nvar enforceInternalState = InternalStateModule.enforce;\nvar TEMPLATE = String(String).split('String');\n\n(module.exports = function (O, key, value, options) {\n  var unsafe = options ? !!options.unsafe : false;\n  var simple = options ? !!options.enumerable : false;\n  var noTargetGet = options ? !!options.noTargetGet : false;\n  if (typeof value == 'function') {\n    if (typeof key == 'string' && !has(value, 'name')) createNonEnumerableProperty(value, 'name', key);\n    enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : '');\n  }\n  if (O === global) {\n    if (simple) O[key] = value;\n    else setGlobal(key, value);\n    return;\n  } else if (!unsafe) {\n    delete O[key];\n  } else if (!noTargetGet && O[key]) {\n    simple = true;\n  }\n  if (simple) O[key] = value;\n  else createNonEnumerableProperty(O, key, value);\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n})(Function.prototype, 'toString', function toString() {\n  return typeof this == 'function' && getInternalState(this).source || inspectSource(this);\n});\n","exports.f = Object.getOwnPropertySymbols;\n","// IE8- don't enum bug keys\nmodule.exports = [\n  'constructor',\n  'hasOwnProperty',\n  'isPrototypeOf',\n  'propertyIsEnumerable',\n  'toLocaleString',\n  'toString',\n  'valueOf'\n];\n","var requireObjectCoercible = require('../internals/require-object-coercible');\n\n// `ToObject` abstract operation\n// https://tc39.github.io/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n  return Object(requireObjectCoercible(argument));\n};\n","var anObject = require('../internals/an-object');\nvar defineProperties = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n  activeXDocument.write(scriptTag(''));\n  activeXDocument.close();\n  var temp = activeXDocument.parentWindow.Object;\n  activeXDocument = null; // avoid memory leak\n  return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = documentCreateElement('iframe');\n  var JS = 'java' + SCRIPT + ':';\n  var iframeDocument;\n  iframe.style.display = 'none';\n  html.appendChild(iframe);\n  // https://github.com/zloirock/core-js/issues/475\n  iframe.src = String(JS);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(scriptTag('document.F=Object'));\n  iframeDocument.close();\n  return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n  try {\n    /* global ActiveXObject */\n    activeXDocument = document.domain && new ActiveXObject('htmlfile');\n  } catch (error) { /* ignore */ }\n  NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame();\n  var length = enumBugKeys.length;\n  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n  return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.github.io/ecma262/#sec-object.create\nmodule.exports = Object.create || function create(O, Properties) {\n  var result;\n  if (O !== null) {\n    EmptyConstructor[PROTOTYPE] = anObject(O);\n    result = new EmptyConstructor();\n    EmptyConstructor[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = NullProtoObject();\n  return Properties === undefined ? result : defineProperties(result, Properties);\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar createIteratorConstructor = require('../internals/create-iterator-constructor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\nvar Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar IteratorPrototype = IteratorsCore.IteratorPrototype;\nvar BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;\nvar ITERATOR = wellKnownSymbol('iterator');\nvar KEYS = 'keys';\nvar VALUES = 'values';\nvar ENTRIES = 'entries';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {\n  createIteratorConstructor(IteratorConstructor, NAME, next);\n\n  var getIterationMethod = function (KIND) {\n    if (KIND === DEFAULT && defaultIterator) return defaultIterator;\n    if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];\n    switch (KIND) {\n      case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };\n      case VALUES: return function values() { return new IteratorConstructor(this, KIND); };\n      case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };\n    } return function () { return new IteratorConstructor(this); };\n  };\n\n  var TO_STRING_TAG = NAME + ' Iterator';\n  var INCORRECT_VALUES_NAME = false;\n  var IterablePrototype = Iterable.prototype;\n  var nativeIterator = IterablePrototype[ITERATOR]\n    || IterablePrototype['@@iterator']\n    || DEFAULT && IterablePrototype[DEFAULT];\n  var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);\n  var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;\n  var CurrentIteratorPrototype, methods, KEY;\n\n  // fix native\n  if (anyNativeIterator) {\n    CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));\n    if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n      if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n        if (setPrototypeOf) {\n          setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n        } else if (typeof CurrentIteratorPrototype[ITERATOR] != 'function') {\n          createNonEnumerableProperty(CurrentIteratorPrototype, ITERATOR, returnThis);\n        }\n      }\n      // Set @@toStringTag to native iterators\n      setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);\n      if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;\n    }\n  }\n\n  // fix Array#{values, @@iterator}.name in V8 / FF\n  if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n    INCORRECT_VALUES_NAME = true;\n    defaultIterator = function values() { return nativeIterator.call(this); };\n  }\n\n  // define iterator\n  if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n    createNonEnumerableProperty(IterablePrototype, ITERATOR, defaultIterator);\n  }\n  Iterators[NAME] = defaultIterator;\n\n  // export additional methods\n  if (DEFAULT) {\n    methods = {\n      values: getIterationMethod(VALUES),\n      keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),\n      entries: getIterationMethod(ENTRIES)\n    };\n    if (FORCED) for (KEY in methods) {\n      if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {\n        redefine(IterablePrototype, KEY, methods[KEY]);\n      }\n    } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);\n  }\n\n  return methods;\n};\n","var global = require('../internals/global');\nvar inspectSource = require('../internals/inspect-source');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap));\n","var isObject = require('../internals/is-object');\n\nmodule.exports = function (it) {\n  if (!isObject(it)) {\n    throw TypeError(String(it) + ' is not an object');\n  } return it;\n};\n","import { camelize, warn, callWithAsyncErrorHandling, getCurrentInstance, onMounted, watchEffect, unref, Fragment, h, BaseTransition, useTransitionState, onUpdated, getTransitionRawChildren, setTransitionHooks, resolveTransitionHooks, createVNode, createRenderer, createHydrationRenderer } from '@vue/runtime-core';\nexport * from '@vue/runtime-core';\nimport { isString, hyphenate, capitalize, isSpecialBooleanAttr, isArray, isOn, isModelListener, isFunction, EMPTY_OBJ, extend, isObject, toNumber, invokeArrayFns, looseIndexOf, looseEqual, isHTMLTag, isSVGTag } from '@vue/shared';\n\nconst svgNS = 'http://www.w3.org/2000/svg';\r\nconst doc = (typeof document !== 'undefined' ? document : null);\r\nlet tempContainer;\r\nlet tempSVGContainer;\r\nconst nodeOps = {\r\n    insert: (child, parent, anchor) => {\r\n        parent.insertBefore(child, anchor || null);\r\n    },\r\n    remove: child => {\r\n        const parent = child.parentNode;\r\n        if (parent) {\r\n            parent.removeChild(child);\r\n        }\r\n    },\r\n    createElement: (tag, isSVG, is) => isSVG\r\n        ? doc.createElementNS(svgNS, tag)\r\n        : doc.createElement(tag, is ? { is } : undefined),\r\n    createText: text => doc.createTextNode(text),\r\n    createComment: text => doc.createComment(text),\r\n    setText: (node, text) => {\r\n        node.nodeValue = text;\r\n    },\r\n    setElementText: (el, text) => {\r\n        el.textContent = text;\r\n    },\r\n    parentNode: node => node.parentNode,\r\n    nextSibling: node => node.nextSibling,\r\n    querySelector: selector => doc.querySelector(selector),\r\n    setScopeId(el, id) {\r\n        el.setAttribute(id, '');\r\n    },\r\n    cloneNode(el) {\r\n        return el.cloneNode(true);\r\n    },\r\n    // __UNSAFE__\r\n    // Reason: innerHTML.\r\n    // Static content here can only come from compiled templates.\r\n    // As long as the user only uses trusted templates, this is safe.\r\n    insertStaticContent(content, parent, anchor, isSVG) {\r\n        const temp = isSVG\r\n            ? tempSVGContainer ||\r\n                (tempSVGContainer = doc.createElementNS(svgNS, 'svg'))\r\n            : tempContainer || (tempContainer = doc.createElement('div'));\r\n        temp.innerHTML = content;\r\n        const first = temp.firstChild;\r\n        let node = first;\r\n        let last = node;\r\n        while (node) {\r\n            last = node;\r\n            nodeOps.insert(node, parent, anchor);\r\n            node = temp.firstChild;\r\n        }\r\n        return [first, last];\r\n    }\r\n};\n\n// compiler should normalize class + :class bindings on the same element\r\n// into a single binding ['staticClass', dynamic]\r\nfunction patchClass(el, value, isSVG) {\r\n    if (value == null) {\r\n        value = '';\r\n    }\r\n    if (isSVG) {\r\n        el.setAttribute('class', value);\r\n    }\r\n    else {\r\n        // directly setting className should be faster than setAttribute in theory\r\n        // if this is an element during a transition, take the temporary transition\r\n        // classes into account.\r\n        const transitionClasses = el._vtc;\r\n        if (transitionClasses) {\r\n            value = (value\r\n                ? [value, ...transitionClasses]\r\n                : [...transitionClasses]).join(' ');\r\n        }\r\n        el.className = value;\r\n    }\r\n}\n\nfunction patchStyle(el, prev, next) {\r\n    const style = el.style;\r\n    if (!next) {\r\n        el.removeAttribute('style');\r\n    }\r\n    else if (isString(next)) {\r\n        if (prev !== next) {\r\n            style.cssText = next;\r\n        }\r\n    }\r\n    else {\r\n        for (const key in next) {\r\n            setStyle(style, key, next[key]);\r\n        }\r\n        if (prev && !isString(prev)) {\r\n            for (const key in prev) {\r\n                if (next[key] == null) {\r\n                    setStyle(style, key, '');\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\nconst importantRE = /\\s*!important$/;\r\nfunction setStyle(style, name, val) {\r\n    if (name.startsWith('--')) {\r\n        // custom property definition\r\n        style.setProperty(name, val);\r\n    }\r\n    else {\r\n        const prefixed = autoPrefix(style, name);\r\n        if (importantRE.test(val)) {\r\n            // !important\r\n            style.setProperty(hyphenate(prefixed), val.replace(importantRE, ''), 'important');\r\n        }\r\n        else {\r\n            style[prefixed] = val;\r\n        }\r\n    }\r\n}\r\nconst prefixes = ['Webkit', 'Moz', 'ms'];\r\nconst prefixCache = {};\r\nfunction autoPrefix(style, rawName) {\r\n    const cached = prefixCache[rawName];\r\n    if (cached) {\r\n        return cached;\r\n    }\r\n    let name = camelize(rawName);\r\n    if (name !== 'filter' && name in style) {\r\n        return (prefixCache[rawName] = name);\r\n    }\r\n    name = capitalize(name);\r\n    for (let i = 0; i < prefixes.length; i++) {\r\n        const prefixed = prefixes[i] + name;\r\n        if (prefixed in style) {\r\n            return (prefixCache[rawName] = prefixed);\r\n        }\r\n    }\r\n    return rawName;\r\n}\n\nconst xlinkNS = 'http://www.w3.org/1999/xlink';\r\nfunction patchAttr(el, key, value, isSVG) {\r\n    if (isSVG && key.startsWith('xlink:')) {\r\n        if (value == null) {\r\n            el.removeAttributeNS(xlinkNS, key.slice(6, key.length));\r\n        }\r\n        else {\r\n            el.setAttributeNS(xlinkNS, key, value);\r\n        }\r\n    }\r\n    else {\r\n        // note we are only checking boolean attributes that don't have a\r\n        // corresponding dom prop of the same name here.\r\n        const isBoolean = isSpecialBooleanAttr(key);\r\n        if (value == null || (isBoolean && value === false)) {\r\n            el.removeAttribute(key);\r\n        }\r\n        else {\r\n            el.setAttribute(key, isBoolean ? '' : value);\r\n        }\r\n    }\r\n}\n\n// __UNSAFE__\r\n// functions. The user is responsible for using them with only trusted content.\r\nfunction patchDOMProp(el, key, value, \r\n// the following args are passed only due to potential innerHTML/textContent\r\n// overriding existing VNodes, in which case the old tree must be properly\r\n// unmounted.\r\nprevChildren, parentComponent, parentSuspense, unmountChildren) {\r\n    if (key === 'innerHTML' || key === 'textContent') {\r\n        if (prevChildren) {\r\n            unmountChildren(prevChildren, parentComponent, parentSuspense);\r\n        }\r\n        el[key] = value == null ? '' : value;\r\n        return;\r\n    }\r\n    if (key === 'value' && el.tagName !== 'PROGRESS') {\r\n        // store value as _value as well since\r\n        // non-string values will be stringified.\r\n        el._value = value;\r\n        el.value = value == null ? '' : value;\r\n        return;\r\n    }\r\n    if (value === '' && typeof el[key] === 'boolean') {\r\n        // e.g. <select multiple> compiles to { multiple: '' }\r\n        el[key] = true;\r\n    }\r\n    else if (value == null && typeof el[key] === 'string') {\r\n        // e.g. <div :id=\"null\">\r\n        el[key] = '';\r\n        el.removeAttribute(key);\r\n    }\r\n    else {\r\n        // some properties perform value validation and throw\r\n        try {\r\n            el[key] = value;\r\n        }\r\n        catch (e) {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                warn(`Failed setting prop \"${key}\" on <${el.tagName.toLowerCase()}>: ` +\r\n                    `value ${value} is invalid.`, e);\r\n            }\r\n        }\r\n    }\r\n}\n\n// Async edge case fix requires storing an event listener's attach timestamp.\r\nlet _getNow = Date.now;\r\n// Determine what event timestamp the browser is using. Annoyingly, the\r\n// timestamp can either be hi-res (relative to page load) or low-res\r\n// (relative to UNIX epoch), so in order to compare time we have to use the\r\n// same timestamp type when saving the flush timestamp.\r\nif (typeof document !== 'undefined' &&\r\n    _getNow() > document.createEvent('Event').timeStamp) {\r\n    // if the low-res timestamp which is bigger than the event timestamp\r\n    // (which is evaluated AFTER) it means the event is using a hi-res timestamp,\r\n    // and we need to use the hi-res version for event listeners as well.\r\n    _getNow = () => performance.now();\r\n}\r\n// To avoid the overhead of repeatedly calling performance.now(), we cache\r\n// and use the same timestamp for all event listeners attached in the same tick.\r\nlet cachedNow = 0;\r\nconst p = Promise.resolve();\r\nconst reset = () => {\r\n    cachedNow = 0;\r\n};\r\nconst getNow = () => cachedNow || (p.then(reset), (cachedNow = _getNow()));\r\nfunction addEventListener(el, event, handler, options) {\r\n    el.addEventListener(event, handler, options);\r\n}\r\nfunction removeEventListener(el, event, handler, options) {\r\n    el.removeEventListener(event, handler, options);\r\n}\r\nfunction patchEvent(el, rawName, prevValue, nextValue, instance = null) {\r\n    const invoker = prevValue && prevValue.invoker;\r\n    if (nextValue && invoker) {\r\n        prevValue.invoker = null;\r\n        invoker.value = nextValue;\r\n        nextValue.invoker = invoker;\r\n    }\r\n    else {\r\n        const [name, options] = parseName(rawName);\r\n        if (nextValue) {\r\n            addEventListener(el, name, createInvoker(nextValue, instance), options);\r\n        }\r\n        else if (invoker) {\r\n            // remove\r\n            removeEventListener(el, name, invoker, options);\r\n        }\r\n    }\r\n}\r\nconst optionsModifierRE = /(?:Once|Passive|Capture)$/;\r\nfunction parseName(name) {\r\n    let options;\r\n    if (optionsModifierRE.test(name)) {\r\n        options = {};\r\n        let m;\r\n        while ((m = name.match(optionsModifierRE))) {\r\n            name = name.slice(0, name.length - m[0].length);\r\n            options[m[0].toLowerCase()] = true;\r\n        }\r\n    }\r\n    return [name.slice(2).toLowerCase(), options];\r\n}\r\nfunction createInvoker(initialValue, instance) {\r\n    const invoker = (e) => {\r\n        // async edge case #6566: inner click event triggers patch, event handler\r\n        // attached to outer element during patch, and triggered again. This\r\n        // happens because browsers fire microtask ticks between event propagation.\r\n        // the solution is simple: we save the timestamp when a handler is attached,\r\n        // and the handler would only fire if the event passed to it was fired\r\n        // AFTER it was attached.\r\n        const timeStamp = e.timeStamp || _getNow();\r\n        if (timeStamp >= invoker.attached - 1) {\r\n            callWithAsyncErrorHandling(patchStopImmediatePropagation(e, invoker.value), instance, 5 /* NATIVE_EVENT_HANDLER */, [e]);\r\n        }\r\n    };\r\n    invoker.value = initialValue;\r\n    initialValue.invoker = invoker;\r\n    invoker.attached = getNow();\r\n    return invoker;\r\n}\r\nfunction patchStopImmediatePropagation(e, value) {\r\n    if (isArray(value)) {\r\n        const originalStop = e.stopImmediatePropagation;\r\n        e.stopImmediatePropagation = () => {\r\n            originalStop.call(e);\r\n            e._stopped = true;\r\n        };\r\n        return value.map(fn => (e) => !e._stopped && fn(e));\r\n    }\r\n    else {\r\n        return value;\r\n    }\r\n}\n\nconst nativeOnRE = /^on[a-z]/;\r\nconst forcePatchProp = (_, key) => key === 'value';\r\nconst patchProp = (el, key, prevValue, nextValue, isSVG = false, prevChildren, parentComponent, parentSuspense, unmountChildren) => {\r\n    switch (key) {\r\n        // special\r\n        case 'class':\r\n            patchClass(el, nextValue, isSVG);\r\n            break;\r\n        case 'style':\r\n            patchStyle(el, prevValue, nextValue);\r\n            break;\r\n        default:\r\n            if (isOn(key)) {\r\n                // ignore v-model listeners\r\n                if (!isModelListener(key)) {\r\n                    patchEvent(el, key, prevValue, nextValue, parentComponent);\r\n                }\r\n            }\r\n            else if (shouldSetAsProp(el, key, nextValue, isSVG)) {\r\n                patchDOMProp(el, key, nextValue, prevChildren, parentComponent, parentSuspense, unmountChildren);\r\n            }\r\n            else {\r\n                // special case for <input v-model type=\"checkbox\"> with\r\n                // :true-value & :false-value\r\n                // store value as dom properties since non-string values will be\r\n                // stringified.\r\n                if (key === 'true-value') {\r\n                    el._trueValue = nextValue;\r\n                }\r\n                else if (key === 'false-value') {\r\n                    el._falseValue = nextValue;\r\n                }\r\n                patchAttr(el, key, nextValue, isSVG);\r\n            }\r\n            break;\r\n    }\r\n};\r\nfunction shouldSetAsProp(el, key, value, isSVG) {\r\n    if (isSVG) {\r\n        // most keys must be set as attribute on svg elements to work\r\n        // ...except innerHTML\r\n        if (key === 'innerHTML') {\r\n            return true;\r\n        }\r\n        // or native onclick with function values\r\n        if (key in el && nativeOnRE.test(key) && isFunction(value)) {\r\n            return true;\r\n        }\r\n        return false;\r\n    }\r\n    // spellcheck and draggable are numerated attrs, however their\r\n    // corresponding DOM properties are actually booleans - this leads to\r\n    // setting it with a string \"false\" value leading it to be coerced to\r\n    // `true`, so we need to always treat them as attributes.\r\n    // Note that `contentEditable` doesn't have this problem: its DOM\r\n    // property is also enumerated string values.\r\n    if (key === 'spellcheck' || key === 'draggable') {\r\n        return false;\r\n    }\r\n    // #1526 <input list> must be set as attribute\r\n    if (key === 'list' && el.tagName === 'INPUT') {\r\n        return false;\r\n    }\r\n    // native onclick with string value, must be set as attribute\r\n    if (nativeOnRE.test(key) && isString(value)) {\r\n        return false;\r\n    }\r\n    return key in el;\r\n}\n\nfunction useCssModule(name = '$style') {\r\n    /* istanbul ignore else */\r\n    {\r\n        const instance = getCurrentInstance();\r\n        if (!instance) {\r\n            (process.env.NODE_ENV !== 'production') && warn(`useCssModule must be called inside setup()`);\r\n            return EMPTY_OBJ;\r\n        }\r\n        const modules = instance.type.__cssModules;\r\n        if (!modules) {\r\n            (process.env.NODE_ENV !== 'production') && warn(`Current instance does not have CSS modules injected.`);\r\n            return EMPTY_OBJ;\r\n        }\r\n        const mod = modules[name];\r\n        if (!mod) {\r\n            (process.env.NODE_ENV !== 'production') &&\r\n                warn(`Current instance does not have CSS module named \"${name}\".`);\r\n            return EMPTY_OBJ;\r\n        }\r\n        return mod;\r\n    }\r\n}\n\nfunction useCssVars(getter, scoped = false) {\r\n    const instance = getCurrentInstance();\r\n    /* istanbul ignore next */\r\n    if (!instance) {\r\n        (process.env.NODE_ENV !== 'production') &&\r\n            warn(`useCssVars is called without current active component instance.`);\r\n        return;\r\n    }\r\n    const prefix = scoped && instance.type.__scopeId\r\n        ? `${instance.type.__scopeId.replace(/^data-v-/, '')}-`\r\n        : ``;\r\n    onMounted(() => {\r\n        watchEffect(() => {\r\n            setVarsOnVNode(instance.subTree, getter(instance.proxy), prefix);\r\n        });\r\n    });\r\n}\r\nfunction setVarsOnVNode(vnode, vars, prefix) {\r\n    if ( vnode.shapeFlag & 128 /* SUSPENSE */) {\r\n        const { isResolved, isHydrating, fallbackTree, subTree } = vnode.suspense;\r\n        if (isResolved || isHydrating) {\r\n            vnode = subTree;\r\n        }\r\n        else {\r\n            vnode.suspense.effects.push(() => {\r\n                setVarsOnVNode(subTree, vars, prefix);\r\n            });\r\n            vnode = fallbackTree;\r\n        }\r\n    }\r\n    // drill down HOCs until it's a non-component vnode\r\n    while (vnode.component) {\r\n        vnode = vnode.component.subTree;\r\n    }\r\n    if (vnode.shapeFlag & 1 /* ELEMENT */ && vnode.el) {\r\n        const style = vnode.el.style;\r\n        for (const key in vars) {\r\n            style.setProperty(`--${prefix}${key}`, unref(vars[key]));\r\n        }\r\n    }\r\n    else if (vnode.type === Fragment) {\r\n        vnode.children.forEach(c => setVarsOnVNode(c, vars, prefix));\r\n    }\r\n}\n\nconst TRANSITION = 'transition';\r\nconst ANIMATION = 'animation';\r\n// DOM Transition is a higher-order-component based on the platform-agnostic\r\n// base Transition component, with DOM-specific logic.\r\nconst Transition = (props, { slots }) => h(BaseTransition, resolveTransitionProps(props), slots);\r\nTransition.displayName = 'Transition';\r\nconst DOMTransitionPropsValidators = {\r\n    name: String,\r\n    type: String,\r\n    css: {\r\n        type: Boolean,\r\n        default: true\r\n    },\r\n    duration: [String, Number, Object],\r\n    enterFromClass: String,\r\n    enterActiveClass: String,\r\n    enterToClass: String,\r\n    appearFromClass: String,\r\n    appearActiveClass: String,\r\n    appearToClass: String,\r\n    leaveFromClass: String,\r\n    leaveActiveClass: String,\r\n    leaveToClass: String\r\n};\r\nconst TransitionPropsValidators = (Transition.props = /*#__PURE__*/ extend({}, BaseTransition.props, DOMTransitionPropsValidators));\r\nfunction resolveTransitionProps(rawProps) {\r\n    let { name = 'v', type, css = true, duration, enterFromClass = `${name}-enter-from`, enterActiveClass = `${name}-enter-active`, enterToClass = `${name}-enter-to`, appearFromClass = enterFromClass, appearActiveClass = enterActiveClass, appearToClass = enterToClass, leaveFromClass = `${name}-leave-from`, leaveActiveClass = `${name}-leave-active`, leaveToClass = `${name}-leave-to` } = rawProps;\r\n    const baseProps = {};\r\n    for (const key in rawProps) {\r\n        if (!(key in DOMTransitionPropsValidators)) {\r\n            baseProps[key] = rawProps[key];\r\n        }\r\n    }\r\n    if (!css) {\r\n        return baseProps;\r\n    }\r\n    const durations = normalizeDuration(duration);\r\n    const enterDuration = durations && durations[0];\r\n    const leaveDuration = durations && durations[1];\r\n    const { onBeforeEnter, onEnter, onEnterCancelled, onLeave, onLeaveCancelled, onBeforeAppear = onBeforeEnter, onAppear = onEnter, onAppearCancelled = onEnterCancelled } = baseProps;\r\n    const finishEnter = (el, isAppear, done) => {\r\n        removeTransitionClass(el, isAppear ? appearToClass : enterToClass);\r\n        removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);\r\n        done && done();\r\n    };\r\n    const finishLeave = (el, done) => {\r\n        removeTransitionClass(el, leaveToClass);\r\n        removeTransitionClass(el, leaveActiveClass);\r\n        done && done();\r\n    };\r\n    const makeEnterHook = (isAppear) => {\r\n        return (el, done) => {\r\n            const hook = isAppear ? onAppear : onEnter;\r\n            const resolve = () => finishEnter(el, isAppear, done);\r\n            hook && hook(el, resolve);\r\n            nextFrame(() => {\r\n                removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);\r\n                addTransitionClass(el, isAppear ? appearToClass : enterToClass);\r\n                if (!(hook && hook.length > 1)) {\r\n                    if (enterDuration) {\r\n                        setTimeout(resolve, enterDuration);\r\n                    }\r\n                    else {\r\n                        whenTransitionEnds(el, type, resolve);\r\n                    }\r\n                }\r\n            });\r\n        };\r\n    };\r\n    return extend(baseProps, {\r\n        onBeforeEnter(el) {\r\n            onBeforeEnter && onBeforeEnter(el);\r\n            addTransitionClass(el, enterActiveClass);\r\n            addTransitionClass(el, enterFromClass);\r\n        },\r\n        onBeforeAppear(el) {\r\n            onBeforeAppear && onBeforeAppear(el);\r\n            addTransitionClass(el, appearActiveClass);\r\n            addTransitionClass(el, appearFromClass);\r\n        },\r\n        onEnter: makeEnterHook(false),\r\n        onAppear: makeEnterHook(true),\r\n        onLeave(el, done) {\r\n            const resolve = () => finishLeave(el, done);\r\n            addTransitionClass(el, leaveActiveClass);\r\n            addTransitionClass(el, leaveFromClass);\r\n            nextFrame(() => {\r\n                removeTransitionClass(el, leaveFromClass);\r\n                addTransitionClass(el, leaveToClass);\r\n                if (!(onLeave && onLeave.length > 1)) {\r\n                    if (leaveDuration) {\r\n                        setTimeout(resolve, leaveDuration);\r\n                    }\r\n                    else {\r\n                        whenTransitionEnds(el, type, resolve);\r\n                    }\r\n                }\r\n            });\r\n            onLeave && onLeave(el, resolve);\r\n        },\r\n        onEnterCancelled(el) {\r\n            finishEnter(el, false);\r\n            onEnterCancelled && onEnterCancelled(el);\r\n        },\r\n        onAppearCancelled(el) {\r\n            finishEnter(el, true);\r\n            onAppearCancelled && onAppearCancelled(el);\r\n        },\r\n        onLeaveCancelled(el) {\r\n            finishLeave(el);\r\n            onLeaveCancelled && onLeaveCancelled(el);\r\n        }\r\n    });\r\n}\r\nfunction normalizeDuration(duration) {\r\n    if (duration == null) {\r\n        return null;\r\n    }\r\n    else if (isObject(duration)) {\r\n        return [NumberOf(duration.enter), NumberOf(duration.leave)];\r\n    }\r\n    else {\r\n        const n = NumberOf(duration);\r\n        return [n, n];\r\n    }\r\n}\r\nfunction NumberOf(val) {\r\n    const res = toNumber(val);\r\n    if ((process.env.NODE_ENV !== 'production'))\r\n        validateDuration(res);\r\n    return res;\r\n}\r\nfunction validateDuration(val) {\r\n    if (typeof val !== 'number') {\r\n        warn(`<transition> explicit duration is not a valid number - ` +\r\n            `got ${JSON.stringify(val)}.`);\r\n    }\r\n    else if (isNaN(val)) {\r\n        warn(`<transition> explicit duration is NaN - ` +\r\n            'the duration expression might be incorrect.');\r\n    }\r\n}\r\nfunction addTransitionClass(el, cls) {\r\n    cls.split(/\\s+/).forEach(c => c && el.classList.add(c));\r\n    (el._vtc ||\r\n        (el._vtc = new Set())).add(cls);\r\n}\r\nfunction removeTransitionClass(el, cls) {\r\n    cls.split(/\\s+/).forEach(c => c && el.classList.remove(c));\r\n    const { _vtc } = el;\r\n    if (_vtc) {\r\n        _vtc.delete(cls);\r\n        if (!_vtc.size) {\r\n            el._vtc = undefined;\r\n        }\r\n    }\r\n}\r\nfunction nextFrame(cb) {\r\n    requestAnimationFrame(() => {\r\n        requestAnimationFrame(cb);\r\n    });\r\n}\r\nfunction whenTransitionEnds(el, expectedType, cb) {\r\n    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);\r\n    if (!type) {\r\n        return cb();\r\n    }\r\n    const endEvent = type + 'end';\r\n    let ended = 0;\r\n    const end = () => {\r\n        el.removeEventListener(endEvent, onEnd);\r\n        cb();\r\n    };\r\n    const onEnd = (e) => {\r\n        if (e.target === el) {\r\n            if (++ended >= propCount) {\r\n                end();\r\n            }\r\n        }\r\n    };\r\n    setTimeout(() => {\r\n        if (ended < propCount) {\r\n            end();\r\n        }\r\n    }, timeout + 1);\r\n    el.addEventListener(endEvent, onEnd);\r\n}\r\nfunction getTransitionInfo(el, expectedType) {\r\n    const styles = window.getComputedStyle(el);\r\n    // JSDOM may return undefined for transition properties\r\n    const getStyleProperties = (key) => (styles[key] || '').split(', ');\r\n    const transitionDelays = getStyleProperties(TRANSITION + 'Delay');\r\n    const transitionDurations = getStyleProperties(TRANSITION + 'Duration');\r\n    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);\r\n    const animationDelays = getStyleProperties(ANIMATION + 'Delay');\r\n    const animationDurations = getStyleProperties(ANIMATION + 'Duration');\r\n    const animationTimeout = getTimeout(animationDelays, animationDurations);\r\n    let type = null;\r\n    let timeout = 0;\r\n    let propCount = 0;\r\n    /* istanbul ignore if */\r\n    if (expectedType === TRANSITION) {\r\n        if (transitionTimeout > 0) {\r\n            type = TRANSITION;\r\n            timeout = transitionTimeout;\r\n            propCount = transitionDurations.length;\r\n        }\r\n    }\r\n    else if (expectedType === ANIMATION) {\r\n        if (animationTimeout > 0) {\r\n            type = ANIMATION;\r\n            timeout = animationTimeout;\r\n            propCount = animationDurations.length;\r\n        }\r\n    }\r\n    else {\r\n        timeout = Math.max(transitionTimeout, animationTimeout);\r\n        type =\r\n            timeout > 0\r\n                ? transitionTimeout > animationTimeout\r\n                    ? TRANSITION\r\n                    : ANIMATION\r\n                : null;\r\n        propCount = type\r\n            ? type === TRANSITION\r\n                ? transitionDurations.length\r\n                : animationDurations.length\r\n            : 0;\r\n    }\r\n    const hasTransform = type === TRANSITION &&\r\n        /\\b(transform|all)(,|$)/.test(styles[TRANSITION + 'Property']);\r\n    return {\r\n        type,\r\n        timeout,\r\n        propCount,\r\n        hasTransform\r\n    };\r\n}\r\nfunction getTimeout(delays, durations) {\r\n    while (delays.length < durations.length) {\r\n        delays = delays.concat(delays);\r\n    }\r\n    return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));\r\n}\r\n// Old versions of Chromium (below 61.0.3163.100) formats floating pointer\r\n// numbers in a locale-dependent way, using a comma instead of a dot.\r\n// If comma is not replaced with a dot, the input will be rounded down\r\n// (i.e. acting as a floor function) causing unexpected behaviors\r\nfunction toMs(s) {\r\n    return Number(s.slice(0, -1).replace(',', '.')) * 1000;\r\n}\n\nfunction toRaw(observed) {\r\n    return ((observed && toRaw(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\n\nconst positionMap = new WeakMap();\r\nconst newPositionMap = new WeakMap();\r\nconst TransitionGroupImpl = {\r\n    name: 'TransitionGroup',\r\n    props: /*#__PURE__*/ extend({}, TransitionPropsValidators, {\r\n        tag: String,\r\n        moveClass: String\r\n    }),\r\n    setup(props, { slots }) {\r\n        const instance = getCurrentInstance();\r\n        const state = useTransitionState();\r\n        let prevChildren;\r\n        let children;\r\n        onUpdated(() => {\r\n            // children is guaranteed to exist after initial render\r\n            if (!prevChildren.length) {\r\n                return;\r\n            }\r\n            const moveClass = props.moveClass || `${props.name || 'v'}-move`;\r\n            if (!hasCSSTransform(prevChildren[0].el, instance.vnode.el, moveClass)) {\r\n                return;\r\n            }\r\n            // we divide the work into three loops to avoid mixing DOM reads and writes\r\n            // in each iteration - which helps prevent layout thrashing.\r\n            prevChildren.forEach(callPendingCbs);\r\n            prevChildren.forEach(recordPosition);\r\n            const movedChildren = prevChildren.filter(applyTranslation);\r\n            // force reflow to put everything in position\r\n            forceReflow();\r\n            movedChildren.forEach(c => {\r\n                const el = c.el;\r\n                const style = el.style;\r\n                addTransitionClass(el, moveClass);\r\n                style.transform = style.webkitTransform = style.transitionDuration = '';\r\n                const cb = (el._moveCb = (e) => {\r\n                    if (e && e.target !== el) {\r\n                        return;\r\n                    }\r\n                    if (!e || /transform$/.test(e.propertyName)) {\r\n                        el.removeEventListener('transitionend', cb);\r\n                        el._moveCb = null;\r\n                        removeTransitionClass(el, moveClass);\r\n                    }\r\n                });\r\n                el.addEventListener('transitionend', cb);\r\n            });\r\n        });\r\n        return () => {\r\n            const rawProps = toRaw(props);\r\n            const cssTransitionProps = resolveTransitionProps(rawProps);\r\n            const tag = rawProps.tag || Fragment;\r\n            prevChildren = children;\r\n            children = slots.default ? getTransitionRawChildren(slots.default()) : [];\r\n            for (let i = 0; i < children.length; i++) {\r\n                const child = children[i];\r\n                if (child.key != null) {\r\n                    setTransitionHooks(child, resolveTransitionHooks(child, cssTransitionProps, state, instance));\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn(`<TransitionGroup> children must be keyed.`);\r\n                }\r\n            }\r\n            if (prevChildren) {\r\n                for (let i = 0; i < prevChildren.length; i++) {\r\n                    const child = prevChildren[i];\r\n                    setTransitionHooks(child, resolveTransitionHooks(child, cssTransitionProps, state, instance));\r\n                    positionMap.set(child, child.el.getBoundingClientRect());\r\n                }\r\n            }\r\n            return createVNode(tag, null, children);\r\n        };\r\n    }\r\n};\r\nconst TransitionGroup = TransitionGroupImpl;\r\nfunction callPendingCbs(c) {\r\n    const el = c.el;\r\n    if (el._moveCb) {\r\n        el._moveCb();\r\n    }\r\n    if (el._enterCb) {\r\n        el._enterCb();\r\n    }\r\n}\r\nfunction recordPosition(c) {\r\n    newPositionMap.set(c, c.el.getBoundingClientRect());\r\n}\r\nfunction applyTranslation(c) {\r\n    const oldPos = positionMap.get(c);\r\n    const newPos = newPositionMap.get(c);\r\n    const dx = oldPos.left - newPos.left;\r\n    const dy = oldPos.top - newPos.top;\r\n    if (dx || dy) {\r\n        const s = c.el.style;\r\n        s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;\r\n        s.transitionDuration = '0s';\r\n        return c;\r\n    }\r\n}\r\n// this is put in a dedicated function to avoid the line from being treeshaken\r\nfunction forceReflow() {\r\n    return document.body.offsetHeight;\r\n}\r\nfunction hasCSSTransform(el, root, moveClass) {\r\n    // Detect whether an element with the move class applied has\r\n    // CSS transitions. Since the element may be inside an entering\r\n    // transition at this very moment, we make a clone of it and remove\r\n    // all other transition classes applied to ensure only the move class\r\n    // is applied.\r\n    const clone = el.cloneNode();\r\n    if (el._vtc) {\r\n        el._vtc.forEach(cls => {\r\n            cls.split(/\\s+/).forEach(c => c && clone.classList.remove(c));\r\n        });\r\n    }\r\n    moveClass.split(/\\s+/).forEach(c => c && clone.classList.add(c));\r\n    clone.style.display = 'none';\r\n    const container = (root.nodeType === 1\r\n        ? root\r\n        : root.parentNode);\r\n    container.appendChild(clone);\r\n    const { hasTransform } = getTransitionInfo(clone);\r\n    container.removeChild(clone);\r\n    return hasTransform;\r\n}\n\nconst getModelAssigner = (vnode) => {\r\n    const fn = vnode.props['onUpdate:modelValue'];\r\n    return isArray(fn) ? value => invokeArrayFns(fn, value) : fn;\r\n};\r\nfunction onCompositionStart(e) {\r\n    e.target.composing = true;\r\n}\r\nfunction onCompositionEnd(e) {\r\n    const target = e.target;\r\n    if (target.composing) {\r\n        target.composing = false;\r\n        trigger(target, 'input');\r\n    }\r\n}\r\nfunction trigger(el, type) {\r\n    const e = document.createEvent('HTMLEvents');\r\n    e.initEvent(type, true, true);\r\n    el.dispatchEvent(e);\r\n}\r\n// We are exporting the v-model runtime directly as vnode hooks so that it can\r\n// be tree-shaken in case v-model is never used.\r\nconst vModelText = {\r\n    beforeMount(el, { value, modifiers: { lazy, trim, number } }, vnode) {\r\n        el.value = value == null ? '' : value;\r\n        el._assign = getModelAssigner(vnode);\r\n        const castToNumber = number || el.type === 'number';\r\n        addEventListener(el, lazy ? 'change' : 'input', e => {\r\n            if (e.target.composing)\r\n                return;\r\n            let domValue = el.value;\r\n            if (trim) {\r\n                domValue = domValue.trim();\r\n            }\r\n            else if (castToNumber) {\r\n                domValue = toNumber(domValue);\r\n            }\r\n            el._assign(domValue);\r\n        });\r\n        if (trim) {\r\n            addEventListener(el, 'change', () => {\r\n                el.value = el.value.trim();\r\n            });\r\n        }\r\n        if (!lazy) {\r\n            addEventListener(el, 'compositionstart', onCompositionStart);\r\n            addEventListener(el, 'compositionend', onCompositionEnd);\r\n            // Safari < 10.2 & UIWebView doesn't fire compositionend when\r\n            // switching focus before confirming composition choice\r\n            // this also fixes the issue where some browsers e.g. iOS Chrome\r\n            // fires \"change\" instead of \"input\" on autocomplete.\r\n            addEventListener(el, 'change', onCompositionEnd);\r\n        }\r\n    },\r\n    beforeUpdate(el, { value, modifiers: { trim, number } }, vnode) {\r\n        el._assign = getModelAssigner(vnode);\r\n        if (document.activeElement === el) {\r\n            if (trim && el.value.trim() === value) {\r\n                return;\r\n            }\r\n            if ((number || el.type === 'number') && toNumber(el.value) === value) {\r\n                return;\r\n            }\r\n        }\r\n        el.value = value == null ? '' : value;\r\n    }\r\n};\r\nconst vModelCheckbox = {\r\n    beforeMount(el, binding, vnode) {\r\n        setChecked(el, binding, vnode);\r\n        el._assign = getModelAssigner(vnode);\r\n        addEventListener(el, 'change', () => {\r\n            const modelValue = el._modelValue;\r\n            const elementValue = getValue(el);\r\n            const checked = el.checked;\r\n            const assign = el._assign;\r\n            if (isArray(modelValue)) {\r\n                const index = looseIndexOf(modelValue, elementValue);\r\n                const found = index !== -1;\r\n                if (checked && !found) {\r\n                    assign(modelValue.concat(elementValue));\r\n                }\r\n                else if (!checked && found) {\r\n                    const filtered = [...modelValue];\r\n                    filtered.splice(index, 1);\r\n                    assign(filtered);\r\n                }\r\n            }\r\n            else {\r\n                assign(getCheckboxValue(el, checked));\r\n            }\r\n        });\r\n    },\r\n    beforeUpdate(el, binding, vnode) {\r\n        el._assign = getModelAssigner(vnode);\r\n        setChecked(el, binding, vnode);\r\n    }\r\n};\r\nfunction setChecked(el, { value, oldValue }, vnode) {\r\n    el._modelValue = value;\r\n    if (isArray(value)) {\r\n        el.checked = looseIndexOf(value, vnode.props.value) > -1;\r\n    }\r\n    else if (value !== oldValue) {\r\n        el.checked = looseEqual(value, getCheckboxValue(el, true));\r\n    }\r\n}\r\nconst vModelRadio = {\r\n    beforeMount(el, { value }, vnode) {\r\n        el.checked = looseEqual(value, vnode.props.value);\r\n        el._assign = getModelAssigner(vnode);\r\n        addEventListener(el, 'change', () => {\r\n            el._assign(getValue(el));\r\n        });\r\n    },\r\n    beforeUpdate(el, { value, oldValue }, vnode) {\r\n        el._assign = getModelAssigner(vnode);\r\n        if (value !== oldValue) {\r\n            el.checked = looseEqual(value, vnode.props.value);\r\n        }\r\n    }\r\n};\r\nconst vModelSelect = {\r\n    // use mounted & updated because <select> relies on its children <option>s.\r\n    mounted(el, { value }, vnode) {\r\n        setSelected(el, value);\r\n        el._assign = getModelAssigner(vnode);\r\n        addEventListener(el, 'change', () => {\r\n            const selectedVal = Array.prototype.filter\r\n                .call(el.options, (o) => o.selected)\r\n                .map(getValue);\r\n            el._assign(el.multiple ? selectedVal : selectedVal[0]);\r\n        });\r\n    },\r\n    beforeUpdate(el, _binding, vnode) {\r\n        el._assign = getModelAssigner(vnode);\r\n    },\r\n    updated(el, { value }) {\r\n        setSelected(el, value);\r\n    }\r\n};\r\nfunction setSelected(el, value) {\r\n    const isMultiple = el.multiple;\r\n    if (isMultiple && !isArray(value)) {\r\n        (process.env.NODE_ENV !== 'production') &&\r\n            warn(`<select multiple v-model> expects an Array value for its binding, ` +\r\n                `but got ${Object.prototype.toString.call(value).slice(8, -1)}.`);\r\n        return;\r\n    }\r\n    for (let i = 0, l = el.options.length; i < l; i++) {\r\n        const option = el.options[i];\r\n        const optionValue = getValue(option);\r\n        if (isMultiple) {\r\n            option.selected = looseIndexOf(value, optionValue) > -1;\r\n        }\r\n        else {\r\n            if (looseEqual(getValue(option), value)) {\r\n                el.selectedIndex = i;\r\n                return;\r\n            }\r\n        }\r\n    }\r\n    if (!isMultiple) {\r\n        el.selectedIndex = -1;\r\n    }\r\n}\r\n// retrieve raw value set via :value bindings\r\nfunction getValue(el) {\r\n    return '_value' in el ? el._value : el.value;\r\n}\r\n// retrieve raw value for true-value and false-value set via :true-value or :false-value bindings\r\nfunction getCheckboxValue(el, checked) {\r\n    const key = checked ? '_trueValue' : '_falseValue';\r\n    return key in el ? el[key] : checked;\r\n}\r\nconst vModelDynamic = {\r\n    beforeMount(el, binding, vnode) {\r\n        callModelHook(el, binding, vnode, null, 'beforeMount');\r\n    },\r\n    mounted(el, binding, vnode) {\r\n        callModelHook(el, binding, vnode, null, 'mounted');\r\n    },\r\n    beforeUpdate(el, binding, vnode, prevVNode) {\r\n        callModelHook(el, binding, vnode, prevVNode, 'beforeUpdate');\r\n    },\r\n    updated(el, binding, vnode, prevVNode) {\r\n        callModelHook(el, binding, vnode, prevVNode, 'updated');\r\n    }\r\n};\r\nfunction callModelHook(el, binding, vnode, prevVNode, hook) {\r\n    let modelToUse;\r\n    switch (el.tagName) {\r\n        case 'SELECT':\r\n            modelToUse = vModelSelect;\r\n            break;\r\n        case 'TEXTAREA':\r\n            modelToUse = vModelText;\r\n            break;\r\n        default:\r\n            switch (el.type) {\r\n                case 'checkbox':\r\n                    modelToUse = vModelCheckbox;\r\n                    break;\r\n                case 'radio':\r\n                    modelToUse = vModelRadio;\r\n                    break;\r\n                default:\r\n                    modelToUse = vModelText;\r\n            }\r\n    }\r\n    const fn = modelToUse[hook];\r\n    fn && fn(el, binding, vnode, prevVNode);\r\n}\n\nconst systemModifiers = ['ctrl', 'shift', 'alt', 'meta'];\r\nconst modifierGuards = {\r\n    stop: e => e.stopPropagation(),\r\n    prevent: e => e.preventDefault(),\r\n    self: e => e.target !== e.currentTarget,\r\n    ctrl: e => !e.ctrlKey,\r\n    shift: e => !e.shiftKey,\r\n    alt: e => !e.altKey,\r\n    meta: e => !e.metaKey,\r\n    left: e => 'button' in e && e.button !== 0,\r\n    middle: e => 'button' in e && e.button !== 1,\r\n    right: e => 'button' in e && e.button !== 2,\r\n    exact: (e, modifiers) => systemModifiers.some(m => e[`${m}Key`] && !modifiers.includes(m))\r\n};\r\n/**\r\n * @private\r\n */\r\nconst withModifiers = (fn, modifiers) => {\r\n    return (event, ...args) => {\r\n        for (let i = 0; i < modifiers.length; i++) {\r\n            const guard = modifierGuards[modifiers[i]];\r\n            if (guard && guard(event, modifiers))\r\n                return;\r\n        }\r\n        return fn(event, ...args);\r\n    };\r\n};\r\n// Kept for 2.x compat.\r\n// Note: IE11 compat for `spacebar` and `del` is removed for now.\r\nconst keyNames = {\r\n    esc: 'escape',\r\n    space: ' ',\r\n    up: 'arrow-up',\r\n    left: 'arrow-left',\r\n    right: 'arrow-right',\r\n    down: 'arrow-down',\r\n    delete: 'backspace'\r\n};\r\n/**\r\n * @private\r\n */\r\nconst withKeys = (fn, modifiers) => {\r\n    return (event) => {\r\n        if (!('key' in event))\r\n            return;\r\n        const eventKey = hyphenate(event.key);\r\n        if (\r\n        // None of the provided key modifiers match the current event key\r\n        !modifiers.some(k => k === eventKey || keyNames[k] === eventKey)) {\r\n            return;\r\n        }\r\n        return fn(event);\r\n    };\r\n};\n\nconst vShow = {\r\n    beforeMount(el, { value }, { transition }) {\r\n        el._vod = el.style.display === 'none' ? '' : el.style.display;\r\n        if (transition && value) {\r\n            transition.beforeEnter(el);\r\n        }\r\n        else {\r\n            setDisplay(el, value);\r\n        }\r\n    },\r\n    mounted(el, { value }, { transition }) {\r\n        if (transition && value) {\r\n            transition.enter(el);\r\n        }\r\n    },\r\n    updated(el, { value, oldValue }, { transition }) {\r\n        if (!value === !oldValue)\r\n            return;\r\n        if (transition) {\r\n            if (value) {\r\n                transition.beforeEnter(el);\r\n                setDisplay(el, true);\r\n                transition.enter(el);\r\n            }\r\n            else {\r\n                transition.leave(el, () => {\r\n                    setDisplay(el, false);\r\n                });\r\n            }\r\n        }\r\n        else {\r\n            setDisplay(el, value);\r\n        }\r\n    },\r\n    beforeUnmount(el, { value }) {\r\n        setDisplay(el, value);\r\n    }\r\n};\r\nfunction setDisplay(el, value) {\r\n    el.style.display = value ? el._vod : 'none';\r\n}\n\nconst rendererOptions = extend({ patchProp, forcePatchProp }, nodeOps);\r\n// lazy create the renderer - this makes core renderer logic tree-shakable\r\n// in case the user only imports reactivity utilities from Vue.\r\nlet renderer;\r\nlet enabledHydration = false;\r\nfunction ensureRenderer() {\r\n    return renderer || (renderer = createRenderer(rendererOptions));\r\n}\r\nfunction ensureHydrationRenderer() {\r\n    renderer = enabledHydration\r\n        ? renderer\r\n        : createHydrationRenderer(rendererOptions);\r\n    enabledHydration = true;\r\n    return renderer;\r\n}\r\n// use explicit type casts here to avoid import() calls in rolled-up d.ts\r\nconst render = ((...args) => {\r\n    ensureRenderer().render(...args);\r\n});\r\nconst hydrate = ((...args) => {\r\n    ensureHydrationRenderer().hydrate(...args);\r\n});\r\nconst createApp = ((...args) => {\r\n    const app = ensureRenderer().createApp(...args);\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        injectNativeTagCheck(app);\r\n    }\r\n    const { mount } = app;\r\n    app.mount = (containerOrSelector) => {\r\n        const container = normalizeContainer(containerOrSelector);\r\n        if (!container)\r\n            return;\r\n        const component = app._component;\r\n        if (!isFunction(component) && !component.render && !component.template) {\r\n            component.template = container.innerHTML;\r\n        }\r\n        // clear content before mounting\r\n        container.innerHTML = '';\r\n        const proxy = mount(container);\r\n        container.removeAttribute('v-cloak');\r\n        container.setAttribute('data-v-app', '');\r\n        return proxy;\r\n    };\r\n    return app;\r\n});\r\nconst createSSRApp = ((...args) => {\r\n    const app = ensureHydrationRenderer().createApp(...args);\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        injectNativeTagCheck(app);\r\n    }\r\n    const { mount } = app;\r\n    app.mount = (containerOrSelector) => {\r\n        const container = normalizeContainer(containerOrSelector);\r\n        if (container) {\r\n            return mount(container, true);\r\n        }\r\n    };\r\n    return app;\r\n});\r\nfunction injectNativeTagCheck(app) {\r\n    // Inject `isNativeTag`\r\n    // this is used for component name validation (dev only)\r\n    Object.defineProperty(app.config, 'isNativeTag', {\r\n        value: (tag) => isHTMLTag(tag) || isSVGTag(tag),\r\n        writable: false\r\n    });\r\n}\r\nfunction normalizeContainer(container) {\r\n    if (isString(container)) {\r\n        const res = document.querySelector(container);\r\n        if ((process.env.NODE_ENV !== 'production') && !res) {\r\n            warn(`Failed to mount app: mount target selector returned null.`);\r\n        }\r\n        return res;\r\n    }\r\n    return container;\r\n}\n\nexport { Transition, TransitionGroup, createApp, createSSRApp, hydrate, render, useCssModule, useCssVars, vModelCheckbox, vModelDynamic, vModelRadio, vModelSelect, vModelText, vShow, withKeys, withModifiers };\n","var fails = require('../internals/fails');\n\n// Thank's IE8 for his funny defineProperty\nmodule.exports = !fails(function () {\n  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;\n});\n","'use strict';\nvar toPrimitive = require('../internals/to-primitive');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = function (object, key, value) {\n  var propertyKey = toPrimitive(key);\n  if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));\n  else object[propertyKey] = value;\n};\n","module.exports = function (it) {\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n","var store = require('../internals/shared-store');\n\nvar functionToString = Function.toString;\n\n// this helper broken in `3.4.1-3.4.4`, so we can't use `shared` helper\nif (typeof store.inspectSource != 'function') {\n  store.inspectSource = function (it) {\n    return functionToString.call(it);\n  };\n}\n\nmodule.exports = store.inspectSource;\n","var id = 0;\nvar postfix = Math.random();\n\nmodule.exports = function (key) {\n  return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n  object[key] = value;\n  return object;\n};\n","var fails = require('../internals/fails');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n  var value = data[normalize(feature)];\n  return value == POLYFILL ? true\n    : value == NATIVE ? false\n    : typeof detection == 'function' ? fails(detection)\n    : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n  return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","'use strict';\nvar $ = require('../internals/export');\nvar fails = require('../internals/fails');\nvar isArray = require('../internals/is-array');\nvar isObject = require('../internals/is-object');\nvar toObject = require('../internals/to-object');\nvar toLength = require('../internals/to-length');\nvar createProperty = require('../internals/create-property');\nvar arraySpeciesCreate = require('../internals/array-species-create');\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable');\nvar MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF;\nvar MAXIMUM_ALLOWED_INDEX_EXCEEDED = 'Maximum allowed index exceeded';\n\n// We can't use this feature detection in V8 since it causes\n// deoptimization and serious performance degradation\n// https://github.com/zloirock/core-js/issues/679\nvar IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails(function () {\n  var array = [];\n  array[IS_CONCAT_SPREADABLE] = false;\n  return array.concat()[0] !== array;\n});\n\nvar SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('concat');\n\nvar isConcatSpreadable = function (O) {\n  if (!isObject(O)) return false;\n  var spreadable = O[IS_CONCAT_SPREADABLE];\n  return spreadable !== undefined ? !!spreadable : isArray(O);\n};\n\nvar FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !SPECIES_SUPPORT;\n\n// `Array.prototype.concat` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.concat\n// with adding support of @@isConcatSpreadable and @@species\n$({ target: 'Array', proto: true, forced: FORCED }, {\n  concat: function concat(arg) { // eslint-disable-line no-unused-vars\n    var O = toObject(this);\n    var A = arraySpeciesCreate(O, 0);\n    var n = 0;\n    var i, k, length, len, E;\n    for (i = -1, length = arguments.length; i < length; i++) {\n      E = i === -1 ? O : arguments[i];\n      if (isConcatSpreadable(E)) {\n        len = toLength(E.length);\n        if (n + len > MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED);\n        for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]);\n      } else {\n        if (n >= MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED);\n        createProperty(A, n++, E);\n      }\n    }\n    A.length = n;\n    return A;\n  }\n});\n","var anObject = require('../internals/an-object');\n\n// call something on iterator step with safe closing on error\nmodule.exports = function (iterator, fn, value, ENTRIES) {\n  try {\n    return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);\n  // 7.4.6 IteratorClose(iterator, completion)\n  } catch (error) {\n    var returnMethod = iterator['return'];\n    if (returnMethod !== undefined) anObject(returnMethod.call(iterator));\n    throw error;\n  }\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar anObject = require('../internals/an-object');\nvar toPrimitive = require('../internals/to-primitive');\n\nvar nativeDefineProperty = Object.defineProperty;\n\n// `Object.defineProperty` method\n// https://tc39.github.io/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if (IE8_DOM_DEFINE) try {\n    return nativeDefineProperty(O, P, Attributes);\n  } catch (error) { /* empty */ }\n  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');\n  if ('value' in Attributes) O[P] = Attributes.value;\n  return O;\n};\n","'use strict';\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar Iterators = require('../internals/iterators');\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (IteratorConstructor, NAME, next) {\n  var TO_STRING_TAG = NAME + ' Iterator';\n  IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) });\n  setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n  Iterators[TO_STRING_TAG] = returnThis;\n  return IteratorConstructor;\n};\n","/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n    const map = Object.create(null);\r\n    const list = str.split(',');\r\n    for (let i = 0; i < list.length; i++) {\r\n        map[list[i]] = true;\r\n    }\r\n    return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\n// Patch flags are optimization hints generated by the compiler.\r\n// when a block with dynamicChildren is encountered during diff, the algorithm\r\n// enters \"optimized mode\". In this mode, we know that the vdom is produced by\r\n// a render function generated by the compiler, so the algorithm only needs to\r\n// handle updates explicitly marked by these patch flags.\r\n// dev only flag -> name mapping\r\nconst PatchFlagNames = {\r\n    [1 /* TEXT */]: `TEXT`,\r\n    [2 /* CLASS */]: `CLASS`,\r\n    [4 /* STYLE */]: `STYLE`,\r\n    [8 /* PROPS */]: `PROPS`,\r\n    [16 /* FULL_PROPS */]: `FULL_PROPS`,\r\n    [32 /* HYDRATE_EVENTS */]: `HYDRATE_EVENTS`,\r\n    [64 /* STABLE_FRAGMENT */]: `STABLE_FRAGMENT`,\r\n    [128 /* KEYED_FRAGMENT */]: `KEYED_FRAGMENT`,\r\n    [256 /* UNKEYED_FRAGMENT */]: `UNKEYED_FRAGMENT`,\r\n    [1024 /* DYNAMIC_SLOTS */]: `DYNAMIC_SLOTS`,\r\n    [512 /* NEED_PATCH */]: `NEED_PATCH`,\r\n    [-1 /* HOISTED */]: `HOISTED`,\r\n    [-2 /* BAIL */]: `BAIL`\r\n};\n\nconst GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +\r\n    'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +\r\n    'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';\r\nconst isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);\n\nconst range = 2;\r\nfunction generateCodeFrame(source, start = 0, end = source.length) {\r\n    const lines = source.split(/\\r?\\n/);\r\n    let count = 0;\r\n    const res = [];\r\n    for (let i = 0; i < lines.length; i++) {\r\n        count += lines[i].length + 1;\r\n        if (count >= start) {\r\n            for (let j = i - range; j <= i + range || end > count; j++) {\r\n                if (j < 0 || j >= lines.length)\r\n                    continue;\r\n                const line = j + 1;\r\n                res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);\r\n                const lineLength = lines[j].length;\r\n                if (j === i) {\r\n                    // push underline\r\n                    const pad = start - (count - lineLength) + 1;\r\n                    const length = Math.max(1, end > count ? lineLength - pad : end - start);\r\n                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));\r\n                }\r\n                else if (j > i) {\r\n                    if (end > count) {\r\n                        const length = Math.max(Math.min(end - count, lineLength), 1);\r\n                        res.push(`   |  ` + '^'.repeat(length));\r\n                    }\r\n                    count += lineLength + 1;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    }\r\n    return res.join('\\n');\r\n}\n\n/**\r\n * On the client we only need to offer special cases for boolean attributes that\r\n * have different names from their corresponding dom properties:\r\n * - itemscope -> N/A\r\n * - allowfullscreen -> allowFullscreen\r\n * - formnovalidate -> formNoValidate\r\n * - ismap -> isMap\r\n * - nomodule -> noModule\r\n * - novalidate -> noValidate\r\n * - readonly -> readOnly\r\n */\r\nconst specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;\r\nconst isSpecialBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs);\r\n/**\r\n * The full list is needed during SSR to produce the correct initial markup.\r\n */\r\nconst isBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs +\r\n    `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,` +\r\n    `loop,open,required,reversed,scoped,seamless,` +\r\n    `checked,muted,multiple,selected`);\r\nconst unsafeAttrCharRE = /[>/=\"'\\u0009\\u000a\\u000c\\u0020]/;\r\nconst attrValidationCache = {};\r\nfunction isSSRSafeAttrName(name) {\r\n    if (attrValidationCache.hasOwnProperty(name)) {\r\n        return attrValidationCache[name];\r\n    }\r\n    const isUnsafe = unsafeAttrCharRE.test(name);\r\n    if (isUnsafe) {\r\n        console.error(`unsafe attribute name: ${name}`);\r\n    }\r\n    return (attrValidationCache[name] = !isUnsafe);\r\n}\r\nconst propsToAttrMap = {\r\n    acceptCharset: 'accept-charset',\r\n    className: 'class',\r\n    htmlFor: 'for',\r\n    httpEquiv: 'http-equiv'\r\n};\r\n/**\r\n * CSS properties that accept plain numbers\r\n */\r\nconst isNoUnitNumericStyleProp = /*#__PURE__*/ makeMap(`animation-iteration-count,border-image-outset,border-image-slice,` +\r\n    `border-image-width,box-flex,box-flex-group,box-ordinal-group,column-count,` +\r\n    `columns,flex,flex-grow,flex-positive,flex-shrink,flex-negative,flex-order,` +\r\n    `grid-row,grid-row-end,grid-row-span,grid-row-start,grid-column,` +\r\n    `grid-column-end,grid-column-span,grid-column-start,font-weight,line-clamp,` +\r\n    `line-height,opacity,order,orphans,tab-size,widows,z-index,zoom,` +\r\n    // SVG\r\n    `fill-opacity,flood-opacity,stop-opacity,stroke-dasharray,stroke-dashoffset,` +\r\n    `stroke-miterlimit,stroke-opacity,stroke-width`);\r\n/**\r\n * Known attributes, this is used for stringification of runtime static nodes\r\n * so that we don't stringify bindings that cannot be set from HTML.\r\n * Don't also forget to allow `data-*` and `aria-*`!\r\n * Generated from https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes\r\n */\r\nconst isKnownAttr = /*#__PURE__*/ makeMap(`accept,accept-charset,accesskey,action,align,allow,alt,async,` +\r\n    `autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,` +\r\n    `border,buffered,capture,challenge,charset,checked,cite,class,code,` +\r\n    `codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,` +\r\n    `coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,` +\r\n    `disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,` +\r\n    `formaction,formenctype,formmethod,formnovalidate,formtarget,headers,` +\r\n    `height,hidden,high,href,hreflang,http-equiv,icon,id,importance,integrity,` +\r\n    `ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,` +\r\n    `manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,` +\r\n    `open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,` +\r\n    `referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,` +\r\n    `selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,` +\r\n    `start,step,style,summary,tabindex,target,title,translate,type,usemap,` +\r\n    `value,width,wrap`);\n\nfunction normalizeStyle(value) {\r\n    if (isArray(value)) {\r\n        const res = {};\r\n        for (let i = 0; i < value.length; i++) {\r\n            const item = value[i];\r\n            const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);\r\n            if (normalized) {\r\n                for (const key in normalized) {\r\n                    res[key] = normalized[key];\r\n                }\r\n            }\r\n        }\r\n        return res;\r\n    }\r\n    else if (isObject(value)) {\r\n        return value;\r\n    }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:(.+)/;\r\nfunction parseStringStyle(cssText) {\r\n    const ret = {};\r\n    cssText.split(listDelimiterRE).forEach(item => {\r\n        if (item) {\r\n            const tmp = item.split(propertyDelimiterRE);\r\n            tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n        }\r\n    });\r\n    return ret;\r\n}\r\nfunction stringifyStyle(styles) {\r\n    let ret = '';\r\n    if (!styles) {\r\n        return ret;\r\n    }\r\n    for (const key in styles) {\r\n        const value = styles[key];\r\n        const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);\r\n        if (isString(value) ||\r\n            (typeof value === 'number' && isNoUnitNumericStyleProp(normalizedKey))) {\r\n            // only render valid values\r\n            ret += `${normalizedKey}:${value};`;\r\n        }\r\n    }\r\n    return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n    let res = '';\r\n    if (isString(value)) {\r\n        res = value;\r\n    }\r\n    else if (isArray(value)) {\r\n        for (let i = 0; i < value.length; i++) {\r\n            res += normalizeClass(value[i]) + ' ';\r\n        }\r\n    }\r\n    else if (isObject(value)) {\r\n        for (const name in value) {\r\n            if (value[name]) {\r\n                res += name + ' ';\r\n            }\r\n        }\r\n    }\r\n    return res.trim();\r\n}\n\n// These tag configs are shared between compiler-dom and runtime-dom, so they\r\n// https://developer.mozilla.org/en-US/docs/Web/HTML/Element\r\nconst HTML_TAGS = 'html,body,base,head,link,meta,style,title,address,article,aside,footer,' +\r\n    'header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,' +\r\n    'figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,' +\r\n    'data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,' +\r\n    'time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,' +\r\n    'canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,' +\r\n    'th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,' +\r\n    'option,output,progress,select,textarea,details,dialog,menu,' +\r\n    'summary,content,template,blockquote,iframe,tfoot';\r\n// https://developer.mozilla.org/en-US/docs/Web/SVG/Element\r\nconst SVG_TAGS = 'svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,' +\r\n    'defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,' +\r\n    'feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,' +\r\n    'feDistanceLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,' +\r\n    'feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,' +\r\n    'fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,' +\r\n    'foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,' +\r\n    'mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,' +\r\n    'polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,' +\r\n    'text,textPath,title,tspan,unknown,use,view';\r\nconst VOID_TAGS = 'area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr';\r\nconst isHTMLTag = /*#__PURE__*/ makeMap(HTML_TAGS);\r\nconst isSVGTag = /*#__PURE__*/ makeMap(SVG_TAGS);\r\nconst isVoidTag = /*#__PURE__*/ makeMap(VOID_TAGS);\n\nconst escapeRE = /[\"'&<>]/;\r\nfunction escapeHtml(string) {\r\n    const str = '' + string;\r\n    const match = escapeRE.exec(str);\r\n    if (!match) {\r\n        return str;\r\n    }\r\n    let html = '';\r\n    let escaped;\r\n    let index;\r\n    let lastIndex = 0;\r\n    for (index = match.index; index < str.length; index++) {\r\n        switch (str.charCodeAt(index)) {\r\n            case 34: // \"\r\n                escaped = '&quot;';\r\n                break;\r\n            case 38: // &\r\n                escaped = '&amp;';\r\n                break;\r\n            case 39: // '\r\n                escaped = '&#39;';\r\n                break;\r\n            case 60: // <\r\n                escaped = '&lt;';\r\n                break;\r\n            case 62: // >\r\n                escaped = '&gt;';\r\n                break;\r\n            default:\r\n                continue;\r\n        }\r\n        if (lastIndex !== index) {\r\n            html += str.substring(lastIndex, index);\r\n        }\r\n        lastIndex = index + 1;\r\n        html += escaped;\r\n    }\r\n    return lastIndex !== index ? html + str.substring(lastIndex, index) : html;\r\n}\r\n// https://www.w3.org/TR/html52/syntax.html#comments\r\nconst commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;\r\nfunction escapeHtmlComment(src) {\r\n    return src.replace(commentStripRE, '');\r\n}\n\nfunction looseCompareArrays(a, b) {\r\n    if (a.length !== b.length)\r\n        return false;\r\n    let equal = true;\r\n    for (let i = 0; equal && i < a.length; i++) {\r\n        equal = looseEqual(a[i], b[i]);\r\n    }\r\n    return equal;\r\n}\r\nfunction looseEqual(a, b) {\r\n    if (a === b)\r\n        return true;\r\n    let aValidType = isDate(a);\r\n    let bValidType = isDate(b);\r\n    if (aValidType || bValidType) {\r\n        return aValidType && bValidType ? a.getTime() === b.getTime() : false;\r\n    }\r\n    aValidType = isArray(a);\r\n    bValidType = isArray(b);\r\n    if (aValidType || bValidType) {\r\n        return aValidType && bValidType ? looseCompareArrays(a, b) : false;\r\n    }\r\n    aValidType = isObject(a);\r\n    bValidType = isObject(b);\r\n    if (aValidType || bValidType) {\r\n        /* istanbul ignore if: this if will probably never be called */\r\n        if (!aValidType || !bValidType) {\r\n            return false;\r\n        }\r\n        const aKeysCount = Object.keys(a).length;\r\n        const bKeysCount = Object.keys(b).length;\r\n        if (aKeysCount !== bKeysCount) {\r\n            return false;\r\n        }\r\n        for (const key in a) {\r\n            const aHasKey = a.hasOwnProperty(key);\r\n            const bHasKey = b.hasOwnProperty(key);\r\n            if ((aHasKey && !bHasKey) ||\r\n                (!aHasKey && bHasKey) ||\r\n                !looseEqual(a[key], b[key])) {\r\n                return false;\r\n            }\r\n        }\r\n    }\r\n    return String(a) === String(b);\r\n}\r\nfunction looseIndexOf(arr, val) {\r\n    return arr.findIndex(item => looseEqual(item, val));\r\n}\n\n/**\r\n * For converting {{ interpolation }} values to displayed strings.\r\n * @private\r\n */\r\nconst toDisplayString = (val) => {\r\n    return val == null\r\n        ? ''\r\n        : isObject(val)\r\n            ? JSON.stringify(val, replacer, 2)\r\n            : String(val);\r\n};\r\nconst replacer = (_key, val) => {\r\n    if (val instanceof Map) {\r\n        return {\r\n            [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val]) => {\r\n                entries[`${key} =>`] = val;\r\n                return entries;\r\n            }, {})\r\n        };\r\n    }\r\n    else if (val instanceof Set) {\r\n        return {\r\n            [`Set(${val.size})`]: [...val.values()]\r\n        };\r\n    }\r\n    else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {\r\n        return String(val);\r\n    }\r\n    return val;\r\n};\n\n/**\r\n * List of @babel/parser plugins that are used for template expression\r\n * transforms and SFC script transforms. By default we enable proposals slated\r\n * for ES2020. This will need to be updated as the spec moves forward.\r\n * Full list at https://babeljs.io/docs/en/next/babel-parser#plugins\r\n */\r\nconst babelParserDefautPlugins = [\r\n    'bigInt',\r\n    'optionalChaining',\r\n    'nullishCoalescingOperator'\r\n];\r\nconst EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n    ? Object.freeze({})\r\n    : {};\r\nconst EMPTY_ARR = [];\r\nconst NOOP = () => { };\r\n/**\r\n * Always return false.\r\n */\r\nconst NO = () => false;\r\nconst onRE = /^on[^a-z]/;\r\nconst isOn = (key) => onRE.test(key);\r\nconst isModelListener = (key) => key.startsWith('onUpdate:');\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n    const i = arr.indexOf(el);\r\n    if (i > -1) {\r\n        arr.splice(i, 1);\r\n    }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isDate = (val) => val instanceof Date;\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n    return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n    return toTypeString(value).slice(8, -1);\r\n};\r\nconst isPlainObject = (val) => toTypeString(val) === '[object Object]';\r\nconst isReservedProp = /*#__PURE__*/ makeMap('key,ref,' +\r\n    'onVnodeBeforeMount,onVnodeMounted,' +\r\n    'onVnodeBeforeUpdate,onVnodeUpdated,' +\r\n    'onVnodeBeforeUnmount,onVnodeUnmounted');\r\nconst cacheStringFunction = (fn) => {\r\n    const cache = Object.create(null);\r\n    return ((str) => {\r\n        const hit = cache[str];\r\n        return hit || (cache[str] = fn(str));\r\n    });\r\n};\r\nconst camelizeRE = /-(\\w)/g;\r\n/**\r\n * @private\r\n */\r\nconst camelize = cacheStringFunction((str) => {\r\n    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));\r\n});\r\nconst hyphenateRE = /\\B([A-Z])/g;\r\n/**\r\n * @private\r\n */\r\nconst hyphenate = cacheStringFunction((str) => {\r\n    return str.replace(hyphenateRE, '-$1').toLowerCase();\r\n});\r\n/**\r\n * @private\r\n */\r\nconst capitalize = cacheStringFunction((str) => {\r\n    return str.charAt(0).toUpperCase() + str.slice(1);\r\n});\r\n// compare whether a value has changed, accounting for NaN.\r\nconst hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);\r\nconst invokeArrayFns = (fns, arg) => {\r\n    for (let i = 0; i < fns.length; i++) {\r\n        fns[i](arg);\r\n    }\r\n};\r\nconst def = (obj, key, value) => {\r\n    Object.defineProperty(obj, key, {\r\n        configurable: true,\r\n        enumerable: false,\r\n        value\r\n    });\r\n};\r\nconst toNumber = (val) => {\r\n    const n = parseFloat(val);\r\n    return isNaN(n) ? val : n;\r\n};\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n    return (_globalThis ||\r\n        (_globalThis =\r\n            typeof globalThis !== 'undefined'\r\n                ? globalThis\r\n                : typeof self !== 'undefined'\r\n                    ? self\r\n                    : typeof window !== 'undefined'\r\n                        ? window\r\n                        : typeof global !== 'undefined'\r\n                            ? global\r\n                            : {}));\r\n};\n\nexport { EMPTY_ARR, EMPTY_OBJ, NO, NOOP, PatchFlagNames, babelParserDefautPlugins, camelize, capitalize, def, escapeHtml, escapeHtmlComment, extend, generateCodeFrame, getGlobalThis, hasChanged, hasOwn, hyphenate, invokeArrayFns, isArray, isBooleanAttr, isDate, isFunction, isGloballyWhitelisted, isHTMLTag, isKnownAttr, isModelListener, isNoUnitNumericStyleProp, isObject, isOn, isPlainObject, isPromise, isReservedProp, isSSRSafeAttrName, isSVGTag, isSpecialBooleanAttr, isString, isSymbol, isVoidTag, looseEqual, looseIndexOf, makeMap, normalizeClass, normalizeStyle, objectToString, parseStringStyle, propsToAttrMap, remove, stringifyStyle, toDisplayString, toNumber, toRawType, toTypeString };\n","import { EMPTY_OBJ, isArray, isSymbol, extend, hasOwn, isObject, hasChanged, capitalize, toRawType, def, makeMap, isFunction, NOOP } from '@vue/shared';\n\nconst targetMap = new WeakMap();\r\nconst effectStack = [];\r\nlet activeEffect;\r\nconst ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');\r\nconst MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');\r\nfunction isEffect(fn) {\r\n    return fn && fn._isEffect === true;\r\n}\r\nfunction effect(fn, options = EMPTY_OBJ) {\r\n    if (isEffect(fn)) {\r\n        fn = fn.raw;\r\n    }\r\n    const effect = createReactiveEffect(fn, options);\r\n    if (!options.lazy) {\r\n        effect();\r\n    }\r\n    return effect;\r\n}\r\nfunction stop(effect) {\r\n    if (effect.active) {\r\n        cleanup(effect);\r\n        if (effect.options.onStop) {\r\n            effect.options.onStop();\r\n        }\r\n        effect.active = false;\r\n    }\r\n}\r\nlet uid = 0;\r\nfunction createReactiveEffect(fn, options) {\r\n    const effect = function reactiveEffect() {\r\n        if (!effect.active) {\r\n            return options.scheduler ? undefined : fn();\r\n        }\r\n        if (!effectStack.includes(effect)) {\r\n            cleanup(effect);\r\n            try {\r\n                enableTracking();\r\n                effectStack.push(effect);\r\n                activeEffect = effect;\r\n                return fn();\r\n            }\r\n            finally {\r\n                effectStack.pop();\r\n                resetTracking();\r\n                activeEffect = effectStack[effectStack.length - 1];\r\n            }\r\n        }\r\n    };\r\n    effect.id = uid++;\r\n    effect._isEffect = true;\r\n    effect.active = true;\r\n    effect.raw = fn;\r\n    effect.deps = [];\r\n    effect.options = options;\r\n    return effect;\r\n}\r\nfunction cleanup(effect) {\r\n    const { deps } = effect;\r\n    if (deps.length) {\r\n        for (let i = 0; i < deps.length; i++) {\r\n            deps[i].delete(effect);\r\n        }\r\n        deps.length = 0;\r\n    }\r\n}\r\nlet shouldTrack = true;\r\nconst trackStack = [];\r\nfunction pauseTracking() {\r\n    trackStack.push(shouldTrack);\r\n    shouldTrack = false;\r\n}\r\nfunction enableTracking() {\r\n    trackStack.push(shouldTrack);\r\n    shouldTrack = true;\r\n}\r\nfunction resetTracking() {\r\n    const last = trackStack.pop();\r\n    shouldTrack = last === undefined ? true : last;\r\n}\r\nfunction track(target, type, key) {\r\n    if (!shouldTrack || activeEffect === undefined) {\r\n        return;\r\n    }\r\n    let depsMap = targetMap.get(target);\r\n    if (!depsMap) {\r\n        targetMap.set(target, (depsMap = new Map()));\r\n    }\r\n    let dep = depsMap.get(key);\r\n    if (!dep) {\r\n        depsMap.set(key, (dep = new Set()));\r\n    }\r\n    if (!dep.has(activeEffect)) {\r\n        dep.add(activeEffect);\r\n        activeEffect.deps.push(dep);\r\n        if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) {\r\n            activeEffect.options.onTrack({\r\n                effect: activeEffect,\r\n                target,\r\n                type,\r\n                key\r\n            });\r\n        }\r\n    }\r\n}\r\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\r\n    const depsMap = targetMap.get(target);\r\n    if (!depsMap) {\r\n        // never been tracked\r\n        return;\r\n    }\r\n    const effects = new Set();\r\n    const add = (effectsToAdd) => {\r\n        if (effectsToAdd) {\r\n            effectsToAdd.forEach(effect => effects.add(effect));\r\n        }\r\n    };\r\n    if (type === \"clear\" /* CLEAR */) {\r\n        // collection being cleared\r\n        // trigger all effects for target\r\n        depsMap.forEach(add);\r\n    }\r\n    else if (key === 'length' && isArray(target)) {\r\n        depsMap.forEach((dep, key) => {\r\n            if (key === 'length' || key >= newValue) {\r\n                add(dep);\r\n            }\r\n        });\r\n    }\r\n    else {\r\n        // schedule runs for SET | ADD | DELETE\r\n        if (key !== void 0) {\r\n            add(depsMap.get(key));\r\n        }\r\n        // also run for iteration key on ADD | DELETE | Map.SET\r\n        const isAddOrDelete = type === \"add\" /* ADD */ ||\r\n            (type === \"delete\" /* DELETE */ && !isArray(target));\r\n        if (isAddOrDelete ||\r\n            (type === \"set\" /* SET */ && target instanceof Map)) {\r\n            add(depsMap.get(isArray(target) ? 'length' : ITERATE_KEY));\r\n        }\r\n        if (isAddOrDelete && target instanceof Map) {\r\n            add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n        }\r\n    }\r\n    const run = (effect) => {\r\n        if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) {\r\n            effect.options.onTrigger({\r\n                effect,\r\n                target,\r\n                key,\r\n                type,\r\n                newValue,\r\n                oldValue,\r\n                oldTarget\r\n            });\r\n        }\r\n        if (effect.options.scheduler) {\r\n            effect.options.scheduler(effect);\r\n        }\r\n        else {\r\n            effect();\r\n        }\r\n    };\r\n    effects.forEach(run);\r\n}\n\nconst builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)\r\n    .map(key => Symbol[key])\r\n    .filter(isSymbol));\r\nconst get = /*#__PURE__*/ createGetter();\r\nconst shallowGet = /*#__PURE__*/ createGetter(false, true);\r\nconst readonlyGet = /*#__PURE__*/ createGetter(true);\r\nconst shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);\r\nconst arrayInstrumentations = {};\r\n['includes', 'indexOf', 'lastIndexOf'].forEach(key => {\r\n    arrayInstrumentations[key] = function (...args) {\r\n        const arr = toRaw(this);\r\n        for (let i = 0, l = this.length; i < l; i++) {\r\n            track(arr, \"get\" /* GET */, i + '');\r\n        }\r\n        // we run the method using the original args first (which may be reactive)\r\n        const res = arr[key](...args);\r\n        if (res === -1 || res === false) {\r\n            // if that didn't work, run it again using raw values.\r\n            return arr[key](...args.map(toRaw));\r\n        }\r\n        else {\r\n            return res;\r\n        }\r\n    };\r\n});\r\nfunction createGetter(isReadonly = false, shallow = false) {\r\n    return function get(target, key, receiver) {\r\n        if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n            return !isReadonly;\r\n        }\r\n        else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n            return isReadonly;\r\n        }\r\n        else if (key === \"__v_raw\" /* RAW */ &&\r\n            receiver ===\r\n                (isReadonly\r\n                    ? target[\"__v_readonly\" /* READONLY */]\r\n                    : target[\"__v_reactive\" /* REACTIVE */])) {\r\n            return target;\r\n        }\r\n        const targetIsArray = isArray(target);\r\n        if (targetIsArray && hasOwn(arrayInstrumentations, key)) {\r\n            return Reflect.get(arrayInstrumentations, key, receiver);\r\n        }\r\n        const res = Reflect.get(target, key, receiver);\r\n        if (isSymbol(key)\r\n            ? builtInSymbols.has(key)\r\n            : key === `__proto__` || key === `__v_isRef`) {\r\n            return res;\r\n        }\r\n        if (!isReadonly) {\r\n            track(target, \"get\" /* GET */, key);\r\n        }\r\n        if (shallow) {\r\n            return res;\r\n        }\r\n        if (isRef(res)) {\r\n            // ref unwrapping, only for Objects, not for Arrays.\r\n            return targetIsArray ? res : res.value;\r\n        }\r\n        if (isObject(res)) {\r\n            // Convert returned value into a proxy as well. we do the isObject check\r\n            // here to avoid invalid value warning. Also need to lazy access readonly\r\n            // and reactive here to avoid circular dependency.\r\n            return isReadonly ? readonly(res) : reactive(res);\r\n        }\r\n        return res;\r\n    };\r\n}\r\nconst set = /*#__PURE__*/ createSetter();\r\nconst shallowSet = /*#__PURE__*/ createSetter(true);\r\nfunction createSetter(shallow = false) {\r\n    return function set(target, key, value, receiver) {\r\n        const oldValue = target[key];\r\n        if (!shallow) {\r\n            value = toRaw(value);\r\n            if (!isArray(target) && isRef(oldValue) && !isRef(value)) {\r\n                oldValue.value = value;\r\n                return true;\r\n            }\r\n        }\r\n        const hadKey = hasOwn(target, key);\r\n        const result = Reflect.set(target, key, value, receiver);\r\n        // don't trigger if target is something up in the prototype chain of original\r\n        if (target === toRaw(receiver)) {\r\n            if (!hadKey) {\r\n                trigger(target, \"add\" /* ADD */, key, value);\r\n            }\r\n            else if (hasChanged(value, oldValue)) {\r\n                trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n            }\r\n        }\r\n        return result;\r\n    };\r\n}\r\nfunction deleteProperty(target, key) {\r\n    const hadKey = hasOwn(target, key);\r\n    const oldValue = target[key];\r\n    const result = Reflect.deleteProperty(target, key);\r\n    if (result && hadKey) {\r\n        trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n    }\r\n    return result;\r\n}\r\nfunction has(target, key) {\r\n    const result = Reflect.has(target, key);\r\n    if (!isSymbol(key) || !builtInSymbols.has(key)) {\r\n        track(target, \"has\" /* HAS */, key);\r\n    }\r\n    return result;\r\n}\r\nfunction ownKeys(target) {\r\n    track(target, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n    return Reflect.ownKeys(target);\r\n}\r\nconst mutableHandlers = {\r\n    get,\r\n    set,\r\n    deleteProperty,\r\n    has,\r\n    ownKeys\r\n};\r\nconst readonlyHandlers = {\r\n    get: readonlyGet,\r\n    has,\r\n    ownKeys,\r\n    set(target, key) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            console.warn(`Set operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n        }\r\n        return true;\r\n    },\r\n    deleteProperty(target, key) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            console.warn(`Delete operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n        }\r\n        return true;\r\n    }\r\n};\r\nconst shallowReactiveHandlers = extend({}, mutableHandlers, {\r\n    get: shallowGet,\r\n    set: shallowSet\r\n});\r\n// Props handlers are special in the sense that it should not unwrap top-level\r\n// refs (in order to allow refs to be explicitly passed down), but should\r\n// retain the reactivity of the normal readonly object.\r\nconst shallowReadonlyHandlers = extend({}, readonlyHandlers, {\r\n    get: shallowReadonlyGet\r\n});\n\nconst toReactive = (value) => isObject(value) ? reactive(value) : value;\r\nconst toReadonly = (value) => isObject(value) ? readonly(value) : value;\r\nconst toShallow = (value) => value;\r\nconst getProto = (v) => Reflect.getPrototypeOf(v);\r\nfunction get$1(target, key, wrap) {\r\n    target = toRaw(target);\r\n    const rawKey = toRaw(key);\r\n    if (key !== rawKey) {\r\n        track(target, \"get\" /* GET */, key);\r\n    }\r\n    track(target, \"get\" /* GET */, rawKey);\r\n    const { has, get } = getProto(target);\r\n    if (has.call(target, key)) {\r\n        return wrap(get.call(target, key));\r\n    }\r\n    else if (has.call(target, rawKey)) {\r\n        return wrap(get.call(target, rawKey));\r\n    }\r\n}\r\nfunction has$1(key) {\r\n    const target = toRaw(this);\r\n    const rawKey = toRaw(key);\r\n    if (key !== rawKey) {\r\n        track(target, \"has\" /* HAS */, key);\r\n    }\r\n    track(target, \"has\" /* HAS */, rawKey);\r\n    const has = getProto(target).has;\r\n    return has.call(target, key) || has.call(target, rawKey);\r\n}\r\nfunction size(target) {\r\n    target = toRaw(target);\r\n    track(target, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n    return Reflect.get(getProto(target), 'size', target);\r\n}\r\nfunction add(value) {\r\n    value = toRaw(value);\r\n    const target = toRaw(this);\r\n    const proto = getProto(target);\r\n    const hadKey = proto.has.call(target, value);\r\n    const result = proto.add.call(target, value);\r\n    if (!hadKey) {\r\n        trigger(target, \"add\" /* ADD */, value, value);\r\n    }\r\n    return result;\r\n}\r\nfunction set$1(key, value) {\r\n    value = toRaw(value);\r\n    const target = toRaw(this);\r\n    const { has, get, set } = getProto(target);\r\n    let hadKey = has.call(target, key);\r\n    if (!hadKey) {\r\n        key = toRaw(key);\r\n        hadKey = has.call(target, key);\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        checkIdentityKeys(target, has, key);\r\n    }\r\n    const oldValue = get.call(target, key);\r\n    const result = set.call(target, key, value);\r\n    if (!hadKey) {\r\n        trigger(target, \"add\" /* ADD */, key, value);\r\n    }\r\n    else if (hasChanged(value, oldValue)) {\r\n        trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n    }\r\n    return result;\r\n}\r\nfunction deleteEntry(key) {\r\n    const target = toRaw(this);\r\n    const { has, get, delete: del } = getProto(target);\r\n    let hadKey = has.call(target, key);\r\n    if (!hadKey) {\r\n        key = toRaw(key);\r\n        hadKey = has.call(target, key);\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        checkIdentityKeys(target, has, key);\r\n    }\r\n    const oldValue = get ? get.call(target, key) : undefined;\r\n    // forward the operation before queueing reactions\r\n    const result = del.call(target, key);\r\n    if (hadKey) {\r\n        trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n    }\r\n    return result;\r\n}\r\nfunction clear() {\r\n    const target = toRaw(this);\r\n    const hadItems = target.size !== 0;\r\n    const oldTarget = (process.env.NODE_ENV !== 'production')\r\n        ? target instanceof Map\r\n            ? new Map(target)\r\n            : new Set(target)\r\n        : undefined;\r\n    // forward the operation before queueing reactions\r\n    const result = getProto(target).clear.call(target);\r\n    if (hadItems) {\r\n        trigger(target, \"clear\" /* CLEAR */, undefined, undefined, oldTarget);\r\n    }\r\n    return result;\r\n}\r\nfunction createForEach(isReadonly, shallow) {\r\n    return function forEach(callback, thisArg) {\r\n        const observed = this;\r\n        const target = toRaw(observed);\r\n        const wrap = isReadonly ? toReadonly : shallow ? toShallow : toReactive;\r\n        !isReadonly && track(target, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n        // important: create sure the callback is\r\n        // 1. invoked with the reactive map as `this` and 3rd arg\r\n        // 2. the value received should be a corresponding reactive/readonly.\r\n        function wrappedCallback(value, key) {\r\n            return callback.call(thisArg, wrap(value), wrap(key), observed);\r\n        }\r\n        return getProto(target).forEach.call(target, wrappedCallback);\r\n    };\r\n}\r\nfunction createIterableMethod(method, isReadonly, shallow) {\r\n    return function (...args) {\r\n        const target = toRaw(this);\r\n        const isMap = target instanceof Map;\r\n        const isPair = method === 'entries' || (method === Symbol.iterator && isMap);\r\n        const isKeyOnly = method === 'keys' && isMap;\r\n        const innerIterator = getProto(target)[method].apply(target, args);\r\n        const wrap = isReadonly ? toReadonly : shallow ? toShallow : toReactive;\r\n        !isReadonly &&\r\n            track(target, \"iterate\" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);\r\n        // return a wrapped iterator which returns observed versions of the\r\n        // values emitted from the real iterator\r\n        return {\r\n            // iterator protocol\r\n            next() {\r\n                const { value, done } = innerIterator.next();\r\n                return done\r\n                    ? { value, done }\r\n                    : {\r\n                        value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\r\n                        done\r\n                    };\r\n            },\r\n            // iterable protocol\r\n            [Symbol.iterator]() {\r\n                return this;\r\n            }\r\n        };\r\n    };\r\n}\r\nfunction createReadonlyMethod(type) {\r\n    return function (...args) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            const key = args[0] ? `on key \"${args[0]}\" ` : ``;\r\n            console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));\r\n        }\r\n        return type === \"delete\" /* DELETE */ ? false : this;\r\n    };\r\n}\r\nconst mutableInstrumentations = {\r\n    get(key) {\r\n        return get$1(this, key, toReactive);\r\n    },\r\n    get size() {\r\n        return size(this);\r\n    },\r\n    has: has$1,\r\n    add,\r\n    set: set$1,\r\n    delete: deleteEntry,\r\n    clear,\r\n    forEach: createForEach(false, false)\r\n};\r\nconst shallowInstrumentations = {\r\n    get(key) {\r\n        return get$1(this, key, toShallow);\r\n    },\r\n    get size() {\r\n        return size(this);\r\n    },\r\n    has: has$1,\r\n    add,\r\n    set: set$1,\r\n    delete: deleteEntry,\r\n    clear,\r\n    forEach: createForEach(false, true)\r\n};\r\nconst readonlyInstrumentations = {\r\n    get(key) {\r\n        return get$1(this, key, toReadonly);\r\n    },\r\n    get size() {\r\n        return size(this);\r\n    },\r\n    has: has$1,\r\n    add: createReadonlyMethod(\"add\" /* ADD */),\r\n    set: createReadonlyMethod(\"set\" /* SET */),\r\n    delete: createReadonlyMethod(\"delete\" /* DELETE */),\r\n    clear: createReadonlyMethod(\"clear\" /* CLEAR */),\r\n    forEach: createForEach(true, false)\r\n};\r\nconst iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];\r\niteratorMethods.forEach(method => {\r\n    mutableInstrumentations[method] = createIterableMethod(method, false, false);\r\n    readonlyInstrumentations[method] = createIterableMethod(method, true, false);\r\n    shallowInstrumentations[method] = createIterableMethod(method, false, true);\r\n});\r\nfunction createInstrumentationGetter(isReadonly, shallow) {\r\n    const instrumentations = shallow\r\n        ? shallowInstrumentations\r\n        : isReadonly\r\n            ? readonlyInstrumentations\r\n            : mutableInstrumentations;\r\n    return (target, key, receiver) => {\r\n        if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n            return !isReadonly;\r\n        }\r\n        else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n            return isReadonly;\r\n        }\r\n        else if (key === \"__v_raw\" /* RAW */) {\r\n            return target;\r\n        }\r\n        return Reflect.get(hasOwn(instrumentations, key) && key in target\r\n            ? instrumentations\r\n            : target, key, receiver);\r\n    };\r\n}\r\nconst mutableCollectionHandlers = {\r\n    get: createInstrumentationGetter(false, false)\r\n};\r\nconst shallowCollectionHandlers = {\r\n    get: createInstrumentationGetter(false, true)\r\n};\r\nconst readonlyCollectionHandlers = {\r\n    get: createInstrumentationGetter(true, false)\r\n};\r\nfunction checkIdentityKeys(target, has, key) {\r\n    const rawKey = toRaw(key);\r\n    if (rawKey !== key && has.call(target, rawKey)) {\r\n        const type = toRawType(target);\r\n        console.warn(`Reactive ${type} contains both the raw and reactive ` +\r\n            `versions of the same object${type === `Map` ? `as keys` : ``}, ` +\r\n            `which can lead to inconsistencies. ` +\r\n            `Avoid differentiating between the raw and reactive versions ` +\r\n            `of an object and only use the reactive version if possible.`);\r\n    }\r\n}\n\nconst collectionTypes = new Set([Set, Map, WeakMap, WeakSet]);\r\nconst isObservableType = /*#__PURE__*/ makeMap('Object,Array,Map,Set,WeakMap,WeakSet');\r\nconst canObserve = (value) => {\r\n    return (!value[\"__v_skip\" /* SKIP */] &&\r\n        isObservableType(toRawType(value)) &&\r\n        !Object.isFrozen(value));\r\n};\r\nfunction reactive(target) {\r\n    // if trying to observe a readonly proxy, return the readonly version.\r\n    if (target && target[\"__v_isReadonly\" /* IS_READONLY */]) {\r\n        return target;\r\n    }\r\n    return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);\r\n}\r\n// Return a reactive-copy of the original object, where only the root level\r\n// properties are reactive, and does NOT unwrap refs nor recursively convert\r\n// returned properties.\r\nfunction shallowReactive(target) {\r\n    return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers);\r\n}\r\nfunction readonly(target) {\r\n    return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);\r\n}\r\n// Return a reactive-copy of the original object, where only the root level\r\n// properties are readonly, and does NOT unwrap refs nor recursively convert\r\n// returned properties.\r\n// This is used for creating the props proxy object for stateful components.\r\nfunction shallowReadonly(target) {\r\n    return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);\r\n}\r\nfunction createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {\r\n    if (!isObject(target)) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            console.warn(`value cannot be made reactive: ${String(target)}`);\r\n        }\r\n        return target;\r\n    }\r\n    // target is already a Proxy, return it.\r\n    // exception: calling readonly() on a reactive object\r\n    if (target[\"__v_raw\" /* RAW */] &&\r\n        !(isReadonly && target[\"__v_isReactive\" /* IS_REACTIVE */])) {\r\n        return target;\r\n    }\r\n    // target already has corresponding Proxy\r\n    const reactiveFlag = isReadonly\r\n        ? \"__v_readonly\" /* READONLY */\r\n        : \"__v_reactive\" /* REACTIVE */;\r\n    if (hasOwn(target, reactiveFlag)) {\r\n        return target[reactiveFlag];\r\n    }\r\n    // only a whitelist of value types can be observed.\r\n    if (!canObserve(target)) {\r\n        return target;\r\n    }\r\n    const observed = new Proxy(target, collectionTypes.has(target.constructor) ? collectionHandlers : baseHandlers);\r\n    def(target, reactiveFlag, observed);\r\n    return observed;\r\n}\r\nfunction isReactive(value) {\r\n    if (isReadonly(value)) {\r\n        return isReactive(value[\"__v_raw\" /* RAW */]);\r\n    }\r\n    return !!(value && value[\"__v_isReactive\" /* IS_REACTIVE */]);\r\n}\r\nfunction isReadonly(value) {\r\n    return !!(value && value[\"__v_isReadonly\" /* IS_READONLY */]);\r\n}\r\nfunction isProxy(value) {\r\n    return isReactive(value) || isReadonly(value);\r\n}\r\nfunction toRaw(observed) {\r\n    return ((observed && toRaw(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\r\nfunction markRaw(value) {\r\n    def(value, \"__v_skip\" /* SKIP */, true);\r\n    return value;\r\n}\n\nconst convert = (val) => isObject(val) ? reactive(val) : val;\r\nfunction isRef(r) {\r\n    return r ? r.__v_isRef === true : false;\r\n}\r\nfunction ref(value) {\r\n    return createRef(value);\r\n}\r\nfunction shallowRef(value) {\r\n    return createRef(value, true);\r\n}\r\nfunction createRef(rawValue, shallow = false) {\r\n    if (isRef(rawValue)) {\r\n        return rawValue;\r\n    }\r\n    let value = shallow ? rawValue : convert(rawValue);\r\n    const r = {\r\n        __v_isRef: true,\r\n        get value() {\r\n            track(r, \"get\" /* GET */, 'value');\r\n            return value;\r\n        },\r\n        set value(newVal) {\r\n            if (hasChanged(toRaw(newVal), rawValue)) {\r\n                rawValue = newVal;\r\n                value = shallow ? newVal : convert(newVal);\r\n                trigger(r, \"set\" /* SET */, 'value', newVal);\r\n            }\r\n        }\r\n    };\r\n    return r;\r\n}\r\nfunction triggerRef(ref) {\r\n    trigger(ref, \"set\" /* SET */, 'value', (process.env.NODE_ENV !== 'production') ? ref.value : void 0);\r\n}\r\nfunction unref(ref) {\r\n    return isRef(ref) ? ref.value : ref;\r\n}\r\nconst shallowUnwrapHandlers = {\r\n    get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),\r\n    set: (target, key, value, receiver) => {\r\n        const oldValue = target[key];\r\n        if (isRef(oldValue) && !isRef(value)) {\r\n            oldValue.value = value;\r\n            return true;\r\n        }\r\n        else {\r\n            return Reflect.set(target, key, value, receiver);\r\n        }\r\n    }\r\n};\r\nfunction proxyRefs(objectWithRefs) {\r\n    return isReactive(objectWithRefs)\r\n        ? objectWithRefs\r\n        : new Proxy(objectWithRefs, shallowUnwrapHandlers);\r\n}\r\nfunction customRef(factory) {\r\n    const { get, set } = factory(() => track(r, \"get\" /* GET */, 'value'), () => trigger(r, \"set\" /* SET */, 'value'));\r\n    const r = {\r\n        __v_isRef: true,\r\n        get value() {\r\n            return get();\r\n        },\r\n        set value(v) {\r\n            set(v);\r\n        }\r\n    };\r\n    return r;\r\n}\r\nfunction toRefs(object) {\r\n    if ((process.env.NODE_ENV !== 'production') && !isProxy(object)) {\r\n        console.warn(`toRefs() expects a reactive object but received a plain one.`);\r\n    }\r\n    const ret = {};\r\n    for (const key in object) {\r\n        ret[key] = toRef(object, key);\r\n    }\r\n    return ret;\r\n}\r\nfunction toRef(object, key) {\r\n    return {\r\n        __v_isRef: true,\r\n        get value() {\r\n            return object[key];\r\n        },\r\n        set value(newVal) {\r\n            object[key] = newVal;\r\n        }\r\n    };\r\n}\n\nfunction computed(getterOrOptions) {\r\n    let getter;\r\n    let setter;\r\n    if (isFunction(getterOrOptions)) {\r\n        getter = getterOrOptions;\r\n        setter = (process.env.NODE_ENV !== 'production')\r\n            ? () => {\r\n                console.warn('Write operation failed: computed value is readonly');\r\n            }\r\n            : NOOP;\r\n    }\r\n    else {\r\n        getter = getterOrOptions.get;\r\n        setter = getterOrOptions.set;\r\n    }\r\n    let dirty = true;\r\n    let value;\r\n    let computed;\r\n    const runner = effect(getter, {\r\n        lazy: true,\r\n        scheduler: () => {\r\n            if (!dirty) {\r\n                dirty = true;\r\n                trigger(computed, \"set\" /* SET */, 'value');\r\n            }\r\n        }\r\n    });\r\n    computed = {\r\n        __v_isRef: true,\r\n        [\"__v_isReadonly\" /* IS_READONLY */]: isFunction(getterOrOptions) || !getterOrOptions.set,\r\n        // expose effect so computed can be stopped\r\n        effect: runner,\r\n        get value() {\r\n            if (dirty) {\r\n                value = runner();\r\n                dirty = false;\r\n            }\r\n            track(computed, \"get\" /* GET */, 'value');\r\n            return value;\r\n        },\r\n        set value(newValue) {\r\n            setter(newValue);\r\n        }\r\n    };\r\n    return computed;\r\n}\n\nexport { ITERATE_KEY, computed, customRef, effect, enableTracking, isProxy, isReactive, isReadonly, isRef, markRaw, pauseTracking, proxyRefs, reactive, readonly, ref, resetTracking, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, track, trigger, triggerRef, unref };\n","var ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `ToInteger` abstract operation\n// https://tc39.github.io/ecma262/#sec-tointeger\nmodule.exports = function (argument) {\n  return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar NativePromise = require('../internals/native-promise-constructor');\nvar fails = require('../internals/fails');\nvar getBuiltIn = require('../internals/get-built-in');\nvar speciesConstructor = require('../internals/species-constructor');\nvar promiseResolve = require('../internals/promise-resolve');\nvar redefine = require('../internals/redefine');\n\n// Safari bug https://bugs.webkit.org/show_bug.cgi?id=200829\nvar NON_GENERIC = !!NativePromise && fails(function () {\n  NativePromise.prototype['finally'].call({ then: function () { /* empty */ } }, function () { /* empty */ });\n});\n\n// `Promise.prototype.finally` method\n// https://tc39.github.io/ecma262/#sec-promise.prototype.finally\n$({ target: 'Promise', proto: true, real: true, forced: NON_GENERIC }, {\n  'finally': function (onFinally) {\n    var C = speciesConstructor(this, getBuiltIn('Promise'));\n    var isFunction = typeof onFinally == 'function';\n    return this.then(\n      isFunction ? function (x) {\n        return promiseResolve(C, onFinally()).then(function () { return x; });\n      } : onFinally,\n      isFunction ? function (e) {\n        return promiseResolve(C, onFinally()).then(function () { throw e; });\n      } : onFinally\n    );\n  }\n});\n\n// patch native Promise.prototype for native async functions\nif (!IS_PURE && typeof NativePromise == 'function' && !NativePromise.prototype['finally']) {\n  redefine(NativePromise.prototype, 'finally', getBuiltIn('Promise').prototype['finally']);\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","'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","var DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar has = require('../internals/has');\n\nvar defineProperty = Object.defineProperty;\nvar cache = {};\n\nvar thrower = function (it) { throw it; };\n\nmodule.exports = function (METHOD_NAME, options) {\n  if (has(cache, METHOD_NAME)) return cache[METHOD_NAME];\n  if (!options) options = {};\n  var method = [][METHOD_NAME];\n  var ACCESSORS = has(options, 'ACCESSORS') ? options.ACCESSORS : false;\n  var argument0 = has(options, 0) ? options[0] : thrower;\n  var argument1 = has(options, 1) ? options[1] : undefined;\n\n  return cache[METHOD_NAME] = !!method && !fails(function () {\n    if (ACCESSORS && !DESCRIPTORS) return true;\n    var O = { length: -1 };\n\n    if (ACCESSORS) defineProperty(O, 1, { enumerable: true, get: thrower });\n    else O[1] = 1;\n\n    method.call(O, argument0, argument1);\n  });\n};\n","'use strict';\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar has = require('../internals/has');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar BUGGY_SAFARI_ITERATORS = false;\n\nvar returnThis = function () { return this; };\n\n// `%IteratorPrototype%` object\n// https://tc39.github.io/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\nif ([].keys) {\n  arrayIterator = [].keys();\n  // Safari 8 has buggy iterators w/o `next`\n  if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;\n  else {\n    PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));\n    if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;\n  }\n}\n\nif (IteratorPrototype == undefined) IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\nif (!IS_PURE && !has(IteratorPrototype, ITERATOR)) {\n  createNonEnumerableProperty(IteratorPrototype, ITERATOR, returnThis);\n}\n\nmodule.exports = {\n  IteratorPrototype: IteratorPrototype,\n  BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","var global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar classof = require('../internals/classof-raw');\nvar macrotask = require('../internals/task').set;\nvar IS_IOS = require('../internals/engine-is-ios');\n\nvar MutationObserver = global.MutationObserver || global.WebKitMutationObserver;\nvar process = global.process;\nvar Promise = global.Promise;\nvar IS_NODE = classof(process) == 'process';\n// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`\nvar queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');\nvar queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;\n\nvar flush, head, last, notify, toggle, node, promise, then;\n\n// modern engines have queueMicrotask method\nif (!queueMicrotask) {\n  flush = function () {\n    var parent, fn;\n    if (IS_NODE && (parent = process.domain)) parent.exit();\n    while (head) {\n      fn = head.fn;\n      head = head.next;\n      try {\n        fn();\n      } catch (error) {\n        if (head) notify();\n        else last = undefined;\n        throw error;\n      }\n    } last = undefined;\n    if (parent) parent.enter();\n  };\n\n  // Node.js\n  if (IS_NODE) {\n    notify = function () {\n      process.nextTick(flush);\n    };\n  // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339\n  } else if (MutationObserver && !IS_IOS) {\n    toggle = true;\n    node = document.createTextNode('');\n    new MutationObserver(flush).observe(node, { characterData: true });\n    notify = function () {\n      node.data = toggle = !toggle;\n    };\n  // environments with maybe non-completely correct, but existent Promise\n  } else if (Promise && Promise.resolve) {\n    // Promise.resolve without an argument throws an error in LG WebOS 2\n    promise = Promise.resolve(undefined);\n    then = promise.then;\n    notify = function () {\n      then.call(promise, flush);\n    };\n  // for other environments - macrotask based on:\n  // - setImmediate\n  // - MessageChannel\n  // - window.postMessag\n  // - onreadystatechange\n  // - setTimeout\n  } else {\n    notify = function () {\n      // strange IE + webpack dev server bug - use .call(global)\n      macrotask.call(global, flush);\n    };\n  }\n}\n\nmodule.exports = queueMicrotask || function (fn) {\n  var task = { fn: fn, next: undefined };\n  if (last) last.next = task;\n  if (!head) {\n    head = task;\n    notify();\n  } last = task;\n};\n","var global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar has = require('../internals/has');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar WellKnownSymbolsStore = shared('wks');\nvar Symbol = global.Symbol;\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n  if (!has(WellKnownSymbolsStore, name)) {\n    if (NATIVE_SYMBOL && has(Symbol, name)) WellKnownSymbolsStore[name] = Symbol[name];\n    else WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);\n  } return WellKnownSymbolsStore[name];\n};\n","/** @license React v16.13.1\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.13.1\";\n","var isObject = require('../internals/is-object');\n\n// `ToPrimitive` abstract operation\n// https://tc39.github.io/ecma262/#sec-toprimitive\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function (input, PREFERRED_STRING) {\n  if (!isObject(input)) return input;\n  var fn, val;\n  if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;\n  if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val;\n  if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n","module.exports = false;\n","var toString = {}.toString;\n\nmodule.exports = function (it) {\n  return toString.call(it).slice(8, -1);\n};\n","var global = require('../internals/global');\nvar setGlobal = require('../internals/set-global');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || setGlobal(SHARED, {});\n\nmodule.exports = store;\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","var has = require('../internals/has');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nmodule.exports = function (object, names) {\n  var O = toIndexedObject(object);\n  var i = 0;\n  var result = [];\n  var key;\n  for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key);\n  // Don't enum bug & hidden keys\n  while (names.length > i) if (has(O, key = names[i++])) {\n    ~indexOf(result, key) || result.push(key);\n  }\n  return result;\n};\n","var global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n  return EXISTS ? document.createElement(it) : {};\n};\n","var $ = require('../internals/export');\nvar assign = require('../internals/object-assign');\n\n// `Object.assign` method\n// https://tc39.github.io/ecma262/#sec-object.assign\n$({ target: 'Object', stat: true, forced: Object.assign !== assign }, {\n  assign: assign\n});\n","var anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar newPromiseCapability = require('../internals/new-promise-capability');\n\nmodule.exports = function (C, x) {\n  anObject(C);\n  if (isObject(x) && x.constructor === C) return x;\n  var promiseCapability = newPromiseCapability.f(C);\n  var resolve = promiseCapability.resolve;\n  resolve(x);\n  return promiseCapability.promise;\n};\n","var global = require('../internals/global');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\nmodule.exports = function (key, value) {\n  try {\n    createNonEnumerableProperty(global, key, value);\n  } catch (error) {\n    global[key] = value;\n  } return value;\n};\n","module.exports = {};\n","module.exports = function (exec) {\n  try {\n    return !!exec();\n  } catch (error) {\n    return true;\n  }\n};\n","var path = require('../internals/path');\nvar global = require('../internals/global');\n\nvar aFunction = function (variable) {\n  return typeof variable == 'function' ? variable : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n  return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace])\n    : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method];\n};\n","/**\n * @author Toru Nagashima <https://github.com/mysticatea>\n * @copyright 2015 Toru Nagashima. All rights reserved.\n * See LICENSE file in root directory for full license.\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 */\nfunction 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 */\nfunction 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 */\nfunction 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 */\nfunction 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 */\nfunction setPassiveListener(event, passiveListener) {\n    pd(event).passiveListener = passiveListener;\n}\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 default EventTarget;\nexport { defineEventAttribute, EventTarget };\n//# sourceMappingURL=event-target-shim.mjs.map\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.\nimport { toUint8Array } from './buffer';\nimport { TextDecoder as TextDecoderPolyfill, TextEncoder as TextEncoderPolyfill, } from 'text-encoding-utf-8';\n/** @ignore @suppress {missingRequire} */\nconst _Buffer = typeof Buffer === 'function' ? Buffer : null;\n/** @ignore */\nconst useNativeEncoders = typeof TextDecoder === 'function' && typeof TextEncoder === 'function';\n/** @ignore */\nexport const decodeUtf8 = ((TextDecoder) => {\n    if (useNativeEncoders || !_Buffer) {\n        const decoder = new TextDecoder('utf-8');\n        return (buffer) => decoder.decode(buffer);\n    }\n    return (input) => {\n        const { buffer, byteOffset, length } = toUint8Array(input);\n        return _Buffer.from(buffer, byteOffset, length).toString();\n    };\n})(typeof TextDecoder !== 'undefined' ? TextDecoder : TextDecoderPolyfill);\n/** @ignore */\nexport const encodeUtf8 = ((TextEncoder) => {\n    if (useNativeEncoders || !_Buffer) {\n        const encoder = new TextEncoder();\n        return (value) => encoder.encode(value);\n    }\n    return (input = '') => toUint8Array(_Buffer.from(input, 'utf8'));\n})(typeof TextEncoder !== 'undefined' ? TextEncoder : TextEncoderPolyfill);\n\n//# sourceMappingURL=utf8.mjs.map\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.\nimport streamAdapters from './adapters';\n/** @ignore */\nexport const ITERATOR_DONE = Object.freeze({ done: true, value: void (0) });\n/** @ignore */\nexport class ArrowJSON {\n    // @ts-ignore\n    constructor(_json) {\n        this._json = _json;\n    }\n    get schema() { return this._json['schema']; }\n    get batches() { return (this._json['batches'] || []); }\n    get dictionaries() { return (this._json['dictionaries'] || []); }\n}\n/** @ignore */\nexport class ReadableInterop {\n    tee() {\n        return this._getDOMStream().tee();\n    }\n    pipe(writable, options) {\n        return this._getNodeStream().pipe(writable, options);\n    }\n    pipeTo(writable, options) { return this._getDOMStream().pipeTo(writable, options); }\n    pipeThrough(duplex, options) {\n        return this._getDOMStream().pipeThrough(duplex, options);\n    }\n    _getDOMStream() {\n        return this._DOMStream || (this._DOMStream = this.toDOMStream());\n    }\n    _getNodeStream() {\n        return this._nodeStream || (this._nodeStream = this.toNodeStream());\n    }\n}\n/** @ignore */\nexport class AsyncQueue extends ReadableInterop {\n    constructor() {\n        super();\n        this._values = [];\n        this.resolvers = [];\n        this._closedPromise = new Promise((r) => this._closedPromiseResolve = r);\n    }\n    get closed() { return this._closedPromise; }\n    async cancel(reason) { await this.return(reason); }\n    write(value) {\n        if (this._ensureOpen()) {\n            this.resolvers.length <= 0\n                ? (this._values.push(value))\n                : (this.resolvers.shift().resolve({ done: false, value }));\n        }\n    }\n    abort(value) {\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    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    [Symbol.asyncIterator]() { return this; }\n    toDOMStream(options) {\n        return streamAdapters.toDOMStream((this._closedPromiseResolve || this._error)\n            ? this\n            : this._values, options);\n    }\n    toNodeStream(options) {\n        return streamAdapters.toNodeStream((this._closedPromiseResolve || this._error)\n            ? this\n            : this._values, options);\n    }\n    async throw(_) { await this.abort(_); return ITERATOR_DONE; }\n    async return(_) { await this.close(); return ITERATOR_DONE; }\n    async read(size) { return (await this.next(size, 'read')).value; }\n    async peek(size) { return (await this.next(size, 'peek')).value; }\n    next(..._args) {\n        if (this._values.length > 0) {\n            return Promise.resolve({ done: false, value: this._values.shift() });\n        }\n        else if (this._error) {\n            return Promise.reject({ done: true, value: this._error.error });\n        }\n        else if (!this._closedPromiseResolve) {\n            return Promise.resolve(ITERATOR_DONE);\n        }\n        else {\n            return new Promise((resolve, reject) => {\n                this.resolvers.push({ resolve, reject });\n            });\n        }\n    }\n    _ensureOpen() {\n        if (this._closedPromiseResolve) {\n            return true;\n        }\n        throw new Error(`${this} is closed`);\n    }\n}\n\n//# sourceMappingURL=interfaces.mjs.map\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.\nimport { ReadableInterop } from '../io/interfaces';\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] : [BigIntUnavailable, false];\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] : [BigInt64ArrayUnavailable, false];\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] : [BigUint64ArrayUnavailable, false];\n})();\nexport { BigIntCtor as BigInt, BigIntAvailable };\nexport { BigInt64ArrayCtor as BigInt64Array, BigInt64ArrayAvailable };\nexport { BigUint64ArrayCtor as BigUint64Array, BigUint64ArrayAvailable };\n/** @ignore */ const isNumber = (x) => typeof x === 'number';\n/** @ignore */ const isBoolean = (x) => typeof x === 'boolean';\n/** @ignore */ const isFunction = (x) => typeof x === 'function';\n/** @ignore */\nexport const isObject = (x) => x != null && Object(x) === x;\n/** @ignore */\nexport const isPromise = (x) => {\n    return isObject(x) && isFunction(x.then);\n};\n/** @ignore */\nexport const isObservable = (x) => {\n    return isObject(x) && isFunction(x.subscribe);\n};\n/** @ignore */\nexport const isIterable = (x) => {\n    return isObject(x) && isFunction(x[Symbol.iterator]);\n};\n/** @ignore */\nexport const isAsyncIterable = (x) => {\n    return isObject(x) && isFunction(x[Symbol.asyncIterator]);\n};\n/** @ignore */\nexport const isArrowJSON = (x) => {\n    return isObject(x) && isObject(x['schema']);\n};\n/** @ignore */\nexport const isArrayLike = (x) => {\n    return isObject(x) && isNumber(x['length']);\n};\n/** @ignore */\nexport const isIteratorResult = (x) => {\n    return isObject(x) && ('done' in x) && ('value' in x);\n};\n/** @ignore */\nexport const isUnderlyingSink = (x) => {\n    return isObject(x) &&\n        isFunction(x['abort']) &&\n        isFunction(x['close']) &&\n        isFunction(x['start']) &&\n        isFunction(x['write']);\n};\n/** @ignore */\nexport const isFileHandle = (x) => {\n    return isObject(x) && isFunction(x['stat']) && isNumber(x['fd']);\n};\n/** @ignore */\nexport const isFSReadStream = (x) => {\n    return isReadableNodeStream(x) && isNumber(x['bytesRead']);\n};\n/** @ignore */\nexport const isFetchResponse = (x) => {\n    return isObject(x) && isReadableDOMStream(x['body']);\n};\n/** @ignore */\nexport const isWritableDOMStream = (x) => {\n    return isObject(x) &&\n        isFunction(x['abort']) &&\n        isFunction(x['getWriter']) &&\n        !(x instanceof ReadableInterop);\n};\n/** @ignore */\nexport const isReadableDOMStream = (x) => {\n    return isObject(x) &&\n        isFunction(x['cancel']) &&\n        isFunction(x['getReader']) &&\n        !(x instanceof ReadableInterop);\n};\n/** @ignore */\nexport const isWritableNodeStream = (x) => {\n    return isObject(x) &&\n        isFunction(x['end']) &&\n        isFunction(x['write']) &&\n        isBoolean(x['writable']) &&\n        !(x instanceof ReadableInterop);\n};\n/** @ignore */\nexport const isReadableNodeStream = (x) => {\n    return isObject(x) &&\n        isFunction(x['read']) &&\n        isFunction(x['pipe']) &&\n        isBoolean(x['readable']) &&\n        !(x instanceof ReadableInterop);\n};\n\n//# sourceMappingURL=compat.mjs.map\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.\nimport { flatbuffers } from 'flatbuffers';\nimport { encodeUtf8 } from '../util/utf8';\nvar ByteBuffer = flatbuffers.ByteBuffer;\nimport { isPromise, isIterable, isAsyncIterable, isIteratorResult, BigInt64Array, BigUint64Array } from './compat';\n/** @ignore */\nconst SharedArrayBuf = (typeof SharedArrayBuffer !== 'undefined' ? SharedArrayBuffer : ArrayBuffer);\n/** @ignore */\nfunction collapseContiguousByteRanges(chunks) {\n    let result = chunks[0] ? [chunks[0]] : [];\n    let xOffset, yOffset, xLen, yLen;\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/** @ignore */\nexport function memcpy(target, source, 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/** @ignore */\nexport function joinUint8Arrays(chunks, size) {\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, sliced, buffer;\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            }\n            else if (sliced.length === source.length) {\n                index++;\n            }\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}\nexport function toArrayBufferView(ArrayBufferViewCtor, input) {\n    let value = isIteratorResult(input) ? input.value : input;\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) {\n        return new ArrayBufferViewCtor(0);\n    }\n    if (typeof value === 'string') {\n        value = encodeUtf8(value);\n    }\n    if (value instanceof ArrayBuffer) {\n        return new ArrayBufferViewCtor(value);\n    }\n    if (value instanceof SharedArrayBuf) {\n        return new ArrayBufferViewCtor(value);\n    }\n    if (value instanceof ByteBuffer) {\n        return toArrayBufferView(ArrayBufferViewCtor, value.bytes());\n    }\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/** @ignore */ export const toInt8Array = (input) => toArrayBufferView(Int8Array, input);\n/** @ignore */ export const toInt16Array = (input) => toArrayBufferView(Int16Array, input);\n/** @ignore */ export const toInt32Array = (input) => toArrayBufferView(Int32Array, input);\n/** @ignore */ export const toBigInt64Array = (input) => toArrayBufferView(BigInt64Array, input);\n/** @ignore */ export const toUint8Array = (input) => toArrayBufferView(Uint8Array, input);\n/** @ignore */ export const toUint16Array = (input) => toArrayBufferView(Uint16Array, input);\n/** @ignore */ export const toUint32Array = (input) => toArrayBufferView(Uint32Array, input);\n/** @ignore */ export const toBigUint64Array = (input) => toArrayBufferView(BigUint64Array, input);\n/** @ignore */ export const toFloat32Array = (input) => toArrayBufferView(Float32Array, input);\n/** @ignore */ export const toFloat64Array = (input) => toArrayBufferView(Float64Array, input);\n/** @ignore */ export const toUint8ClampedArray = (input) => toArrayBufferView(Uint8ClampedArray, input);\n/** @ignore */\nconst pump = (iterator) => { iterator.next(); return iterator; };\n/** @ignore */\nexport function* toArrayBufferViewIterator(ArrayCtor, source) {\n    const wrap = function* (x) { yield x; };\n    const buffers = (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(source) ? wrap(source) : source;\n    yield* pump((function* (it) {\n        let r = null;\n        do {\n            r = it.next(yield toArrayBufferView(ArrayCtor, r));\n        } while (!r.done);\n    })(buffers[Symbol.iterator]()));\n}\n/** @ignore */ export const toInt8ArrayIterator = (input) => toArrayBufferViewIterator(Int8Array, input);\n/** @ignore */ export const toInt16ArrayIterator = (input) => toArrayBufferViewIterator(Int16Array, input);\n/** @ignore */ export const toInt32ArrayIterator = (input) => toArrayBufferViewIterator(Int32Array, input);\n/** @ignore */ export const toUint8ArrayIterator = (input) => toArrayBufferViewIterator(Uint8Array, input);\n/** @ignore */ export const toUint16ArrayIterator = (input) => toArrayBufferViewIterator(Uint16Array, input);\n/** @ignore */ export const toUint32ArrayIterator = (input) => toArrayBufferViewIterator(Uint32Array, input);\n/** @ignore */ export const toFloat32ArrayIterator = (input) => toArrayBufferViewIterator(Float32Array, input);\n/** @ignore */ export const toFloat64ArrayIterator = (input) => toArrayBufferViewIterator(Float64Array, input);\n/** @ignore */ export const toUint8ClampedArrayIterator = (input) => toArrayBufferViewIterator(Uint8ClampedArray, input);\n/** @ignore */\nexport async function* toArrayBufferViewAsyncIterator(ArrayCtor, source) {\n    // if a Promise, unwrap the Promise and iterate the resolved value\n    if (isPromise(source)) {\n        return yield* toArrayBufferViewAsyncIterator(ArrayCtor, await source);\n    }\n    const wrap = async function* (x) { yield await x; };\n    const emit = async function* (source) {\n        yield* pump((function* (it) {\n            let r = null;\n            do {\n                r = it.next(yield r && r.value);\n            } while (!r.done);\n        })(source[Symbol.iterator]()));\n    };\n    const buffers = (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(source) ? emit(source) // If Iterable, wrap in an AsyncIterableIterator and compose the `next` values\n                        : !isAsyncIterable(source) ? wrap(source) // If not an AsyncIterable, treat as a sentinel and wrap in an AsyncIterableIterator\n                            : source; // otherwise if AsyncIterable, use it\n    yield* pump((async function* (it) {\n        let r = null;\n        do {\n            r = await it.next(yield toArrayBufferView(ArrayCtor, r));\n        } while (!r.done);\n    })(buffers[Symbol.asyncIterator]()));\n}\n/** @ignore */ export const toInt8ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Int8Array, input);\n/** @ignore */ export const toInt16ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Int16Array, input);\n/** @ignore */ export const toInt32ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Int32Array, input);\n/** @ignore */ export const toUint8ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint8Array, input);\n/** @ignore */ export const toUint16ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint16Array, input);\n/** @ignore */ export const toUint32ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint32Array, input);\n/** @ignore */ export const toFloat32ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Float32Array, input);\n/** @ignore */ export const toFloat64ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Float64Array, input);\n/** @ignore */ export const toUint8ClampedArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint8ClampedArray, input);\n/** @ignore */\nexport function rebaseValueOffsets(offset, length, valueOffsets) {\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/** @ignore */\nexport function compareArrayLike(a, b) {\n    let i = 0, n = a.length;\n    if (n !== b.length) {\n        return false;\n    }\n    if (n > 0) {\n        do {\n            if (a[i] !== b[i]) {\n                return false;\n            }\n        } while (++i < n);\n    }\n    return true;\n}\n\n//# sourceMappingURL=buffer.mjs.map\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.\nimport { toUint8Array, joinUint8Arrays, toUint8ArrayIterator, toUint8ArrayAsyncIterator } from '../util/buffer';\n/** @ignore */\nexport default {\n    fromIterable(source) {\n        return pump(fromIterable(source));\n    },\n    fromAsyncIterable(source) {\n        return pump(fromAsyncIterable(source));\n    },\n    fromDOMStream(source) {\n        return pump(fromDOMStream(source));\n    },\n    fromNodeStream(stream) {\n        return pump(fromNodeStream(stream));\n    },\n    // @ts-ignore\n    toDOMStream(source, options) {\n        throw new Error(`\"toDOMStream\" not available in this environment`);\n    },\n    // @ts-ignore\n    toNodeStream(source, options) {\n        throw new Error(`\"toNodeStream\" not available in this environment`);\n    },\n};\n/** @ignore */\nconst pump = (iterator) => { iterator.next(); return iterator; };\n/** @ignore */\nfunction* fromIterable(source) {\n    let done, threw = false;\n    let buffers = [], buffer;\n    let cmd, size, bufferLength = 0;\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    // Yield so the caller can inject the read command before creating the source Iterator\n    ({ cmd, size } = yield null);\n    // initialize the iterator\n    let it = toUint8ArrayIterator(source)[Symbol.iterator]();\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    }\n    catch (e) {\n        (threw = true) && (typeof it.throw === 'function') && (it.throw(e));\n    }\n    finally {\n        (threw === false) && (typeof it.return === 'function') && (it.return());\n    }\n}\n/** @ignore */\nasync function* fromAsyncIterable(source) {\n    let done, threw = false;\n    let buffers = [], buffer;\n    let cmd, size, bufferLength = 0;\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    // Yield so the caller can inject the read command before creating the source AsyncIterator\n    ({ cmd, size } = yield null);\n    // initialize the iterator\n    let it = toUint8ArrayAsyncIterator(source)[Symbol.asyncIterator]();\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    }\n    catch (e) {\n        (threw = true) && (typeof it.throw === 'function') && (await it.throw(e));\n    }\n    finally {\n        (threw === false) && (typeof it.return === 'function') && (await it.return());\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(source) {\n    let done = false, threw = false;\n    let buffers = [], buffer;\n    let cmd, size, bufferLength = 0;\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    // Yield so the caller can inject the read command before we establish the ReadableStream lock\n    ({ cmd, size } = yield null);\n    // initialize the reader and lock the stream\n    let it = new AdaptiveByteReader(source);\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    }\n    catch (e) {\n        (threw = true) && (await it['cancel'](e));\n    }\n    finally {\n        (threw === false) ? (await it['cancel']())\n            : source['locked'] && it.releaseLock();\n    }\n}\n/** @ignore */\nclass AdaptiveByteReader {\n    constructor(source) {\n        this.source = source;\n        this.byobReader = null;\n        this.defaultReader = null;\n        try {\n            this.supportsBYOB = !!(this.reader = this.getBYOBReader());\n        }\n        catch (e) {\n            this.supportsBYOB = !!!(this.reader = this.getDefaultReader());\n        }\n    }\n    get closed() {\n        return this.reader ? this.reader['closed'].catch(() => { }) : Promise.resolve();\n    }\n    releaseLock() {\n        if (this.reader) {\n            this.reader.releaseLock();\n        }\n        this.reader = this.byobReader = this.defaultReader = null;\n    }\n    async cancel(reason) {\n        const { reader, source } = this;\n        reader && (await reader['cancel'](reason).catch(() => { }));\n        source && (source['locked'] && this.releaseLock());\n    }\n    async read(size) {\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));\n        return result;\n    }\n    getDefaultReader() {\n        if (this.byobReader) {\n            this.releaseLock();\n        }\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    getBYOBReader() {\n        if (this.defaultReader) {\n            this.releaseLock();\n        }\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    // This strategy plucked from the example in the streams spec:\n    // https://streams.spec.whatwg.org/#example-manual-read-bytes\n    async readFromBYOBReader(size) {\n        return await readInto(this.getBYOBReader(), new ArrayBuffer(size), 0, size);\n    }\n}\n/** @ignore */\nasync function readInto(reader, buffer, offset, size) {\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/** @ignore */\nconst onEvent = (stream, event) => {\n    let handler = (_) => resolve([event, _]);\n    let resolve;\n    return [event, handler, new Promise((r) => (resolve = r) && stream['once'](event, handler))];\n};\n/** @ignore */\nasync function* fromNodeStream(stream) {\n    let events = [];\n    let event = 'error';\n    let done = false, err = null;\n    let cmd, size, bufferLength = 0;\n    let buffers = [], buffer;\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    // 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 null);\n    // ignore stdin if it's a TTY\n    if (stream['isTTY']) {\n        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        do {\n            events[2] = onEvent(stream, 'readable');\n            // wait on the first message event from the stream\n            [event, err] = await Promise.race(events.map((x) => x[2]));\n            // if the stream emitted an Error, rethrow it\n            if (event === 'error') {\n                break;\n            }\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                }\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    }\n    finally {\n        await cleanup(events, event === 'error' ? err : null);\n    }\n    function cleanup(events, err) {\n        buffer = buffers = null;\n        return new Promise(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['destroy'];\n                destroy && destroy.call(stream, err);\n                err = undefined;\n            }\n            catch (e) {\n                err = e || err;\n            }\n            finally {\n                err != null ? reject(err) : resolve();\n            }\n        });\n    }\n}\n\n//# sourceMappingURL=adapters.mjs.map\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.\nexport class AbstractVector {\n}\nexport { AbstractVector as Vector };\n\n//# sourceMappingURL=vector.mjs.map\n","/* tslint:disable:class-name */\n/**\n * @enum {number}\n */\nexport var org;\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                let MetadataVersion;\n                (function (MetadataVersion) {\n                    /**\n                     * 0.1.0\n                     */\n                    MetadataVersion[MetadataVersion[\"V1\"] = 0] = \"V1\";\n                    /**\n                     * 0.2.0\n                     */\n                    MetadataVersion[MetadataVersion[\"V2\"] = 1] = \"V2\";\n                    /**\n                     * 0.3.0 -> 0.7.1\n                     */\n                    MetadataVersion[MetadataVersion[\"V3\"] = 2] = \"V3\";\n                    /**\n                     * >= 0.8.0\n                     */\n                    MetadataVersion[MetadataVersion[\"V4\"] = 3] = \"V4\";\n                })(MetadataVersion = flatbuf.MetadataVersion || (flatbuf.MetadataVersion = {}));\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * @enum {number}\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                let UnionMode;\n                (function (UnionMode) {\n                    UnionMode[UnionMode[\"Sparse\"] = 0] = \"Sparse\";\n                    UnionMode[UnionMode[\"Dense\"] = 1] = \"Dense\";\n                })(UnionMode = flatbuf.UnionMode || (flatbuf.UnionMode = {}));\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * @enum {number}\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                let Precision;\n                (function (Precision) {\n                    Precision[Precision[\"HALF\"] = 0] = \"HALF\";\n                    Precision[Precision[\"SINGLE\"] = 1] = \"SINGLE\";\n                    Precision[Precision[\"DOUBLE\"] = 2] = \"DOUBLE\";\n                })(Precision = flatbuf.Precision || (flatbuf.Precision = {}));\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * @enum {number}\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                let DateUnit;\n                (function (DateUnit) {\n                    DateUnit[DateUnit[\"DAY\"] = 0] = \"DAY\";\n                    DateUnit[DateUnit[\"MILLISECOND\"] = 1] = \"MILLISECOND\";\n                })(DateUnit = flatbuf.DateUnit || (flatbuf.DateUnit = {}));\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * @enum {number}\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                let TimeUnit;\n                (function (TimeUnit) {\n                    TimeUnit[TimeUnit[\"SECOND\"] = 0] = \"SECOND\";\n                    TimeUnit[TimeUnit[\"MILLISECOND\"] = 1] = \"MILLISECOND\";\n                    TimeUnit[TimeUnit[\"MICROSECOND\"] = 2] = \"MICROSECOND\";\n                    TimeUnit[TimeUnit[\"NANOSECOND\"] = 3] = \"NANOSECOND\";\n                })(TimeUnit = flatbuf.TimeUnit || (flatbuf.TimeUnit = {}));\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * @enum {number}\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                let IntervalUnit;\n                (function (IntervalUnit) {\n                    IntervalUnit[IntervalUnit[\"YEAR_MONTH\"] = 0] = \"YEAR_MONTH\";\n                    IntervalUnit[IntervalUnit[\"DAY_TIME\"] = 1] = \"DAY_TIME\";\n                })(IntervalUnit = flatbuf.IntervalUnit || (flatbuf.IntervalUnit = {}));\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\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 */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                let Type;\n                (function (Type) {\n                    Type[Type[\"NONE\"] = 0] = \"NONE\";\n                    Type[Type[\"Null\"] = 1] = \"Null\";\n                    Type[Type[\"Int\"] = 2] = \"Int\";\n                    Type[Type[\"FloatingPoint\"] = 3] = \"FloatingPoint\";\n                    Type[Type[\"Binary\"] = 4] = \"Binary\";\n                    Type[Type[\"Utf8\"] = 5] = \"Utf8\";\n                    Type[Type[\"Bool\"] = 6] = \"Bool\";\n                    Type[Type[\"Decimal\"] = 7] = \"Decimal\";\n                    Type[Type[\"Date\"] = 8] = \"Date\";\n                    Type[Type[\"Time\"] = 9] = \"Time\";\n                    Type[Type[\"Timestamp\"] = 10] = \"Timestamp\";\n                    Type[Type[\"Interval\"] = 11] = \"Interval\";\n                    Type[Type[\"List\"] = 12] = \"List\";\n                    Type[Type[\"Struct_\"] = 13] = \"Struct_\";\n                    Type[Type[\"Union\"] = 14] = \"Union\";\n                    Type[Type[\"FixedSizeBinary\"] = 15] = \"FixedSizeBinary\";\n                    Type[Type[\"FixedSizeList\"] = 16] = \"FixedSizeList\";\n                    Type[Type[\"Map\"] = 17] = \"Map\";\n                    Type[Type[\"Duration\"] = 18] = \"Duration\";\n                    Type[Type[\"LargeBinary\"] = 19] = \"LargeBinary\";\n                    Type[Type[\"LargeUtf8\"] = 20] = \"LargeUtf8\";\n                    Type[Type[\"LargeList\"] = 21] = \"LargeList\";\n                })(Type = flatbuf.Type || (flatbuf.Type = {}));\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * ----------------------------------------------------------------------\n * Endianness of the platform producing the data\n *\n * @enum {number}\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                let Endianness;\n                (function (Endianness) {\n                    Endianness[Endianness[\"Little\"] = 0] = \"Little\";\n                    Endianness[Endianness[\"Big\"] = 1] = \"Big\";\n                })(Endianness = flatbuf.Endianness || (flatbuf.Endianness = {}));\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * These are stored in the flatbuffer in the Type union below\n *\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Null {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Null\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param Null= obj\n                     * @returns Null\n                     */\n                    static getRootAsNull(bb, obj) {\n                        return (obj || new Null).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     */\n                    static startNull(builder) {\n                        builder.startObject(0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endNull(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createNull(builder) {\n                        Null.startNull(builder);\n                        return Null.endNull(builder);\n                    }\n                }\n                flatbuf.Null = Null;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\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 */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Struct_ {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Struct_\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param Struct_= obj\n                     * @returns Struct_\n                     */\n                    static getRootAsStruct_(bb, obj) {\n                        return (obj || new Struct_).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     */\n                    static startStruct_(builder) {\n                        builder.startObject(0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endStruct_(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createStruct_(builder) {\n                        Struct_.startStruct_(builder);\n                        return Struct_.endStruct_(builder);\n                    }\n                }\n                flatbuf.Struct_ = Struct_;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class List {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns List\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param List= obj\n                     * @returns List\n                     */\n                    static getRootAsList(bb, obj) {\n                        return (obj || new List).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     */\n                    static startList(builder) {\n                        builder.startObject(0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endList(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createList(builder) {\n                        List.startList(builder);\n                        return List.endList(builder);\n                    }\n                }\n                flatbuf.List = List;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * Same as List, but with 64-bit offsets, allowing to represent\n * extremely large data values.\n *\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class LargeList {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns LargeList\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param LargeList= obj\n                     * @returns LargeList\n                     */\n                    static getRootAsLargeList(bb, obj) {\n                        return (obj || new LargeList).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     */\n                    static startLargeList(builder) {\n                        builder.startObject(0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endLargeList(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createLargeList(builder) {\n                        LargeList.startLargeList(builder);\n                        return LargeList.endLargeList(builder);\n                    }\n                }\n                flatbuf.LargeList = LargeList;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class FixedSizeList {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns FixedSizeList\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param FixedSizeList= obj\n                     * @returns FixedSizeList\n                     */\n                    static getRootAsFixedSizeList(bb, obj) {\n                        return (obj || new FixedSizeList).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * Number of list items per value\n                     *\n                     * @returns number\n                     */\n                    listSize() {\n                        let offset = this.bb.__offset(this.bb_pos, 4);\n                        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     */\n                    static startFixedSizeList(builder) {\n                        builder.startObject(1);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param number listSize\n                     */\n                    static addListSize(builder, listSize) {\n                        builder.addFieldInt32(0, listSize, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endFixedSizeList(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createFixedSizeList(builder, listSize) {\n                        FixedSizeList.startFixedSizeList(builder);\n                        FixedSizeList.addListSize(builder, listSize);\n                        return FixedSizeList.endFixedSizeList(builder);\n                    }\n                }\n                flatbuf.FixedSizeList = FixedSizeList;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\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 */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Map {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Map\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param Map= obj\n                     * @returns Map\n                     */\n                    static getRootAsMap(bb, obj) {\n                        return (obj || new Map).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * Set to true if the keys within each value are sorted\n                     *\n                     * @returns boolean\n                     */\n                    keysSorted() {\n                        let offset = this.bb.__offset(this.bb_pos, 4);\n                        return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     */\n                    static startMap(builder) {\n                        builder.startObject(1);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param boolean keysSorted\n                     */\n                    static addKeysSorted(builder, keysSorted) {\n                        builder.addFieldInt8(0, +keysSorted, +false);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endMap(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createMap(builder, keysSorted) {\n                        Map.startMap(builder);\n                        Map.addKeysSorted(builder, keysSorted);\n                        return Map.endMap(builder);\n                    }\n                }\n                flatbuf.Map = Map;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\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 */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Union {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Union\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param Union= obj\n                     * @returns Union\n                     */\n                    static getRootAsUnion(bb, obj) {\n                        return (obj || new Union).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @returns org.apache.arrow.flatbuf.UnionMode\n                     */\n                    mode() {\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                     * @param number index\n                     * @returns number\n                     */\n                    typeIds(index) {\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                     * @returns number\n                     */\n                    typeIdsLength() {\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                     * @returns Int32Array\n                     */\n                    typeIdsArray() {\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                     * @param flatbuffers.Builder builder\n                     */\n                    static startUnion(builder) {\n                        builder.startObject(2);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param org.apache.arrow.flatbuf.UnionMode mode\n                     */\n                    static addMode(builder, mode) {\n                        builder.addFieldInt16(0, mode, org.apache.arrow.flatbuf.UnionMode.Sparse);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset typeIdsOffset\n                     */\n                    static addTypeIds(builder, typeIdsOffset) {\n                        builder.addFieldOffset(1, typeIdsOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param Array.<number> data\n                     * @returns flatbuffers.Offset\n                     */\n                    static createTypeIdsVector(builder, data) {\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                     * @param flatbuffers.Builder builder\n                     * @param number numElems\n                     */\n                    static startTypeIdsVector(builder, numElems) {\n                        builder.startVector(4, numElems, 4);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endUnion(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createUnion(builder, mode, typeIdsOffset) {\n                        Union.startUnion(builder);\n                        Union.addMode(builder, mode);\n                        Union.addTypeIds(builder, typeIdsOffset);\n                        return Union.endUnion(builder);\n                    }\n                }\n                flatbuf.Union = Union;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Int {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Int\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param Int= obj\n                     * @returns Int\n                     */\n                    static getRootAsInt(bb, obj) {\n                        return (obj || new Int).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @returns number\n                     */\n                    bitWidth() {\n                        let offset = this.bb.__offset(this.bb_pos, 4);\n                        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;\n                    }\n                    /**\n                     * @returns boolean\n                     */\n                    isSigned() {\n                        let offset = this.bb.__offset(this.bb_pos, 6);\n                        return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     */\n                    static startInt(builder) {\n                        builder.startObject(2);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param number bitWidth\n                     */\n                    static addBitWidth(builder, bitWidth) {\n                        builder.addFieldInt32(0, bitWidth, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param boolean isSigned\n                     */\n                    static addIsSigned(builder, isSigned) {\n                        builder.addFieldInt8(1, +isSigned, +false);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endInt(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createInt(builder, bitWidth, isSigned) {\n                        Int.startInt(builder);\n                        Int.addBitWidth(builder, bitWidth);\n                        Int.addIsSigned(builder, isSigned);\n                        return Int.endInt(builder);\n                    }\n                }\n                flatbuf.Int = Int;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class FloatingPoint {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns FloatingPoint\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param FloatingPoint= obj\n                     * @returns FloatingPoint\n                     */\n                    static getRootAsFloatingPoint(bb, obj) {\n                        return (obj || new FloatingPoint).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @returns org.apache.arrow.flatbuf.Precision\n                     */\n                    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                     * @param flatbuffers.Builder builder\n                     */\n                    static startFloatingPoint(builder) {\n                        builder.startObject(1);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param org.apache.arrow.flatbuf.Precision precision\n                     */\n                    static addPrecision(builder, precision) {\n                        builder.addFieldInt16(0, precision, org.apache.arrow.flatbuf.Precision.HALF);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endFloatingPoint(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createFloatingPoint(builder, precision) {\n                        FloatingPoint.startFloatingPoint(builder);\n                        FloatingPoint.addPrecision(builder, precision);\n                        return FloatingPoint.endFloatingPoint(builder);\n                    }\n                }\n                flatbuf.FloatingPoint = FloatingPoint;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * Unicode with UTF-8 encoding\n *\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Utf8 {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Utf8\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param Utf8= obj\n                     * @returns Utf8\n                     */\n                    static getRootAsUtf8(bb, obj) {\n                        return (obj || new Utf8).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     */\n                    static startUtf8(builder) {\n                        builder.startObject(0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endUtf8(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createUtf8(builder) {\n                        Utf8.startUtf8(builder);\n                        return Utf8.endUtf8(builder);\n                    }\n                }\n                flatbuf.Utf8 = Utf8;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * Opaque binary data\n *\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Binary {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Binary\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param Binary= obj\n                     * @returns Binary\n                     */\n                    static getRootAsBinary(bb, obj) {\n                        return (obj || new Binary).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     */\n                    static startBinary(builder) {\n                        builder.startObject(0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endBinary(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createBinary(builder) {\n                        Binary.startBinary(builder);\n                        return Binary.endBinary(builder);\n                    }\n                }\n                flatbuf.Binary = Binary;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * Same as Utf8, but with 64-bit offsets, allowing to represent\n * extremely large data values.\n *\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class LargeUtf8 {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns LargeUtf8\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param LargeUtf8= obj\n                     * @returns LargeUtf8\n                     */\n                    static getRootAsLargeUtf8(bb, obj) {\n                        return (obj || new LargeUtf8).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     */\n                    static startLargeUtf8(builder) {\n                        builder.startObject(0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endLargeUtf8(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createLargeUtf8(builder) {\n                        LargeUtf8.startLargeUtf8(builder);\n                        return LargeUtf8.endLargeUtf8(builder);\n                    }\n                }\n                flatbuf.LargeUtf8 = LargeUtf8;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * Same as Binary, but with 64-bit offsets, allowing to represent\n * extremely large data values.\n *\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class LargeBinary {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns LargeBinary\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param LargeBinary= obj\n                     * @returns LargeBinary\n                     */\n                    static getRootAsLargeBinary(bb, obj) {\n                        return (obj || new LargeBinary).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     */\n                    static startLargeBinary(builder) {\n                        builder.startObject(0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endLargeBinary(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createLargeBinary(builder) {\n                        LargeBinary.startLargeBinary(builder);\n                        return LargeBinary.endLargeBinary(builder);\n                    }\n                }\n                flatbuf.LargeBinary = LargeBinary;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class FixedSizeBinary {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns FixedSizeBinary\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param FixedSizeBinary= obj\n                     * @returns FixedSizeBinary\n                     */\n                    static getRootAsFixedSizeBinary(bb, obj) {\n                        return (obj || new FixedSizeBinary).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * Number of bytes per value\n                     *\n                     * @returns number\n                     */\n                    byteWidth() {\n                        let offset = this.bb.__offset(this.bb_pos, 4);\n                        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     */\n                    static startFixedSizeBinary(builder) {\n                        builder.startObject(1);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param number byteWidth\n                     */\n                    static addByteWidth(builder, byteWidth) {\n                        builder.addFieldInt32(0, byteWidth, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endFixedSizeBinary(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createFixedSizeBinary(builder, byteWidth) {\n                        FixedSizeBinary.startFixedSizeBinary(builder);\n                        FixedSizeBinary.addByteWidth(builder, byteWidth);\n                        return FixedSizeBinary.endFixedSizeBinary(builder);\n                    }\n                }\n                flatbuf.FixedSizeBinary = FixedSizeBinary;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Bool {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Bool\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param Bool= obj\n                     * @returns Bool\n                     */\n                    static getRootAsBool(bb, obj) {\n                        return (obj || new Bool).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     */\n                    static startBool(builder) {\n                        builder.startObject(0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endBool(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createBool(builder) {\n                        Bool.startBool(builder);\n                        return Bool.endBool(builder);\n                    }\n                }\n                flatbuf.Bool = Bool;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Decimal {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Decimal\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param Decimal= obj\n                     * @returns Decimal\n                     */\n                    static getRootAsDecimal(bb, obj) {\n                        return (obj || new Decimal).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * Total number of decimal digits\n                     *\n                     * @returns number\n                     */\n                    precision() {\n                        let offset = this.bb.__offset(this.bb_pos, 4);\n                        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;\n                    }\n                    /**\n                     * Number of digits after the decimal point \".\"\n                     *\n                     * @returns number\n                     */\n                    scale() {\n                        let offset = this.bb.__offset(this.bb_pos, 6);\n                        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     */\n                    static startDecimal(builder) {\n                        builder.startObject(2);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param number precision\n                     */\n                    static addPrecision(builder, precision) {\n                        builder.addFieldInt32(0, precision, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param number scale\n                     */\n                    static addScale(builder, scale) {\n                        builder.addFieldInt32(1, scale, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endDecimal(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createDecimal(builder, precision, scale) {\n                        Decimal.startDecimal(builder);\n                        Decimal.addPrecision(builder, precision);\n                        Decimal.addScale(builder, scale);\n                        return Decimal.endDecimal(builder);\n                    }\n                }\n                flatbuf.Decimal = Decimal;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\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 */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Date {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Date\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param Date= obj\n                     * @returns Date\n                     */\n                    static getRootAsDate(bb, obj) {\n                        return (obj || new Date).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @returns org.apache.arrow.flatbuf.DateUnit\n                     */\n                    unit() {\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                     * @param flatbuffers.Builder builder\n                     */\n                    static startDate(builder) {\n                        builder.startObject(1);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param org.apache.arrow.flatbuf.DateUnit unit\n                     */\n                    static addUnit(builder, unit) {\n                        builder.addFieldInt16(0, unit, org.apache.arrow.flatbuf.DateUnit.MILLISECOND);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endDate(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createDate(builder, unit) {\n                        Date.startDate(builder);\n                        Date.addUnit(builder, unit);\n                        return Date.endDate(builder);\n                    }\n                }\n                flatbuf.Date = Date;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\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 */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Time {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Time\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param Time= obj\n                     * @returns Time\n                     */\n                    static getRootAsTime(bb, obj) {\n                        return (obj || new Time).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @returns org.apache.arrow.flatbuf.TimeUnit\n                     */\n                    unit() {\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                     * @returns number\n                     */\n                    bitWidth() {\n                        let offset = this.bb.__offset(this.bb_pos, 6);\n                        return offset ? this.bb.readInt32(this.bb_pos + offset) : 32;\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     */\n                    static startTime(builder) {\n                        builder.startObject(2);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param org.apache.arrow.flatbuf.TimeUnit unit\n                     */\n                    static addUnit(builder, unit) {\n                        builder.addFieldInt16(0, unit, org.apache.arrow.flatbuf.TimeUnit.MILLISECOND);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param number bitWidth\n                     */\n                    static addBitWidth(builder, bitWidth) {\n                        builder.addFieldInt32(1, bitWidth, 32);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endTime(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createTime(builder, unit, bitWidth) {\n                        Time.startTime(builder);\n                        Time.addUnit(builder, unit);\n                        Time.addBitWidth(builder, bitWidth);\n                        return Time.endTime(builder);\n                    }\n                }\n                flatbuf.Time = Time;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\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 */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Timestamp {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Timestamp\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param Timestamp= obj\n                     * @returns Timestamp\n                     */\n                    static getRootAsTimestamp(bb, obj) {\n                        return (obj || new Timestamp).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @returns org.apache.arrow.flatbuf.TimeUnit\n                     */\n                    unit() {\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                    timezone(optionalEncoding) {\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                     * @param flatbuffers.Builder builder\n                     */\n                    static startTimestamp(builder) {\n                        builder.startObject(2);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param org.apache.arrow.flatbuf.TimeUnit unit\n                     */\n                    static addUnit(builder, unit) {\n                        builder.addFieldInt16(0, unit, org.apache.arrow.flatbuf.TimeUnit.SECOND);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset timezoneOffset\n                     */\n                    static addTimezone(builder, timezoneOffset) {\n                        builder.addFieldOffset(1, timezoneOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endTimestamp(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createTimestamp(builder, unit, timezoneOffset) {\n                        Timestamp.startTimestamp(builder);\n                        Timestamp.addUnit(builder, unit);\n                        Timestamp.addTimezone(builder, timezoneOffset);\n                        return Timestamp.endTimestamp(builder);\n                    }\n                }\n                flatbuf.Timestamp = Timestamp;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Interval {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Interval\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param Interval= obj\n                     * @returns Interval\n                     */\n                    static getRootAsInterval(bb, obj) {\n                        return (obj || new Interval).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @returns org.apache.arrow.flatbuf.IntervalUnit\n                     */\n                    unit() {\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                     * @param flatbuffers.Builder builder\n                     */\n                    static startInterval(builder) {\n                        builder.startObject(1);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param org.apache.arrow.flatbuf.IntervalUnit unit\n                     */\n                    static addUnit(builder, unit) {\n                        builder.addFieldInt16(0, unit, org.apache.arrow.flatbuf.IntervalUnit.YEAR_MONTH);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endInterval(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createInterval(builder, unit) {\n                        Interval.startInterval(builder);\n                        Interval.addUnit(builder, unit);\n                        return Interval.endInterval(builder);\n                    }\n                }\n                flatbuf.Interval = Interval;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Duration {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Duration\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param Duration= obj\n                     * @returns Duration\n                     */\n                    static getRootAsDuration(bb, obj) {\n                        return (obj || new Duration).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @returns org.apache.arrow.flatbuf.TimeUnit\n                     */\n                    unit() {\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                     * @param flatbuffers.Builder builder\n                     */\n                    static startDuration(builder) {\n                        builder.startObject(1);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param org.apache.arrow.flatbuf.TimeUnit unit\n                     */\n                    static addUnit(builder, unit) {\n                        builder.addFieldInt16(0, unit, org.apache.arrow.flatbuf.TimeUnit.MILLISECOND);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endDuration(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createDuration(builder, unit) {\n                        Duration.startDuration(builder);\n                        Duration.addUnit(builder, unit);\n                        return Duration.endDuration(builder);\n                    }\n                }\n                flatbuf.Duration = Duration;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\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 */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class KeyValue {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns KeyValue\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param KeyValue= obj\n                     * @returns KeyValue\n                     */\n                    static getRootAsKeyValue(bb, obj) {\n                        return (obj || new KeyValue).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    key(optionalEncoding) {\n                        let offset = this.bb.__offset(this.bb_pos, 4);\n                        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;\n                    }\n                    value(optionalEncoding) {\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                     * @param flatbuffers.Builder builder\n                     */\n                    static startKeyValue(builder) {\n                        builder.startObject(2);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset keyOffset\n                     */\n                    static addKey(builder, keyOffset) {\n                        builder.addFieldOffset(0, keyOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset valueOffset\n                     */\n                    static addValue(builder, valueOffset) {\n                        builder.addFieldOffset(1, valueOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endKeyValue(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createKeyValue(builder, keyOffset, valueOffset) {\n                        KeyValue.startKeyValue(builder);\n                        KeyValue.addKey(builder, keyOffset);\n                        KeyValue.addValue(builder, valueOffset);\n                        return KeyValue.endKeyValue(builder);\n                    }\n                }\n                flatbuf.KeyValue = KeyValue;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * ----------------------------------------------------------------------\n * Dictionary encoding metadata\n *\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class DictionaryEncoding {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns DictionaryEncoding\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param DictionaryEncoding= obj\n                     * @returns DictionaryEncoding\n                     */\n                    static getRootAsDictionaryEncoding(bb, obj) {\n                        return (obj || new DictionaryEncoding).__init(bb.readInt32(bb.position()) + bb.position(), bb);\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() {\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                     * 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) {\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                     * 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() {\n                        let offset = this.bb.__offset(this.bb_pos, 8);\n                        return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     */\n                    static startDictionaryEncoding(builder) {\n                        builder.startObject(3);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Long id\n                     */\n                    static addId(builder, id) {\n                        builder.addFieldInt64(0, id, builder.createLong(0, 0));\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset indexTypeOffset\n                     */\n                    static addIndexType(builder, indexTypeOffset) {\n                        builder.addFieldOffset(1, indexTypeOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param boolean isOrdered\n                     */\n                    static addIsOrdered(builder, isOrdered) {\n                        builder.addFieldInt8(2, +isOrdered, +false);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endDictionaryEncoding(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createDictionaryEncoding(builder, id, indexTypeOffset, isOrdered) {\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                flatbuf.DictionaryEncoding = DictionaryEncoding;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\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 */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Field {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Field\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param Field= obj\n                     * @returns Field\n                     */\n                    static getRootAsField(bb, obj) {\n                        return (obj || new Field).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    name(optionalEncoding) {\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                     * Whether or not this field can contain nulls. Should be true in general.\n                     *\n                     * @returns boolean\n                     */\n                    nullable() {\n                        let offset = this.bb.__offset(this.bb_pos, 6);\n                        return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;\n                    }\n                    /**\n                     * @returns org.apache.arrow.flatbuf.Type\n                     */\n                    typeType() {\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                     * 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(obj) {\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                     * 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) {\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                     * 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, obj) {\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                     * @returns number\n                     */\n                    childrenLength() {\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                     * 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, obj) {\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                     * @returns number\n                     */\n                    customMetadataLength() {\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                     * @param flatbuffers.Builder builder\n                     */\n                    static startField(builder) {\n                        builder.startObject(7);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset nameOffset\n                     */\n                    static addName(builder, nameOffset) {\n                        builder.addFieldOffset(0, nameOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param boolean nullable\n                     */\n                    static addNullable(builder, nullable) {\n                        builder.addFieldInt8(1, +nullable, +false);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param org.apache.arrow.flatbuf.Type typeType\n                     */\n                    static addTypeType(builder, typeType) {\n                        builder.addFieldInt8(2, typeType, org.apache.arrow.flatbuf.Type.NONE);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset typeOffset\n                     */\n                    static addType(builder, typeOffset) {\n                        builder.addFieldOffset(3, typeOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset dictionaryOffset\n                     */\n                    static addDictionary(builder, dictionaryOffset) {\n                        builder.addFieldOffset(4, dictionaryOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset childrenOffset\n                     */\n                    static addChildren(builder, childrenOffset) {\n                        builder.addFieldOffset(5, childrenOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param Array.<flatbuffers.Offset> data\n                     * @returns flatbuffers.Offset\n                     */\n                    static createChildrenVector(builder, data) {\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                     * @param flatbuffers.Builder builder\n                     * @param number numElems\n                     */\n                    static startChildrenVector(builder, numElems) {\n                        builder.startVector(4, numElems, 4);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset customMetadataOffset\n                     */\n                    static addCustomMetadata(builder, customMetadataOffset) {\n                        builder.addFieldOffset(6, customMetadataOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param Array.<flatbuffers.Offset> data\n                     * @returns flatbuffers.Offset\n                     */\n                    static createCustomMetadataVector(builder, data) {\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                     * @param flatbuffers.Builder builder\n                     * @param number numElems\n                     */\n                    static startCustomMetadataVector(builder, numElems) {\n                        builder.startVector(4, numElems, 4);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endField(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createField(builder, nameOffset, nullable, typeType, typeOffset, dictionaryOffset, childrenOffset, customMetadataOffset) {\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                flatbuf.Field = Field;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * ----------------------------------------------------------------------\n * A Buffer represents a single contiguous memory segment\n *\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Buffer {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Buffer\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\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() {\n                        return this.bb.readInt64(this.bb_pos);\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() {\n                        return this.bb.readInt64(this.bb_pos + 8);\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, offset, length) {\n                        builder.prep(8, 16);\n                        builder.writeInt64(length);\n                        builder.writeInt64(offset);\n                        return builder.offset();\n                    }\n                }\n                flatbuf.Buffer = Buffer;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * ----------------------------------------------------------------------\n * A Schema describes the columns in a row batch\n *\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Schema {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Schema\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param Schema= obj\n                     * @returns Schema\n                     */\n                    static getRootAsSchema(bb, obj) {\n                        return (obj || new Schema).__init(bb.readInt32(bb.position()) + bb.position(), bb);\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() {\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                     * @param number index\n                     * @param org.apache.arrow.flatbuf.Field= obj\n                     * @returns org.apache.arrow.flatbuf.Field\n                     */\n                    fields(index, obj) {\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                     * @returns number\n                     */\n                    fieldsLength() {\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                     * @param number index\n                     * @param org.apache.arrow.flatbuf.KeyValue= obj\n                     * @returns org.apache.arrow.flatbuf.KeyValue\n                     */\n                    customMetadata(index, obj) {\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                     * @returns number\n                     */\n                    customMetadataLength() {\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                     * @param flatbuffers.Builder builder\n                     */\n                    static startSchema(builder) {\n                        builder.startObject(3);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param org.apache.arrow.flatbuf.Endianness endianness\n                     */\n                    static addEndianness(builder, endianness) {\n                        builder.addFieldInt16(0, endianness, org.apache.arrow.flatbuf.Endianness.Little);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset fieldsOffset\n                     */\n                    static addFields(builder, fieldsOffset) {\n                        builder.addFieldOffset(1, fieldsOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param Array.<flatbuffers.Offset> data\n                     * @returns flatbuffers.Offset\n                     */\n                    static createFieldsVector(builder, data) {\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                     * @param flatbuffers.Builder builder\n                     * @param number numElems\n                     */\n                    static startFieldsVector(builder, numElems) {\n                        builder.startVector(4, numElems, 4);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset customMetadataOffset\n                     */\n                    static addCustomMetadata(builder, customMetadataOffset) {\n                        builder.addFieldOffset(2, customMetadataOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param Array.<flatbuffers.Offset> data\n                     * @returns flatbuffers.Offset\n                     */\n                    static createCustomMetadataVector(builder, data) {\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                     * @param flatbuffers.Builder builder\n                     * @param number numElems\n                     */\n                    static startCustomMetadataVector(builder, numElems) {\n                        builder.startVector(4, numElems, 4);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endSchema(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset offset\n                     */\n                    static finishSchemaBuffer(builder, offset) {\n                        builder.finish(offset);\n                    }\n                    static createSchema(builder, endianness, fieldsOffset, customMetadataOffset) {\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                flatbuf.Schema = Schema;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n\n//# sourceMappingURL=Schema.mjs.map\n","// automatically generated by the FlatBuffers compiler, do not modify\nimport * as NS7624605610262437867 from './Schema';\nexport var org;\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                flatbuf.Schema = NS7624605610262437867.org.apache.arrow.flatbuf.Schema;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\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 */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                let MessageHeader;\n                (function (MessageHeader) {\n                    MessageHeader[MessageHeader[\"NONE\"] = 0] = \"NONE\";\n                    MessageHeader[MessageHeader[\"Schema\"] = 1] = \"Schema\";\n                    MessageHeader[MessageHeader[\"DictionaryBatch\"] = 2] = \"DictionaryBatch\";\n                    MessageHeader[MessageHeader[\"RecordBatch\"] = 3] = \"RecordBatch\";\n                    MessageHeader[MessageHeader[\"Tensor\"] = 4] = \"Tensor\";\n                    MessageHeader[MessageHeader[\"SparseTensor\"] = 5] = \"SparseTensor\";\n                })(MessageHeader = flatbuf.MessageHeader || (flatbuf.MessageHeader = {}));\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\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 */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class FieldNode {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns FieldNode\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\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() {\n                        return this.bb.readInt64(this.bb_pos);\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() {\n                        return this.bb.readInt64(this.bb_pos + 8);\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, length, null_count) {\n                        builder.prep(8, 16);\n                        builder.writeInt64(null_count);\n                        builder.writeInt64(length);\n                        return builder.offset();\n                    }\n                }\n                flatbuf.FieldNode = FieldNode;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\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 */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class RecordBatch {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns RecordBatch\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param RecordBatch= obj\n                     * @returns RecordBatch\n                     */\n                    static getRootAsRecordBatch(bb, obj) {\n                        return (obj || new RecordBatch).__init(bb.readInt32(bb.position()) + bb.position(), bb);\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() {\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                     * 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, obj) {\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                     * @returns number\n                     */\n                    nodesLength() {\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                     * 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, obj) {\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                     * @returns number\n                     */\n                    buffersLength() {\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                     * @param flatbuffers.Builder builder\n                     */\n                    static startRecordBatch(builder) {\n                        builder.startObject(3);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Long length\n                     */\n                    static addLength(builder, length) {\n                        builder.addFieldInt64(0, length, builder.createLong(0, 0));\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset nodesOffset\n                     */\n                    static addNodes(builder, nodesOffset) {\n                        builder.addFieldOffset(1, nodesOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param number numElems\n                     */\n                    static startNodesVector(builder, numElems) {\n                        builder.startVector(16, numElems, 8);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset buffersOffset\n                     */\n                    static addBuffers(builder, buffersOffset) {\n                        builder.addFieldOffset(2, buffersOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param number numElems\n                     */\n                    static startBuffersVector(builder, numElems) {\n                        builder.startVector(16, numElems, 8);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endRecordBatch(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createRecordBatch(builder, length, nodesOffset, buffersOffset) {\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                flatbuf.RecordBatch = RecordBatch;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\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 */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class DictionaryBatch {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns DictionaryBatch\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param DictionaryBatch= obj\n                     * @returns DictionaryBatch\n                     */\n                    static getRootAsDictionaryBatch(bb, obj) {\n                        return (obj || new DictionaryBatch).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @returns flatbuffers.Long\n                     */\n                    id() {\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                     * @param org.apache.arrow.flatbuf.RecordBatch= obj\n                     * @returns org.apache.arrow.flatbuf.RecordBatch|null\n                     */\n                    data(obj) {\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                     * 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() {\n                        let offset = this.bb.__offset(this.bb_pos, 8);\n                        return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     */\n                    static startDictionaryBatch(builder) {\n                        builder.startObject(3);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Long id\n                     */\n                    static addId(builder, id) {\n                        builder.addFieldInt64(0, id, builder.createLong(0, 0));\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset dataOffset\n                     */\n                    static addData(builder, dataOffset) {\n                        builder.addFieldOffset(1, dataOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param boolean isDelta\n                     */\n                    static addIsDelta(builder, isDelta) {\n                        builder.addFieldInt8(2, +isDelta, +false);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endDictionaryBatch(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    static createDictionaryBatch(builder, id, dataOffset, isDelta) {\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                flatbuf.DictionaryBatch = DictionaryBatch;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Message {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Message\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param Message= obj\n                     * @returns Message\n                     */\n                    static getRootAsMessage(bb, obj) {\n                        return (obj || new Message).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @returns org.apache.arrow.flatbuf.MetadataVersion\n                     */\n                    version() {\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                     * @returns org.apache.arrow.flatbuf.MessageHeader\n                     */\n                    headerType() {\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                     * @param flatbuffers.Table obj\n                     * @returns ?flatbuffers.Table\n                     */\n                    header(obj) {\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                     * @returns flatbuffers.Long\n                     */\n                    bodyLength() {\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                     * @param number index\n                     * @param org.apache.arrow.flatbuf.KeyValue= obj\n                     * @returns org.apache.arrow.flatbuf.KeyValue\n                     */\n                    customMetadata(index, obj) {\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                     * @returns number\n                     */\n                    customMetadataLength() {\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                     * @param flatbuffers.Builder builder\n                     */\n                    static startMessage(builder) {\n                        builder.startObject(5);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param org.apache.arrow.flatbuf.MetadataVersion version\n                     */\n                    static addVersion(builder, version) {\n                        builder.addFieldInt16(0, version, NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion.V1);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param org.apache.arrow.flatbuf.MessageHeader headerType\n                     */\n                    static addHeaderType(builder, headerType) {\n                        builder.addFieldInt8(1, headerType, org.apache.arrow.flatbuf.MessageHeader.NONE);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset headerOffset\n                     */\n                    static addHeader(builder, headerOffset) {\n                        builder.addFieldOffset(2, headerOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Long bodyLength\n                     */\n                    static addBodyLength(builder, bodyLength) {\n                        builder.addFieldInt64(3, bodyLength, builder.createLong(0, 0));\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset customMetadataOffset\n                     */\n                    static addCustomMetadata(builder, customMetadataOffset) {\n                        builder.addFieldOffset(4, customMetadataOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param Array.<flatbuffers.Offset> data\n                     * @returns flatbuffers.Offset\n                     */\n                    static createCustomMetadataVector(builder, data) {\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                     * @param flatbuffers.Builder builder\n                     * @param number numElems\n                     */\n                    static startCustomMetadataVector(builder, numElems) {\n                        builder.startVector(4, numElems, 4);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endMessage(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset offset\n                     */\n                    static finishMessageBuffer(builder, offset) {\n                        builder.finish(offset);\n                    }\n                    static createMessage(builder, version, headerType, headerOffset, bodyLength, customMetadataOffset) {\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                flatbuf.Message = Message;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n\n//# sourceMappingURL=Message.mjs.map\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.\nimport * as Schema_ from './fb/Schema';\nimport * as Message_ from './fb/Message';\nexport var ArrowType = Schema_.org.apache.arrow.flatbuf.Type;\nexport var DateUnit = Schema_.org.apache.arrow.flatbuf.DateUnit;\nexport var TimeUnit = Schema_.org.apache.arrow.flatbuf.TimeUnit;\nexport var Precision = Schema_.org.apache.arrow.flatbuf.Precision;\nexport var UnionMode = Schema_.org.apache.arrow.flatbuf.UnionMode;\nexport var IntervalUnit = Schema_.org.apache.arrow.flatbuf.IntervalUnit;\nexport var MessageHeader = Message_.org.apache.arrow.flatbuf.MessageHeader;\nexport var MetadataVersion = Schema_.org.apache.arrow.flatbuf.MetadataVersion;\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 var Type;\n(function (Type) {\n    /** The default placeholder type */\n    Type[Type[\"NONE\"] = 0] = \"NONE\";\n    /** A NULL type having no physical storage */\n    Type[Type[\"Null\"] = 1] = \"Null\";\n    /** Signed or unsigned 8, 16, 32, or 64-bit little-endian integer */\n    Type[Type[\"Int\"] = 2] = \"Int\";\n    /** 2, 4, or 8-byte floating point value */\n    Type[Type[\"Float\"] = 3] = \"Float\";\n    /** Variable-length bytes (no guarantee of UTF8-ness) */\n    Type[Type[\"Binary\"] = 4] = \"Binary\";\n    /** UTF8 variable-length string as List<Char> */\n    Type[Type[\"Utf8\"] = 5] = \"Utf8\";\n    /** Boolean as 1 bit, LSB bit-packed ordering */\n    Type[Type[\"Bool\"] = 6] = \"Bool\";\n    /** Precision-and-scale-based decimal type. Storage type depends on the parameters. */\n    Type[Type[\"Decimal\"] = 7] = \"Decimal\";\n    /** int32_t days or int64_t milliseconds since the UNIX epoch */\n    Type[Type[\"Date\"] = 8] = \"Date\";\n    /** Time as signed 32 or 64-bit integer, representing either seconds, milliseconds, microseconds, or nanoseconds since midnight since midnight */\n    Type[Type[\"Time\"] = 9] = \"Time\";\n    /** Exact timestamp encoded with int64 since UNIX epoch (Default unit millisecond) */\n    Type[Type[\"Timestamp\"] = 10] = \"Timestamp\";\n    /** YEAR_MONTH or DAY_TIME interval in SQL style */\n    Type[Type[\"Interval\"] = 11] = \"Interval\";\n    /** A list of some logical data type */\n    Type[Type[\"List\"] = 12] = \"List\";\n    /** Struct of logical types */\n    Type[Type[\"Struct\"] = 13] = \"Struct\";\n    /** Union of logical types */\n    Type[Type[\"Union\"] = 14] = \"Union\";\n    /** Fixed-size binary. Each value occupies the same number of bytes */\n    Type[Type[\"FixedSizeBinary\"] = 15] = \"FixedSizeBinary\";\n    /** Fixed-size list. Each value occupies the same number of bytes */\n    Type[Type[\"FixedSizeList\"] = 16] = \"FixedSizeList\";\n    /** Map of named logical types */\n    Type[Type[\"Map\"] = 17] = \"Map\";\n    /** Dictionary aka Category type */\n    Type[Type[\"Dictionary\"] = -1] = \"Dictionary\";\n    Type[Type[\"Int8\"] = -2] = \"Int8\";\n    Type[Type[\"Int16\"] = -3] = \"Int16\";\n    Type[Type[\"Int32\"] = -4] = \"Int32\";\n    Type[Type[\"Int64\"] = -5] = \"Int64\";\n    Type[Type[\"Uint8\"] = -6] = \"Uint8\";\n    Type[Type[\"Uint16\"] = -7] = \"Uint16\";\n    Type[Type[\"Uint32\"] = -8] = \"Uint32\";\n    Type[Type[\"Uint64\"] = -9] = \"Uint64\";\n    Type[Type[\"Float16\"] = -10] = \"Float16\";\n    Type[Type[\"Float32\"] = -11] = \"Float32\";\n    Type[Type[\"Float64\"] = -12] = \"Float64\";\n    Type[Type[\"DateDay\"] = -13] = \"DateDay\";\n    Type[Type[\"DateMillisecond\"] = -14] = \"DateMillisecond\";\n    Type[Type[\"TimestampSecond\"] = -15] = \"TimestampSecond\";\n    Type[Type[\"TimestampMillisecond\"] = -16] = \"TimestampMillisecond\";\n    Type[Type[\"TimestampMicrosecond\"] = -17] = \"TimestampMicrosecond\";\n    Type[Type[\"TimestampNanosecond\"] = -18] = \"TimestampNanosecond\";\n    Type[Type[\"TimeSecond\"] = -19] = \"TimeSecond\";\n    Type[Type[\"TimeMillisecond\"] = -20] = \"TimeMillisecond\";\n    Type[Type[\"TimeMicrosecond\"] = -21] = \"TimeMicrosecond\";\n    Type[Type[\"TimeNanosecond\"] = -22] = \"TimeNanosecond\";\n    Type[Type[\"DenseUnion\"] = -23] = \"DenseUnion\";\n    Type[Type[\"SparseUnion\"] = -24] = \"SparseUnion\";\n    Type[Type[\"IntervalDayTime\"] = -25] = \"IntervalDayTime\";\n    Type[Type[\"IntervalYearMonth\"] = -26] = \"IntervalYearMonth\";\n})(Type || (Type = {}));\nexport var BufferType;\n(function (BufferType) {\n    /**\n     * used in List type, Dense Union and variable length primitive types (String, Binary)\n     */\n    BufferType[BufferType[\"OFFSET\"] = 0] = \"OFFSET\";\n    /**\n     * actual data, either wixed width primitive types in slots or variable width delimited by an OFFSET vector\n     */\n    BufferType[BufferType[\"DATA\"] = 1] = \"DATA\";\n    /**\n     * Bit vector indicating if each value is null\n     */\n    BufferType[BufferType[\"VALIDITY\"] = 2] = \"VALIDITY\";\n    /**\n     * Type vector used in Union type\n     */\n    BufferType[BufferType[\"TYPE\"] = 3] = \"TYPE\";\n})(BufferType || (BufferType = {}));\n\n//# sourceMappingURL=enum.mjs.map\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/** @ignore */\nexport function getBool(_data, _index, byte, bit) {\n    return (byte & 1 << bit) !== 0;\n}\n/** @ignore */\nexport function getBit(_data, _index, byte, bit) {\n    return (byte & 1 << bit) >> bit;\n}\n/** @ignore */\nexport function setBool(bytes, index, value) {\n    return value ?\n        !!(bytes[index >> 3] |= (1 << (index % 8))) || true :\n        !(bytes[index >> 3] &= ~(1 << (index % 8))) && false;\n}\n/** @ignore */\nexport function truncateBitmap(offset, length, bitmap) {\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/** @ignore */\nexport function packBools(values) {\n    let xs = [];\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) {\n        xs[i++] = byte;\n    }\n    let b = new Uint8Array((xs.length + 7) & ~7);\n    b.set(xs);\n    return b;\n}\n/** @ignore */\nexport function* iterateBits(bytes, begin, length, context, get) {\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 * 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, lhs, rhs) {\n    if (rhs - lhs <= 0) {\n        return 0;\n    }\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/** @ignore */\nexport function popcnt_array(arr, byteOffset, byteLength) {\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/** @ignore */\nexport function popcnt_uint32(uint32) {\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\n//# sourceMappingURL=bit.mjs.map\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.\nimport { Data } from './data';\nimport { Vector } from './vector';\nimport { Type, Precision, DateUnit, TimeUnit, IntervalUnit, UnionMode } from './enum';\nimport { DataType, } from './type';\nexport class Visitor {\n    visitMany(nodes, ...args) {\n        return nodes.map((node, i) => this.visit(node, ...args.map((x) => x[i])));\n    }\n    visit(...args) {\n        return this.getVisitFn(args[0], false).apply(this, args);\n    }\n    getVisitFn(node, throwIfNotFound = true) {\n        return getVisitFn(this, node, throwIfNotFound);\n    }\n    visitNull(_node, ..._args) { return null; }\n    visitBool(_node, ..._args) { return null; }\n    visitInt(_node, ..._args) { return null; }\n    visitFloat(_node, ..._args) { return null; }\n    visitUtf8(_node, ..._args) { return null; }\n    visitBinary(_node, ..._args) { return null; }\n    visitFixedSizeBinary(_node, ..._args) { return null; }\n    visitDate(_node, ..._args) { return null; }\n    visitTimestamp(_node, ..._args) { return null; }\n    visitTime(_node, ..._args) { return null; }\n    visitDecimal(_node, ..._args) { return null; }\n    visitList(_node, ..._args) { return null; }\n    visitStruct(_node, ..._args) { return null; }\n    visitUnion(_node, ..._args) { return null; }\n    visitDictionary(_node, ..._args) { return null; }\n    visitInterval(_node, ..._args) { return null; }\n    visitFixedSizeList(_node, ..._args) { return null; }\n    visitMap(_node, ..._args) { return null; }\n}\n/** @ignore */\nfunction getVisitFn(visitor, node, throwIfNotFound = true) {\n    let fn = null;\n    let dtype = Type.NONE;\n    // tslint:disable\n    if (node instanceof Data) {\n        dtype = inferDType(node.type);\n    }\n    else if (node instanceof Vector) {\n        dtype = inferDType(node.type);\n    }\n    else if (node instanceof DataType) {\n        dtype = inferDType(node);\n    }\n    else if (typeof (dtype = node) !== 'number') {\n        dtype = Type[node];\n    }\n    switch (dtype) {\n        case Type.Null:\n            fn = visitor.visitNull;\n            break;\n        case Type.Bool:\n            fn = visitor.visitBool;\n            break;\n        case Type.Int:\n            fn = visitor.visitInt;\n            break;\n        case Type.Int8:\n            fn = visitor.visitInt8 || visitor.visitInt;\n            break;\n        case Type.Int16:\n            fn = visitor.visitInt16 || visitor.visitInt;\n            break;\n        case Type.Int32:\n            fn = visitor.visitInt32 || visitor.visitInt;\n            break;\n        case Type.Int64:\n            fn = visitor.visitInt64 || visitor.visitInt;\n            break;\n        case Type.Uint8:\n            fn = visitor.visitUint8 || visitor.visitInt;\n            break;\n        case Type.Uint16:\n            fn = visitor.visitUint16 || visitor.visitInt;\n            break;\n        case Type.Uint32:\n            fn = visitor.visitUint32 || visitor.visitInt;\n            break;\n        case Type.Uint64:\n            fn = visitor.visitUint64 || visitor.visitInt;\n            break;\n        case Type.Float:\n            fn = visitor.visitFloat;\n            break;\n        case Type.Float16:\n            fn = visitor.visitFloat16 || visitor.visitFloat;\n            break;\n        case Type.Float32:\n            fn = visitor.visitFloat32 || visitor.visitFloat;\n            break;\n        case Type.Float64:\n            fn = visitor.visitFloat64 || visitor.visitFloat;\n            break;\n        case Type.Utf8:\n            fn = visitor.visitUtf8;\n            break;\n        case Type.Binary:\n            fn = visitor.visitBinary;\n            break;\n        case Type.FixedSizeBinary:\n            fn = visitor.visitFixedSizeBinary;\n            break;\n        case Type.Date:\n            fn = visitor.visitDate;\n            break;\n        case Type.DateDay:\n            fn = visitor.visitDateDay || visitor.visitDate;\n            break;\n        case Type.DateMillisecond:\n            fn = visitor.visitDateMillisecond || visitor.visitDate;\n            break;\n        case Type.Timestamp:\n            fn = visitor.visitTimestamp;\n            break;\n        case Type.TimestampSecond:\n            fn = visitor.visitTimestampSecond || visitor.visitTimestamp;\n            break;\n        case Type.TimestampMillisecond:\n            fn = visitor.visitTimestampMillisecond || visitor.visitTimestamp;\n            break;\n        case Type.TimestampMicrosecond:\n            fn = visitor.visitTimestampMicrosecond || visitor.visitTimestamp;\n            break;\n        case Type.TimestampNanosecond:\n            fn = visitor.visitTimestampNanosecond || visitor.visitTimestamp;\n            break;\n        case Type.Time:\n            fn = visitor.visitTime;\n            break;\n        case Type.TimeSecond:\n            fn = visitor.visitTimeSecond || visitor.visitTime;\n            break;\n        case Type.TimeMillisecond:\n            fn = visitor.visitTimeMillisecond || visitor.visitTime;\n            break;\n        case Type.TimeMicrosecond:\n            fn = visitor.visitTimeMicrosecond || visitor.visitTime;\n            break;\n        case Type.TimeNanosecond:\n            fn = visitor.visitTimeNanosecond || visitor.visitTime;\n            break;\n        case Type.Decimal:\n            fn = visitor.visitDecimal;\n            break;\n        case Type.List:\n            fn = visitor.visitList;\n            break;\n        case Type.Struct:\n            fn = visitor.visitStruct;\n            break;\n        case Type.Union:\n            fn = visitor.visitUnion;\n            break;\n        case Type.DenseUnion:\n            fn = visitor.visitDenseUnion || visitor.visitUnion;\n            break;\n        case Type.SparseUnion:\n            fn = visitor.visitSparseUnion || visitor.visitUnion;\n            break;\n        case Type.Dictionary:\n            fn = visitor.visitDictionary;\n            break;\n        case Type.Interval:\n            fn = visitor.visitInterval;\n            break;\n        case Type.IntervalDayTime:\n            fn = visitor.visitIntervalDayTime || visitor.visitInterval;\n            break;\n        case Type.IntervalYearMonth:\n            fn = visitor.visitIntervalYearMonth || visitor.visitInterval;\n            break;\n        case Type.FixedSizeList:\n            fn = visitor.visitFixedSizeList;\n            break;\n        case Type.Map:\n            fn = visitor.visitMap;\n            break;\n    }\n    if (typeof fn === 'function')\n        return fn;\n    if (!throwIfNotFound)\n        return () => null;\n    throw new Error(`Unrecognized type '${Type[dtype]}'`);\n}\n/** @ignore */\nfunction inferDType(type) {\n    switch (type.typeId) {\n        case Type.Null: return Type.Null;\n        case Type.Int:\n            const { bitWidth, isSigned } = type;\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.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.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.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.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.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.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// Add these here so they're picked up by the externs creator\n// in the build, and closure-compiler doesn't minify them away\nVisitor.prototype.visitInt8 = null;\nVisitor.prototype.visitInt16 = null;\nVisitor.prototype.visitInt32 = null;\nVisitor.prototype.visitInt64 = null;\nVisitor.prototype.visitUint8 = null;\nVisitor.prototype.visitUint16 = null;\nVisitor.prototype.visitUint32 = null;\nVisitor.prototype.visitUint64 = null;\nVisitor.prototype.visitFloat16 = null;\nVisitor.prototype.visitFloat32 = null;\nVisitor.prototype.visitFloat64 = null;\nVisitor.prototype.visitDateDay = null;\nVisitor.prototype.visitDateMillisecond = null;\nVisitor.prototype.visitTimestampSecond = null;\nVisitor.prototype.visitTimestampMillisecond = null;\nVisitor.prototype.visitTimestampMicrosecond = null;\nVisitor.prototype.visitTimestampNanosecond = null;\nVisitor.prototype.visitTimeSecond = null;\nVisitor.prototype.visitTimeMillisecond = null;\nVisitor.prototype.visitTimeMicrosecond = null;\nVisitor.prototype.visitTimeNanosecond = null;\nVisitor.prototype.visitDenseUnion = null;\nVisitor.prototype.visitSparseUnion = null;\nVisitor.prototype.visitIntervalDayTime = null;\nVisitor.prototype.visitIntervalYearMonth = null;\n\n//# sourceMappingURL=visitor.mjs.map\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.\nimport { Visitor } from '../visitor';\n/** @ignore */\nexport class TypeComparator extends Visitor {\n    compareSchemas(schema, other) {\n        return (schema === other) || (other instanceof schema.constructor &&\n            instance.compareFields(schema.fields, other.fields));\n    }\n    compareFields(fields, others) {\n        return (fields === others) || (Array.isArray(fields) &&\n            Array.isArray(others) &&\n            fields.length === others.length &&\n            fields.every((f, i) => instance.compareField(f, others[i])));\n    }\n    compareField(field, other) {\n        return (field === other) || (other instanceof field.constructor &&\n            field.name === other.name &&\n            field.nullable === other.nullable &&\n            instance.visit(field.type, other.type));\n    }\n}\nfunction compareConstructor(type, other) {\n    return other instanceof type.constructor;\n}\nfunction compareAny(type, other) {\n    return (type === other) || compareConstructor(type, other);\n}\nfunction compareInt(type, other) {\n    return (type === other) || (compareConstructor(type, other) &&\n        type.bitWidth === other.bitWidth &&\n        type.isSigned === other.isSigned);\n}\nfunction compareFloat(type, other) {\n    return (type === other) || (compareConstructor(type, other) &&\n        type.precision === other.precision);\n}\nfunction compareFixedSizeBinary(type, other) {\n    return (type === other) || (compareConstructor(type, other) &&\n        type.byteWidth === other.byteWidth);\n}\nfunction compareDate(type, other) {\n    return (type === other) || (compareConstructor(type, other) &&\n        type.unit === other.unit);\n}\nfunction compareTimestamp(type, other) {\n    return (type === other) || (compareConstructor(type, other) &&\n        type.unit === other.unit &&\n        type.timezone === other.timezone);\n}\nfunction compareTime(type, other) {\n    return (type === other) || (compareConstructor(type, other) &&\n        type.unit === other.unit &&\n        type.bitWidth === other.bitWidth);\n}\nfunction compareList(type, other) {\n    return (type === other) || (compareConstructor(type, other) &&\n        type.children.length === other.children.length &&\n        instance.compareFields(type.children, other.children));\n}\nfunction compareStruct(type, other) {\n    return (type === other) || (compareConstructor(type, other) &&\n        type.children.length === other.children.length &&\n        instance.compareFields(type.children, other.children));\n}\nfunction compareUnion(type, other) {\n    return (type === other) || (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}\nfunction compareDictionary(type, other) {\n    return (type === other) || (compareConstructor(type, other) &&\n        type.id === other.id &&\n        type.isOrdered === other.isOrdered &&\n        instance.visit(type.indices, other.indices) &&\n        instance.visit(type.dictionary, other.dictionary));\n}\nfunction compareInterval(type, other) {\n    return (type === other) || (compareConstructor(type, other) &&\n        type.unit === other.unit);\n}\nfunction compareFixedSizeList(type, other) {\n    return (type === other) || (compareConstructor(type, other) &&\n        type.listSize === other.listSize &&\n        type.children.length === other.children.length &&\n        instance.compareFields(type.children, other.children));\n}\nfunction compareMap(type, other) {\n    return (type === other) || (compareConstructor(type, other) &&\n        type.keysSorted === other.keysSorted &&\n        type.children.length === other.children.length &&\n        instance.compareFields(type.children, other.children));\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/** @ignore */\nexport const instance = new TypeComparator();\n\n//# sourceMappingURL=typecomparator.mjs.map\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.\nimport { instance as comparer } from './visitor/typecomparator';\nimport { Type, Precision, UnionMode, DateUnit, TimeUnit, IntervalUnit } from './enum';\n/**\n * An abstract base class for classes that encapsulate metadata about each of\n * the logical types that Arrow can represent.\n */\nexport class DataType {\n    /** @nocollapse */ static isNull(x) { return x && x.typeId === Type.Null; }\n    /** @nocollapse */ static isInt(x) { return x && x.typeId === Type.Int; }\n    /** @nocollapse */ static isFloat(x) { return x && x.typeId === Type.Float; }\n    /** @nocollapse */ static isBinary(x) { return x && x.typeId === Type.Binary; }\n    /** @nocollapse */ static isUtf8(x) { return x && x.typeId === Type.Utf8; }\n    /** @nocollapse */ static isBool(x) { return x && x.typeId === Type.Bool; }\n    /** @nocollapse */ static isDecimal(x) { return x && x.typeId === Type.Decimal; }\n    /** @nocollapse */ static isDate(x) { return x && x.typeId === Type.Date; }\n    /** @nocollapse */ static isTime(x) { return x && x.typeId === Type.Time; }\n    /** @nocollapse */ static isTimestamp(x) { return x && x.typeId === Type.Timestamp; }\n    /** @nocollapse */ static isInterval(x) { return x && x.typeId === Type.Interval; }\n    /** @nocollapse */ static isList(x) { return x && x.typeId === Type.List; }\n    /** @nocollapse */ static isStruct(x) { return x && x.typeId === Type.Struct; }\n    /** @nocollapse */ static isUnion(x) { return x && x.typeId === Type.Union; }\n    /** @nocollapse */ static isFixedSizeBinary(x) { return x && x.typeId === Type.FixedSizeBinary; }\n    /** @nocollapse */ static isFixedSizeList(x) { return x && x.typeId === Type.FixedSizeList; }\n    /** @nocollapse */ static isMap(x) { return x && x.typeId === Type.Map; }\n    /** @nocollapse */ static isDictionary(x) { return x && x.typeId === Type.Dictionary; }\n    get typeId() { return Type.NONE; }\n    compareTo(other) {\n        return comparer.visit(this, other);\n    }\n}\nDataType[Symbol.toStringTag] = ((proto) => {\n    proto.children = null;\n    proto.ArrayType = Array;\n    return proto[Symbol.toStringTag] = 'DataType';\n})(DataType.prototype);\n/** @ignore */\nexport class Null extends DataType {\n    toString() { return `Null`; }\n    get typeId() { return Type.Null; }\n}\nNull[Symbol.toStringTag] = ((proto) => {\n    return proto[Symbol.toStringTag] = 'Null';\n})(Null.prototype);\n/** @ignore */\nclass Int_ extends DataType {\n    constructor(isSigned, bitWidth) {\n        super();\n        this.isSigned = isSigned;\n        this.bitWidth = bitWidth;\n    }\n    get typeId() { return Type.Int; }\n    get ArrayType() {\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    toString() { return `${this.isSigned ? `I` : `Ui`}nt${this.bitWidth}`; }\n}\nInt_[Symbol.toStringTag] = ((proto) => {\n    proto.isSigned = null;\n    proto.bitWidth = null;\n    return proto[Symbol.toStringTag] = 'Int';\n})(Int_.prototype);\nexport { Int_ as Int };\n/** @ignore */\nexport class Int8 extends Int_ {\n    constructor() { super(true, 8); }\n}\n/** @ignore */\nexport class Int16 extends Int_ {\n    constructor() { super(true, 16); }\n}\n/** @ignore */\nexport class Int32 extends Int_ {\n    constructor() { super(true, 32); }\n}\n/** @ignore */\nexport class Int64 extends Int_ {\n    constructor() { super(true, 64); }\n}\n/** @ignore */\nexport class Uint8 extends Int_ {\n    constructor() { super(false, 8); }\n}\n/** @ignore */\nexport class Uint16 extends Int_ {\n    constructor() { super(false, 16); }\n}\n/** @ignore */\nexport class Uint32 extends Int_ {\n    constructor() { super(false, 32); }\n}\n/** @ignore */\nexport class Uint64 extends Int_ {\n    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/** @ignore */\nexport class Float extends DataType {\n    constructor(precision) {\n        super();\n        this.precision = precision;\n    }\n    get typeId() { return Type.Float; }\n    get ArrayType() {\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    toString() { return `Float${(this.precision << 5) || 16}`; }\n}\nFloat[Symbol.toStringTag] = ((proto) => {\n    proto.precision = null;\n    return proto[Symbol.toStringTag] = 'Float';\n})(Float.prototype);\n/** @ignore */\nexport class Float16 extends Float {\n    constructor() { super(Precision.HALF); }\n}\n/** @ignore */\nexport class Float32 extends Float {\n    constructor() { super(Precision.SINGLE); }\n}\n/** @ignore */\nexport class Float64 extends Float {\n    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/** @ignore */\nexport class Binary extends DataType {\n    constructor() {\n        super();\n    }\n    get typeId() { return Type.Binary; }\n    toString() { return `Binary`; }\n}\nBinary[Symbol.toStringTag] = ((proto) => {\n    proto.ArrayType = Uint8Array;\n    return proto[Symbol.toStringTag] = 'Binary';\n})(Binary.prototype);\n/** @ignore */\nexport class Utf8 extends DataType {\n    constructor() {\n        super();\n    }\n    get typeId() { return Type.Utf8; }\n    toString() { return `Utf8`; }\n}\nUtf8[Symbol.toStringTag] = ((proto) => {\n    proto.ArrayType = Uint8Array;\n    return proto[Symbol.toStringTag] = 'Utf8';\n})(Utf8.prototype);\n/** @ignore */\nexport class Bool extends DataType {\n    constructor() {\n        super();\n    }\n    get typeId() { return Type.Bool; }\n    toString() { return `Bool`; }\n}\nBool[Symbol.toStringTag] = ((proto) => {\n    proto.ArrayType = Uint8Array;\n    return proto[Symbol.toStringTag] = 'Bool';\n})(Bool.prototype);\n/** @ignore */\nexport class Decimal extends DataType {\n    constructor(scale, precision) {\n        super();\n        this.scale = scale;\n        this.precision = precision;\n    }\n    get typeId() { return Type.Decimal; }\n    toString() { return `Decimal[${this.precision}e${this.scale > 0 ? `+` : ``}${this.scale}]`; }\n}\nDecimal[Symbol.toStringTag] = ((proto) => {\n    proto.scale = null;\n    proto.precision = null;\n    proto.ArrayType = Uint32Array;\n    return proto[Symbol.toStringTag] = 'Decimal';\n})(Decimal.prototype);\n/** @ignore */\nexport class Date_ extends DataType {\n    constructor(unit) {\n        super();\n        this.unit = unit;\n    }\n    get typeId() { return Type.Date; }\n    toString() { return `Date${(this.unit + 1) * 32}<${DateUnit[this.unit]}>`; }\n}\nDate_[Symbol.toStringTag] = ((proto) => {\n    proto.unit = null;\n    proto.ArrayType = Int32Array;\n    return proto[Symbol.toStringTag] = 'Date';\n})(Date_.prototype);\n/** @ignore */\nexport class DateDay extends Date_ {\n    constructor() { super(DateUnit.DAY); }\n}\n/** @ignore */\nexport class DateMillisecond extends Date_ {\n    constructor() { super(DateUnit.MILLISECOND); }\n}\n/** @ignore */\nclass Time_ extends DataType {\n    constructor(unit, bitWidth) {\n        super();\n        this.unit = unit;\n        this.bitWidth = bitWidth;\n    }\n    get typeId() { return Type.Time; }\n    toString() { return `Time${this.bitWidth}<${TimeUnit[this.unit]}>`; }\n}\nTime_[Symbol.toStringTag] = ((proto) => {\n    proto.unit = null;\n    proto.bitWidth = null;\n    proto.ArrayType = Int32Array;\n    return proto[Symbol.toStringTag] = 'Time';\n})(Time_.prototype);\nexport { Time_ as Time };\n/** @ignore */\nexport class TimeSecond extends Time_ {\n    constructor() { super(TimeUnit.SECOND, 32); }\n}\n/** @ignore */\nexport class TimeMillisecond extends Time_ {\n    constructor() { super(TimeUnit.MILLISECOND, 32); }\n}\n/** @ignore */\nexport class TimeMicrosecond extends Time_ {\n    constructor() { super(TimeUnit.MICROSECOND, 64); }\n}\n/** @ignore */\nexport class TimeNanosecond extends Time_ {\n    constructor() { super(TimeUnit.NANOSECOND, 64); }\n}\n/** @ignore */\nclass Timestamp_ extends DataType {\n    constructor(unit, timezone) {\n        super();\n        this.unit = unit;\n        this.timezone = timezone;\n    }\n    get typeId() { return Type.Timestamp; }\n    toString() { return `Timestamp<${TimeUnit[this.unit]}${this.timezone ? `, ${this.timezone}` : ``}>`; }\n}\nTimestamp_[Symbol.toStringTag] = ((proto) => {\n    proto.unit = null;\n    proto.timezone = null;\n    proto.ArrayType = Int32Array;\n    return proto[Symbol.toStringTag] = 'Timestamp';\n})(Timestamp_.prototype);\nexport { Timestamp_ as Timestamp };\n/** @ignore */\nexport class TimestampSecond extends Timestamp_ {\n    constructor(timezone) { super(TimeUnit.SECOND, timezone); }\n}\n/** @ignore */\nexport class TimestampMillisecond extends Timestamp_ {\n    constructor(timezone) { super(TimeUnit.MILLISECOND, timezone); }\n}\n/** @ignore */\nexport class TimestampMicrosecond extends Timestamp_ {\n    constructor(timezone) { super(TimeUnit.MICROSECOND, timezone); }\n}\n/** @ignore */\nexport class TimestampNanosecond extends Timestamp_ {\n    constructor(timezone) { super(TimeUnit.NANOSECOND, timezone); }\n}\n/** @ignore */\nclass Interval_ extends DataType {\n    constructor(unit) {\n        super();\n        this.unit = unit;\n    }\n    get typeId() { return Type.Interval; }\n    toString() { return `Interval<${IntervalUnit[this.unit]}>`; }\n}\nInterval_[Symbol.toStringTag] = ((proto) => {\n    proto.unit = null;\n    proto.ArrayType = Int32Array;\n    return proto[Symbol.toStringTag] = 'Interval';\n})(Interval_.prototype);\nexport { Interval_ as Interval };\n/** @ignore */\nexport class IntervalDayTime extends Interval_ {\n    constructor() { super(IntervalUnit.DAY_TIME); }\n}\n/** @ignore */\nexport class IntervalYearMonth extends Interval_ {\n    constructor() { super(IntervalUnit.YEAR_MONTH); }\n}\n/** @ignore */\nexport class List extends DataType {\n    constructor(child) {\n        super();\n        this.children = [child];\n    }\n    get typeId() { return Type.List; }\n    toString() { return `List<${this.valueType}>`; }\n    get valueType() { return this.children[0].type; }\n    get valueField() { return this.children[0]; }\n    get ArrayType() { return this.valueType.ArrayType; }\n}\nList[Symbol.toStringTag] = ((proto) => {\n    proto.children = null;\n    return proto[Symbol.toStringTag] = 'List';\n})(List.prototype);\n/** @ignore */\nexport class Struct extends DataType {\n    constructor(children) {\n        super();\n        this.children = children;\n    }\n    get typeId() { return Type.Struct; }\n    toString() { return `Struct<{${this.children.map((f) => `${f.name}:${f.type}`).join(`, `)}}>`; }\n}\nStruct[Symbol.toStringTag] = ((proto) => {\n    proto.children = null;\n    return proto[Symbol.toStringTag] = 'Struct';\n})(Struct.prototype);\n/** @ignore */\nclass Union_ extends DataType {\n    constructor(mode, typeIds, children) {\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));\n    }\n    get typeId() { return Type.Union; }\n    toString() {\n        return `${this[Symbol.toStringTag]}<${this.children.map((x) => `${x.type}`).join(` | `)}>`;\n    }\n}\nUnion_[Symbol.toStringTag] = ((proto) => {\n    proto.mode = null;\n    proto.typeIds = null;\n    proto.children = null;\n    proto.typeIdToChildIndex = null;\n    proto.ArrayType = Int8Array;\n    return proto[Symbol.toStringTag] = 'Union';\n})(Union_.prototype);\nexport { Union_ as Union };\n/** @ignore */\nexport class DenseUnion extends Union_ {\n    constructor(typeIds, children) {\n        super(UnionMode.Dense, typeIds, children);\n    }\n}\n/** @ignore */\nexport class SparseUnion extends Union_ {\n    constructor(typeIds, children) {\n        super(UnionMode.Sparse, typeIds, children);\n    }\n}\n/** @ignore */\nexport class FixedSizeBinary extends DataType {\n    constructor(byteWidth) {\n        super();\n        this.byteWidth = byteWidth;\n    }\n    get typeId() { return Type.FixedSizeBinary; }\n    toString() { return `FixedSizeBinary[${this.byteWidth}]`; }\n}\nFixedSizeBinary[Symbol.toStringTag] = ((proto) => {\n    proto.byteWidth = null;\n    proto.ArrayType = Uint8Array;\n    return proto[Symbol.toStringTag] = 'FixedSizeBinary';\n})(FixedSizeBinary.prototype);\n/** @ignore */\nexport class FixedSizeList extends DataType {\n    constructor(listSize, child) {\n        super();\n        this.listSize = listSize;\n        this.children = [child];\n    }\n    get typeId() { return Type.FixedSizeList; }\n    get valueType() { return this.children[0].type; }\n    get valueField() { return this.children[0]; }\n    get ArrayType() { return this.valueType.ArrayType; }\n    toString() { return `FixedSizeList[${this.listSize}]<${this.valueType}>`; }\n}\nFixedSizeList[Symbol.toStringTag] = ((proto) => {\n    proto.children = null;\n    proto.listSize = null;\n    return proto[Symbol.toStringTag] = 'FixedSizeList';\n})(FixedSizeList.prototype);\n/** @ignore */\nexport class Map_ extends DataType {\n    constructor(child, keysSorted = false) {\n        super();\n        this.children = [child];\n        this.keysSorted = keysSorted;\n    }\n    get typeId() { return Type.Map; }\n    get keyType() { return this.children[0].type.children[0].type; }\n    get valueType() { return this.children[0].type.children[1].type; }\n    toString() { return `Map<{${this.children[0].type.children.map((f) => `${f.name}:${f.type}`).join(`, `)}}>`; }\n}\nMap_[Symbol.toStringTag] = ((proto) => {\n    proto.children = null;\n    proto.keysSorted = null;\n    return proto[Symbol.toStringTag] = 'Map_';\n})(Map_.prototype);\n/** @ignore */\nconst getId = ((atomicDictionaryId) => () => ++atomicDictionaryId)(-1);\n/** @ignore */\nexport class Dictionary extends DataType {\n    constructor(dictionary, indices, id, isOrdered) {\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    get typeId() { return Type.Dictionary; }\n    get children() { return this.dictionary.children; }\n    get valueType() { return this.dictionary; }\n    get ArrayType() { return this.dictionary.ArrayType; }\n    toString() { return `Dictionary<${this.indices}, ${this.dictionary}>`; }\n}\nDictionary[Symbol.toStringTag] = ((proto) => {\n    proto.id = null;\n    proto.indices = null;\n    proto.isOrdered = null;\n    proto.dictionary = null;\n    return proto[Symbol.toStringTag] = 'Dictionary';\n})(Dictionary.prototype);\n/** @ignore */\nexport function strideForType(type) {\n    let t = type;\n    switch (type.typeId) {\n        case Type.Decimal: return 4;\n        case Type.Timestamp: return 2;\n        case Type.Date: return 1 + t.unit;\n        case Type.Interval: return 1 + t.unit;\n        case Type.Int: return 1 + +(t.bitWidth > 32);\n        case Type.Time: return 1 + +(t.bitWidth > 32);\n        case Type.FixedSizeList: return t.listSize;\n        case Type.FixedSizeBinary: return t.byteWidth;\n        default: return 1;\n    }\n}\n\n//# sourceMappingURL=type.mjs.map\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.\nimport { truncateBitmap } from './util/bit';\nimport { popcnt_bit_range } from './util/bit';\nimport { BufferType, UnionMode, Type } from './enum';\nimport { strideForType } from './type';\nimport { toArrayBufferView, toUint8Array, toInt32Array } from './util/buffer';\n/** @ignore */ export const kUnknownNullCount = -1;\n/** @ignore */\nexport class Data {\n    constructor(type, offset, length, nullCount, buffers, childData, dictionary) {\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);\n        let buffer;\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        }\n        else {\n            this.stride = strideForType(type);\n            if (buffers) {\n                (buffer = buffers[0]) && (this.valueOffsets = buffer);\n                (buffer = buffers[1]) && (this.values = buffer);\n                (buffer = buffers[2]) && (this.nullBitmap = buffer);\n                (buffer = buffers[3]) && (this.typeIds = buffer);\n            }\n        }\n    }\n    get typeId() { return this.type.typeId; }\n    get ArrayType() { return this.type.ArrayType; }\n    get buffers() {\n        return [this.valueOffsets, this.values, this.nullBitmap, this.typeIds];\n    }\n    get byteLength() {\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    get nullCount() {\n        let nullCount = this._nullCount;\n        let nullBitmap;\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    clone(type, offset = this.offset, length = this.length, nullCount = this._nullCount, buffers = this, childData = this.childData) {\n        return new Data(type, offset, length, nullCount, buffers, childData, this.dictionary);\n    }\n    slice(offset, length) {\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(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    _changeLengthAndBackfillNullBitmap(newLength) {\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    _sliceBuffers(offset, length, stride, typeId) {\n        let arr, { 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    _sliceChildren(childData, offset, length) {\n        return childData.map((child) => child.slice(offset, length));\n    }\n    //\n    // Convenience methods for creating Data instances for each of the Arrow Vector types\n    //\n    /** @nocollapse */\n    static new(type, offset, length, nullCount, buffers, childData, dictionary) {\n        if (buffers instanceof Data) {\n            buffers = buffers.buffers;\n        }\n        else if (!buffers) {\n            buffers = [];\n        }\n        switch (type.typeId) {\n            case Type.Null: return Data.Null(type, offset, length);\n            case Type.Int: return Data.Int(type, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []);\n            case Type.Dictionary: return Data.Dictionary(type, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || [], dictionary);\n            case Type.Float: return Data.Float(type, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []);\n            case Type.Bool: return Data.Bool(type, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []);\n            case Type.Decimal: return Data.Decimal(type, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []);\n            case Type.Date: return Data.Date(type, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []);\n            case Type.Time: return Data.Time(type, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []);\n            case Type.Timestamp: return Data.Timestamp(type, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []);\n            case Type.Interval: return Data.Interval(type, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []);\n            case Type.FixedSizeBinary: return Data.FixedSizeBinary(type, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []);\n            case Type.Binary: return Data.Binary(type, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.OFFSET] || [], buffers[BufferType.DATA] || []);\n            case Type.Utf8: return Data.Utf8(type, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.OFFSET] || [], buffers[BufferType.DATA] || []);\n            case Type.List: return Data.List(type, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.OFFSET] || [], (childData || [])[0]);\n            case Type.FixedSizeList: return Data.FixedSizeList(type, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], (childData || [])[0]);\n            case Type.Struct: return Data.Struct(type, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], childData || []);\n            case Type.Map: return Data.Map(type, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.OFFSET] || [], (childData || [])[0]);\n            case Type.Union: return Data.Union(type, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.TYPE] || [], buffers[BufferType.OFFSET] || childData, childData);\n        }\n        throw new Error(`Unrecognized typeId ${type.typeId}`);\n    }\n    /** @nocollapse */\n    static Null(type, offset, length) {\n        return new Data(type, offset, length, 0);\n    }\n    /** @nocollapse */\n    static Int(type, offset, length, nullCount, nullBitmap, data) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    static Dictionary(type, offset, length, nullCount, nullBitmap, data, dictionary) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.indices.ArrayType, data), toUint8Array(nullBitmap)], [], dictionary);\n    }\n    /** @nocollapse */\n    static Float(type, offset, length, nullCount, nullBitmap, data) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    static Bool(type, offset, length, nullCount, nullBitmap, data) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    static Decimal(type, offset, length, nullCount, nullBitmap, data) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    static Date(type, offset, length, nullCount, nullBitmap, data) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    static Time(type, offset, length, nullCount, nullBitmap, data) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    static Timestamp(type, offset, length, nullCount, nullBitmap, data) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    static Interval(type, offset, length, nullCount, nullBitmap, data) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    static FixedSizeBinary(type, offset, length, nullCount, nullBitmap, data) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    static Binary(type, offset, length, nullCount, nullBitmap, valueOffsets, data) {\n        return new Data(type, offset, length, nullCount, [toInt32Array(valueOffsets), toUint8Array(data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    static Utf8(type, offset, length, nullCount, nullBitmap, valueOffsets, data) {\n        return new Data(type, offset, length, nullCount, [toInt32Array(valueOffsets), toUint8Array(data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    static List(type, offset, length, nullCount, nullBitmap, valueOffsets, child) {\n        return new Data(type, offset, length, nullCount, [toInt32Array(valueOffsets), undefined, toUint8Array(nullBitmap)], [child]);\n    }\n    /** @nocollapse */\n    static FixedSizeList(type, offset, length, nullCount, nullBitmap, child) {\n        return new Data(type, offset, length, nullCount, [undefined, undefined, toUint8Array(nullBitmap)], [child]);\n    }\n    /** @nocollapse */\n    static Struct(type, offset, length, nullCount, nullBitmap, children) {\n        return new Data(type, offset, length, nullCount, [undefined, undefined, toUint8Array(nullBitmap)], children);\n    }\n    /** @nocollapse */\n    static Map(type, offset, length, nullCount, nullBitmap, valueOffsets, child) {\n        return new Data(type, offset, length, nullCount, [toInt32Array(valueOffsets), undefined, toUint8Array(nullBitmap)], [child]);\n    }\n    /** @nocollapse */\n    static Union(type, offset, length, nullCount, nullBitmap, typeIds, valueOffsetsOrChildren, children) {\n        const buffers = [\n            undefined, undefined,\n            toUint8Array(nullBitmap),\n            toArrayBufferView(type.ArrayType, typeIds)\n        ];\n        if (type.mode === UnionMode.Sparse) {\n            return new Data(type, offset, length, nullCount, buffers, valueOffsetsOrChildren);\n        }\n        buffers[BufferType.OFFSET] = toInt32Array(valueOffsetsOrChildren);\n        return new Data(type, offset, length, nullCount, buffers, children);\n    }\n}\nData.prototype.childData = Object.freeze([]);\n\n//# sourceMappingURL=data.mjs.map\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/** @ignore */ const undf = void (0);\n/** @ignore */\nexport function valueToString(x) {\n    if (x === null) {\n        return 'null';\n    }\n    if (x === undf) {\n        return 'undefined';\n    }\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\n//# sourceMappingURL=pretty.mjs.map\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.\nimport { valueToString } from '../util/pretty';\nimport { BigIntAvailable } from '../util/compat';\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(nullValues) {\n    if (!nullValues || nullValues.length <= 0) {\n        // @ts-ignore\n        return function isValid(value) { return true; };\n    }\n    let fnBody = '';\n    let noNaNs = nullValues.filter((x) => x === x);\n    if (noNaNs.length > 0) {\n        fnBody = `\n    switch (x) {${noNaNs.map((x) => `\n        case ${valueToCase(x)}:`).join('')}\n            return false;\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    return new Function(`x`, `${fnBody}\\nreturn true;`);\n}\n/** @ignore */\nfunction valueToCase(x) {\n    if (typeof x !== 'bigint') {\n        return valueToString(x);\n    }\n    else if (BigIntAvailable) {\n        return `${valueToString(x)}n`;\n    }\n    return `\"${valueToString(x)}\"`;\n}\n\n//# sourceMappingURL=valid.mjs.map\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.\nimport { memcpy } from '../util/buffer';\nimport { BigIntAvailable, BigInt64Array, BigUint64Array } from '../util/compat';\n/** @ignore */\nconst roundLengthUpToNearest64Bytes = (len, BPE) => ((((len * BPE) + 63) & ~63) || 64) / BPE;\n/** @ignore */\nconst sliceOrExtendArray = (arr, len = 0) => (arr.length >= len ? arr.subarray(0, len) : memcpy(new arr.constructor(len), arr, 0));\n/** @ignore */\nexport class BufferBuilder {\n    constructor(buffer, stride = 1) {\n        this.buffer = buffer;\n        this.stride = stride;\n        this.BYTES_PER_ELEMENT = buffer.BYTES_PER_ELEMENT;\n        this.ArrayType = buffer.constructor;\n        this._resize(this.length = buffer.length / stride | 0);\n    }\n    get byteLength() { return this.length * this.stride * this.BYTES_PER_ELEMENT | 0; }\n    get reservedLength() { return this.buffer.length / this.stride; }\n    get reservedByteLength() { return this.buffer.byteLength; }\n    // @ts-ignore\n    set(index, value) { return this; }\n    append(value) { return this.set(this.length, value); }\n    reserve(extra) {\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        return this;\n    }\n    flush(length = this.length) {\n        length = roundLengthUpToNearest64Bytes(length * this.stride, this.BYTES_PER_ELEMENT);\n        const array = sliceOrExtendArray(this.buffer, length);\n        this.clear();\n        return array;\n    }\n    clear() {\n        this.length = 0;\n        this._resize(0);\n        return this;\n    }\n    _resize(newLength) {\n        return this.buffer = memcpy(new this.ArrayType(newLength), this.buffer);\n    }\n}\nBufferBuilder.prototype.offset = 0;\n/** @ignore */\nexport class DataBufferBuilder extends BufferBuilder {\n    last() { return this.get(this.length - 1); }\n    get(index) { return this.buffer[index]; }\n    set(index, value) {\n        this.reserve(index - this.length + 1);\n        this.buffer[index * this.stride] = value;\n        return this;\n    }\n}\n/** @ignore */\nexport class BitmapBufferBuilder extends DataBufferBuilder {\n    constructor(data = new Uint8Array(0)) {\n        super(data, 1 / 8);\n        this.numValid = 0;\n    }\n    get numInvalid() { return this.length - this.numValid; }\n    get(idx) { return this.buffer[idx >> 3] >> idx % 8 & 1; }\n    set(idx, val) {\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    clear() {\n        this.numValid = 0;\n        return super.clear();\n    }\n}\n/** @ignore */\nexport class OffsetsBufferBuilder extends DataBufferBuilder {\n    constructor(data = new Int32Array(1)) { super(data, 1); }\n    append(value) {\n        return this.set(this.length - 1, value);\n    }\n    set(index, value) {\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    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/** @ignore */\nexport class WideBufferBuilder extends BufferBuilder {\n    get ArrayType64() {\n        return this._ArrayType64 || (this._ArrayType64 = (this.buffer instanceof Int32Array ? BigInt64Array : BigUint64Array));\n    }\n    set(index, value) {\n        this.reserve(index - this.length + 1);\n        switch (typeof value) {\n            case 'bigint':\n                this.buffer64[index] = value;\n                break;\n            case 'number':\n                this.buffer[index * this.stride] = value;\n                break;\n            default: this.buffer.set(value, index * this.stride);\n        }\n        return this;\n    }\n    _resize(newLength) {\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\n//# sourceMappingURL=buffer.mjs.map\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.\nimport { Vector } from './vector';\nimport { BufferType } from './enum';\nimport { Data } from './data';\nimport { createIsValidFunction } from './builder/valid';\nimport { BitmapBufferBuilder, DataBufferBuilder, OffsetsBufferBuilder } from './builder/buffer';\nimport { strideForType } from './type';\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 class Builder {\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 }) {\n        /**\n         * The number of values written to the `Builder` that haven't been flushed yet.\n         * @readonly\n         */\n        this.length = 0;\n        /**\n         * A boolean indicating whether `Builder.prototype.finish()` has been called on this `Builder`.\n         * @readonly\n         */\n        this.finished = false;\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     * 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    static new(options) { }\n    /** @nocollapse */\n    // @ts-ignore\n    static throughNode(options) {\n        throw new Error(`\"throughNode\" not available in this environment`);\n    }\n    /** @nocollapse */\n    // @ts-ignore\n    static throughDOM(options) {\n        throw new Error(`\"throughDOM\" not available in this environment`);\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    static throughIterable(options) {\n        return throughIterable(options);\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    static throughAsyncIterable(options) {\n        return throughAsyncIterable(options);\n    }\n    /**\n     * Flush the `Builder` and return a `Vector<T>`.\n     * @returns {Vector<T>} A `Vector<T>` of the flushed values.\n     */\n    toVector() { return Vector.new(this.flush()); }\n    get ArrayType() { return this.type.ArrayType; }\n    get nullCount() { return this._nulls.numInvalid; }\n    get numChildren() { return this.children.length; }\n    /**\n     * @returns The aggregate length (in bytes) of the values that have been written.\n     */\n    get byteLength() {\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     * @returns The aggregate number of rows that have been reserved to write new values.\n     */\n    get reservedLength() {\n        return this._nulls.reservedLength;\n    }\n    /**\n     * @returns The aggregate length (in bytes) that has been reserved to write new values.\n     */\n    get reservedByteLength() {\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    get valueOffsets() { return this._offsets ? this._offsets.buffer : null; }\n    get values() { return this._values ? this._values.buffer : null; }\n    get nullBitmap() { return this._nulls ? this._nulls.buffer : null; }\n    get typeIds() { return this._typeIds ? this._typeIds.buffer : null; }\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    append(value) { return this.set(this.length, value); }\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    isValid(value) { return this._isValid(value); }\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    set(index, value) {\n        if (this.setValid(index, this.isValid(value))) {\n            this.setValue(index, value);\n        }\n        return this;\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    setValue(index, value) { this._setValue(this, index, value); }\n    setValid(index, valid) {\n        this.length = this._nulls.set(index, +valid).length;\n        return valid;\n    }\n    // @ts-ignore\n    addChild(child, name = `${this.numChildren}`) {\n        throw new Error(`Cannot append children to non-nested type \"${this.type}\"`);\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    getChildAt(index) {\n        return this.children[index] || null;\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    flush() {\n        const buffers = [];\n        const values = this._values;\n        const offsets = this._offsets;\n        const typeIds = this._typeIds;\n        const { length, nullCount } = this;\n        if (typeIds) { /* Unions */\n            buffers[BufferType.TYPE] = typeIds.flush(length);\n            // DenseUnions\n            offsets && (buffers[BufferType.OFFSET] = offsets.flush(length));\n        }\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        }\n        else if (values) { /* Fixed-width primitives (Int, Float, Decimal, Time, Timestamp, and Interval) */\n            buffers[BufferType.DATA] = values.flush(length);\n        }\n        nullCount > 0 && (buffers[BufferType.VALIDITY] = this._nulls.flush(length));\n        const data = Data.new(this.type, 0, length, nullCount, buffers, this.children.map((child) => child.flush()));\n        this.clear();\n        return data;\n    }\n    /**\n     * Finalize this `Builder`, and child builders if applicable.\n     * @returns {this} The finalized `Builder` instance.\n     */\n    finish() {\n        this.finished = true;\n        this.children.forEach((child) => child.finish());\n        return this;\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    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}\nBuilder.prototype.length = 1;\nBuilder.prototype.stride = 1;\nBuilder.prototype.children = null;\nBuilder.prototype.finished = false;\nBuilder.prototype.nullValues = null;\nBuilder.prototype._isValid = () => true;\n/** @ignore */\nexport class FixedWidthBuilder extends Builder {\n    constructor(opts) {\n        super(opts);\n        this._values = new DataBufferBuilder(new this.ArrayType(0), this.stride);\n    }\n    setValue(index, value) {\n        const values = this._values;\n        values.reserve(index - values.length + 1);\n        return super.setValue(index, value);\n    }\n}\n/** @ignore */\nexport class VariableWidthBuilder extends Builder {\n    constructor(opts) {\n        super(opts);\n        this._pendingLength = 0;\n        this._offsets = new OffsetsBufferBuilder();\n    }\n    setValue(index, value) {\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    setValid(index, isValid) {\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    clear() {\n        this._pendingLength = 0;\n        this._pending = undefined;\n        return super.clear();\n    }\n    flush() {\n        this._flush();\n        return super.flush();\n    }\n    finish() {\n        this._flush();\n        return super.finish();\n    }\n    _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}\n/** @ignore */\nfunction throughIterable(options) {\n    const { ['queueingStrategy']: queueingStrategy = 'count' } = options;\n    const { ['highWaterMark']: highWaterMark = queueingStrategy !== 'bytes' ? 1000 : 2 ** 14 } = options;\n    const sizeProperty = queueingStrategy !== 'bytes' ? 'length' : 'byteLength';\n    return function* (source) {\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/** @ignore */\nfunction throughAsyncIterable(options) {\n    const { ['queueingStrategy']: queueingStrategy = 'count' } = options;\n    const { ['highWaterMark']: highWaterMark = queueingStrategy !== 'bytes' ? 1000 : 2 ** 14 } = options;\n    const sizeProperty = queueingStrategy !== 'bytes' ? 'length' : 'byteLength';\n    return async function* (source) {\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\n//# sourceMappingURL=builder.mjs.map\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.\nimport { BitmapBufferBuilder } from './buffer';\nimport { Builder } from '../builder';\n/** @ignore */\nexport class BoolBuilder extends Builder {\n    constructor(options) {\n        super(options);\n        this._values = new BitmapBufferBuilder();\n    }\n    setValue(index, value) {\n        this._values.set(index, +value);\n    }\n}\n\n//# sourceMappingURL=bool.mjs.map\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.\nimport { Builder } from '../builder';\n/** @ignore */\nexport class NullBuilder extends Builder {\n    // @ts-ignore\n    setValue(index, value) { }\n    setValid(index, valid) {\n        this.length = Math.max(index + 1, this.length);\n        return valid;\n    }\n}\n\n//# sourceMappingURL=null.mjs.map\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.\nimport { FixedWidthBuilder } from '../builder';\n/** @ignore */\nexport class DateBuilder extends FixedWidthBuilder {\n}\n/** @ignore */\nexport class DateDayBuilder extends DateBuilder {\n}\n/** @ignore */\nexport class DateMillisecondBuilder extends DateBuilder {\n}\n\n//# sourceMappingURL=date.mjs.map\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.\nimport { FixedWidthBuilder } from '../builder';\n/** @ignore */\nexport class DecimalBuilder extends FixedWidthBuilder {\n}\n\n//# sourceMappingURL=decimal.mjs.map\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.\nimport { Dictionary } from '../type';\nimport { Builder } from '../builder';\n/** @ignore */\nexport class DictionaryBuilder extends Builder {\n    constructor({ 'type': type, 'nullValues': nulls, 'dictionaryHashFunction': hashFn }) {\n        super({ type: new Dictionary(type.dictionary, type.indices, type.id, type.isOrdered) });\n        this._nulls = null;\n        this._dictionaryOffset = 0;\n        this._keysToIndices = Object.create(null);\n        this.indices = Builder.new({ 'type': this.type.indices, 'nullValues': nulls });\n        this.dictionary = Builder.new({ 'type': this.type.dictionary, 'nullValues': null });\n        if (typeof hashFn === 'function') {\n            this.valueToKey = hashFn;\n        }\n    }\n    get values() { return this.indices.values; }\n    get nullCount() { return this.indices.nullCount; }\n    get nullBitmap() { return this.indices.nullBitmap; }\n    get byteLength() { return this.indices.byteLength + this.dictionary.byteLength; }\n    get reservedLength() { return this.indices.reservedLength + this.dictionary.reservedLength; }\n    get reservedByteLength() { return this.indices.reservedByteLength + this.dictionary.reservedByteLength; }\n    isValid(value) { return this.indices.isValid(value); }\n    setValid(index, valid) {\n        const indices = this.indices;\n        valid = indices.setValid(index, valid);\n        this.length = indices.length;\n        return valid;\n    }\n    setValue(index, value) {\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    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;\n        this.clear();\n        return data;\n    }\n    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    clear() {\n        this.indices.clear();\n        this.dictionary.clear();\n        return super.clear();\n    }\n    valueToKey(val) {\n        return typeof val === 'string' ? val : `${val}`;\n    }\n}\n\n//# sourceMappingURL=dictionary.mjs.map\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.\nimport { FixedWidthBuilder } from '../builder';\n/** @ignore */\nexport class FixedSizeBinaryBuilder extends FixedWidthBuilder {\n}\n\n//# sourceMappingURL=fixedsizebinary.mjs.map\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.\nconst f64 = new Float64Array(1);\nconst u32 = new Uint32Array(f64.buffer);\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) {\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 * 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) {\n    if (d !== d) {\n        return 0x7E00;\n    } // NaN\n    f64[0] = d;\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    let sign = (u32[1] & 0x80000000) >> 16 & 0xFFFF;\n    let expo = (u32[1] & 0x7ff00000), sigf = 0x0000;\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        }\n        else {\n            expo = (expo & 0x7C000000) >> 16;\n            sigf = (u32[1] & 0x000fffff) >> 10;\n        }\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    }\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        // 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    return sign | expo | sigf & 0xFFFF;\n}\n\n//# sourceMappingURL=math.mjs.map\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.\nimport { float64ToUint16 } from '../util/math';\nimport { FixedWidthBuilder } from '../builder';\n/** @ignore */\nexport class FloatBuilder extends FixedWidthBuilder {\n}\n/** @ignore */\nexport class Float16Builder extends FloatBuilder {\n    setValue(index, value) {\n        // convert JS float64 to a uint16\n        this._values.set(index, float64ToUint16(value));\n    }\n}\n/** @ignore */\nexport class Float32Builder extends FloatBuilder {\n    setValue(index, value) {\n        this._values.set(index, value);\n    }\n}\n/** @ignore */\nexport class Float64Builder extends FloatBuilder {\n    setValue(index, value) {\n        this._values.set(index, value);\n    }\n}\n\n//# sourceMappingURL=float.mjs.map\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.\nimport { toArrayBufferView } from './buffer';\nimport { BigIntAvailable, BigInt64Array, BigUint64Array } from './compat';\n/** @ignore */\nexport const isArrowBigNumSymbol = Symbol.for('isArrowBigNum');\n/** @ignore */\nfunction BigNum(x, ...xs) {\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}\nBigNum.prototype[isArrowBigNumSymbol] = true;\nBigNum.prototype.toJSON = function () { return `\"${bignumToString(this)}\"`; };\nBigNum.prototype.valueOf = function () { return bignumToNumber(this); };\nBigNum.prototype.toString = function () { return bignumToString(this); };\nBigNum.prototype[Symbol.toPrimitive] = function (hint = '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/** @ignore */\nfunction SignedBigNum(...args) { return BigNum.apply(this, args); }\n/** @ignore */\nfunction UnsignedBigNum(...args) { return BigNum.apply(this, args); }\n/** @ignore */\nfunction DecimalBigNum(...args) { return BigNum.apply(this, args); }\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/** @ignore */\nfunction bignumToNumber(bn) {\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/** @ignore */\nexport let bignumToString;\n/** @ignore */\nexport let bignumToBigInt;\nif (!BigIntAvailable) {\n    bignumToString = decimalToString;\n    bignumToBigInt = bignumToString;\n}\nelse {\n    bignumToBigInt = ((a) => a.byteLength === 8 ? new a['BigIntArray'](a.buffer, a.byteOffset, 1)[0] : decimalToString(a));\n    bignumToString = ((a) => a.byteLength === 8 ? `${new a['BigIntArray'](a.buffer, a.byteOffset, 1)[0]}` : decimalToString(a));\n}\n/** @ignore */\nfunction decimalToString(a) {\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/** @ignore */\nexport class BN {\n    constructor(num, isSigned) {\n        return BN.new(num, isSigned);\n    }\n    /** @nocollapse */\n    static new(num, isSigned) {\n        switch (isSigned) {\n            case true: return new SignedBigNum(num);\n            case false: return new UnsignedBigNum(num);\n        }\n        switch (num.constructor) {\n            case Int8Array:\n            case Int16Array:\n            case Int32Array:\n            case BigInt64Array:\n                return new SignedBigNum(num);\n        }\n        if (num.byteLength === 16) {\n            return new DecimalBigNum(num);\n        }\n        return new UnsignedBigNum(num);\n    }\n    /** @nocollapse */\n    static signed(num) {\n        return new SignedBigNum(num);\n    }\n    /** @nocollapse */\n    static unsigned(num) {\n        return new UnsignedBigNum(num);\n    }\n    /** @nocollapse */\n    static decimal(num) {\n        return new DecimalBigNum(num);\n    }\n}\n\n//# sourceMappingURL=bn.mjs.map\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.\nimport { bignumToBigInt } from '../util/bn';\nimport { WideBufferBuilder } from './buffer';\nimport { BigInt64Array } from '../util/compat';\nimport { FixedWidthBuilder } from '../builder';\n/** @ignore */\nexport class IntBuilder extends FixedWidthBuilder {\n    setValue(index, value) {\n        this._values.set(index, value);\n    }\n}\n/** @ignore */\nexport class Int8Builder extends IntBuilder {\n}\n/** @ignore */\nexport class Int16Builder extends IntBuilder {\n}\n/** @ignore */\nexport class Int32Builder extends IntBuilder {\n}\n/** @ignore */\nexport class Int64Builder extends IntBuilder {\n    constructor(options) {\n        if (options['nullValues']) {\n            options['nullValues'] = options['nullValues'].map(toBigInt);\n        }\n        super(options);\n        this._values = new WideBufferBuilder(new Int32Array(0), 2);\n    }\n    get values64() { return this._values.buffer64; }\n    isValid(value) { return super.isValid(toBigInt(value)); }\n}\n/** @ignore */\nexport class Uint8Builder extends IntBuilder {\n}\n/** @ignore */\nexport class Uint16Builder extends IntBuilder {\n}\n/** @ignore */\nexport class Uint32Builder extends IntBuilder {\n}\n/** @ignore */\nexport class Uint64Builder extends IntBuilder {\n    constructor(options) {\n        if (options['nullValues']) {\n            options['nullValues'] = options['nullValues'].map(toBigInt);\n        }\n        super(options);\n        this._values = new WideBufferBuilder(new Uint32Array(0), 2);\n    }\n    get values64() { return this._values.buffer64; }\n    isValid(value) { return super.isValid(toBigInt(value)); }\n}\nconst toBigInt = ((memo) => (value) => {\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\n//# sourceMappingURL=int.mjs.map\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.\nimport { FixedWidthBuilder } from '../builder';\n/** @ignore */\nexport class TimeBuilder extends FixedWidthBuilder {\n}\n/** @ignore */\nexport class TimeSecondBuilder extends TimeBuilder {\n}\n/** @ignore */\nexport class TimeMillisecondBuilder extends TimeBuilder {\n}\n/** @ignore */\nexport class TimeMicrosecondBuilder extends TimeBuilder {\n}\n/** @ignore */\nexport class TimeNanosecondBuilder extends TimeBuilder {\n}\n\n//# sourceMappingURL=time.mjs.map\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.\nimport { FixedWidthBuilder } from '../builder';\n/** @ignore */\nexport class TimestampBuilder extends FixedWidthBuilder {\n}\n/** @ignore */\nexport class TimestampSecondBuilder extends TimestampBuilder {\n}\n/** @ignore */\nexport class TimestampMillisecondBuilder extends TimestampBuilder {\n}\n/** @ignore */\nexport class TimestampMicrosecondBuilder extends TimestampBuilder {\n}\n/** @ignore */\nexport class TimestampNanosecondBuilder extends TimestampBuilder {\n}\n\n//# sourceMappingURL=timestamp.mjs.map\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.\nimport { FixedWidthBuilder } from '../builder';\n/** @ignore */\nexport class IntervalBuilder extends FixedWidthBuilder {\n}\n/** @ignore */\nexport class IntervalDayTimeBuilder extends IntervalBuilder {\n}\n/** @ignore */\nexport class IntervalYearMonthBuilder extends IntervalBuilder {\n}\n\n//# sourceMappingURL=interval.mjs.map\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.\nimport { toUint8Array } from '../util/buffer';\nimport { BufferBuilder } from './buffer';\nimport { VariableWidthBuilder } from '../builder';\n/** @ignore */\nexport class BinaryBuilder extends VariableWidthBuilder {\n    constructor(opts) {\n        super(opts);\n        this._values = new BufferBuilder(new Uint8Array(0));\n    }\n    get byteLength() {\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    setValue(index, value) {\n        return super.setValue(index, toUint8Array(value));\n    }\n    _flushPending(pending, pendingLength) {\n        const offsets = this._offsets;\n        const data = this._values.reserve(pendingLength).buffer;\n        let index = 0, length = 0, offset = 0, value;\n        for ([index, value] of pending) {\n            if (value === undefined) {\n                offsets.set(index, 0);\n            }\n            else {\n                length = value.length;\n                data.set(value, offset);\n                offsets.set(index, length);\n                offset += length;\n            }\n        }\n    }\n}\n\n//# sourceMappingURL=binary.mjs.map\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.\nimport { encodeUtf8 } from '../util/utf8';\nimport { BinaryBuilder } from './binary';\nimport { BufferBuilder } from './buffer';\nimport { VariableWidthBuilder } from '../builder';\n/** @ignore */\nexport class Utf8Builder extends VariableWidthBuilder {\n    constructor(opts) {\n        super(opts);\n        this._values = new BufferBuilder(new Uint8Array(0));\n    }\n    get byteLength() {\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    setValue(index, value) {\n        return super.setValue(index, encodeUtf8(value));\n    }\n    // @ts-ignore\n    _flushPending(pending, pendingLength) { }\n}\nUtf8Builder.prototype._flushPending = BinaryBuilder.prototype._flushPending;\n\n//# sourceMappingURL=utf8.mjs.map\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.\nimport { Vector } from '../vector';\n/** @ignore */\nexport class Run {\n    get length() { return this._values.length; }\n    get(index) { return this._values[index]; }\n    clear() { this._values = null; return this; }\n    bind(values) {\n        if (values instanceof Vector) {\n            return values;\n        }\n        this._values = values;\n        return this;\n    }\n}\n\n//# sourceMappingURL=run.mjs.map\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.\nimport { valueToString } from '../util/pretty';\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');\nclass Row {\n    constructor(parent, numKeys) {\n        this[kParent] = parent;\n        this.size = numKeys;\n    }\n    entries() { return this[Symbol.iterator](); }\n    has(key) { return this.get(key) !== undefined; }\n    get(key) {\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            }\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    set(key, val) {\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] = this.setValue(idx, val);\n            }\n        }\n        return this;\n    }\n    clear() { throw new Error(`Clearing ${this[Symbol.toStringTag]} not supported.`); }\n    delete(_) { throw new Error(`Deleting ${this[Symbol.toStringTag]} values not supported.`); }\n    *[Symbol.iterator]() {\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        for (let k, v, i = 0, kr, vr; !((kr = ki.next()).done || (vr = vi.next()).done); ++i) {\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    forEach(callbackfn, thisArg) {\n        const ki = this.keys();\n        const vi = this.values();\n        const callback = thisArg === undefined ? callbackfn :\n            (v, k, m) => 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        for (let k, v, i = 0, kr, vr; !((kr = ki.next()).done || (vr = vi.next()).done); ++i) {\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    toArray() { return [...this.values()]; }\n    toJSON() {\n        const obj = {};\n        this.forEach((val, key) => obj[key] = val);\n        return obj;\n    }\n    inspect() { return this.toString(); }\n    [kCustomInspect]() { return this.toString(); }\n    toString() {\n        const str = [];\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}\nRow[Symbol.toStringTag] = ((proto) => {\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[Symbol.toStringTag] = 'Row';\n})(Row.prototype);\nexport class MapRow extends Row {\n    constructor(slice) {\n        super(slice, slice.length);\n        return createRowProxy(this);\n    }\n    keys() {\n        return this[kParent].getChildAt(0)[Symbol.iterator]();\n    }\n    values() {\n        return this[kParent].getChildAt(1)[Symbol.iterator]();\n    }\n    getKey(idx) {\n        return this[kParent].getChildAt(0).get(idx);\n    }\n    getIndex(key) {\n        return this[kParent].getChildAt(0).indexOf(key);\n    }\n    getValue(index) {\n        return this[kParent].getChildAt(1).get(index);\n    }\n    setValue(index, value) {\n        this[kParent].getChildAt(1).set(index, value);\n    }\n}\nexport class StructRow extends Row {\n    constructor(parent) {\n        super(parent, parent.type.children.length);\n        return defineRowProxyProperties(this);\n    }\n    *keys() {\n        for (const field of this[kParent].type.children) {\n            yield field.name;\n        }\n    }\n    *values() {\n        for (const field of this[kParent].type.children) {\n            yield this[field.name];\n        }\n    }\n    getKey(idx) {\n        return this[kParent].type.children[idx].name;\n    }\n    getIndex(key) {\n        return this[kParent].type.children.findIndex((f) => f.name === key);\n    }\n    getValue(index) {\n        return this[kParent].getChildAt(index).get(this[kRowIndex]);\n    }\n    setValue(index, value) {\n        return this[kParent].getChildAt(index).set(this[kRowIndex], value);\n    }\n}\nObject.setPrototypeOf(Row.prototype, Map.prototype);\n/** @ignore */\nconst defineRowProxyProperties = (() => {\n    const desc = { enumerable: true, configurable: false, get: null, set: null };\n    return (row) => {\n        let idx = -1, ktoi = row[kKeyToIdx] || (row[kKeyToIdx] = new Map());\n        const getter = (key) => function () { return this.get(key); };\n        const setter = (key) => function (val) { 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/** @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 = {\n        isExtensible() { return false; },\n        deleteProperty() { return false; },\n        preventExtensions() { return true; },\n        ownKeys(row) { return [...row.keys()].map((x) => `${x}`); },\n        has(row, key) {\n            switch (key) {\n                case 'getKey':\n                case 'getIndex':\n                case 'getValue':\n                case 'setValue':\n                case 'toArray':\n                case 'toJSON':\n                case 'inspect':\n                case 'constructor':\n                case 'isPrototypeOf':\n                case 'propertyIsEnumerable':\n                case 'toString':\n                case 'toLocaleString':\n                case 'valueOf':\n                case 'size':\n                case 'has':\n                case 'get':\n                case 'set':\n                case 'clear':\n                case 'delete':\n                case 'keys':\n                case 'values':\n                case 'entries':\n                case 'forEach':\n                case '__proto__':\n                case '__defineGetter__':\n                case '__defineSetter__':\n                case 'hasOwnProperty':\n                case '__lookupGetter__':\n                case '__lookupSetter__':\n                case Symbol.iterator:\n                case Symbol.toStringTag:\n                case kParent:\n                case kRowIndex:\n                case kIdxToVal:\n                case kKeyToIdx:\n                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, key, receiver) {\n            switch (key) {\n                case 'getKey':\n                case 'getIndex':\n                case 'getValue':\n                case 'setValue':\n                case 'toArray':\n                case 'toJSON':\n                case 'inspect':\n                case 'constructor':\n                case 'isPrototypeOf':\n                case 'propertyIsEnumerable':\n                case 'toString':\n                case 'toLocaleString':\n                case 'valueOf':\n                case 'size':\n                case 'has':\n                case 'get':\n                case 'set':\n                case 'clear':\n                case 'delete':\n                case 'keys':\n                case 'values':\n                case 'entries':\n                case 'forEach':\n                case '__proto__':\n                case '__defineGetter__':\n                case '__defineSetter__':\n                case 'hasOwnProperty':\n                case '__lookupGetter__':\n                case '__lookupSetter__':\n                case Symbol.iterator:\n                case Symbol.toStringTag:\n                case kParent:\n                case kRowIndex:\n                case kIdxToVal:\n                case kKeyToIdx:\n                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, key, val, receiver) {\n            switch (key) {\n                case kParent:\n                case kRowIndex:\n                case kIdxToVal:\n                case kKeyToIdx:\n                    return Reflect.set(row, key, val, receiver);\n                case 'getKey':\n                case 'getIndex':\n                case 'getValue':\n                case 'setValue':\n                case 'toArray':\n                case 'toJSON':\n                case 'inspect':\n                case 'constructor':\n                case 'isPrototypeOf':\n                case 'propertyIsEnumerable':\n                case 'toString':\n                case 'toLocaleString':\n                case 'valueOf':\n                case 'size':\n                case 'has':\n                case 'get':\n                case 'set':\n                case 'clear':\n                case 'delete':\n                case 'keys':\n                case 'values':\n                case 'entries':\n                case 'forEach':\n                case '__proto__':\n                case '__defineGetter__':\n                case '__defineSetter__':\n                case 'hasOwnProperty':\n                case '__lookupGetter__':\n                case '__lookupSetter__':\n                case Symbol.iterator:\n                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 (row) => new Proxy(row, RowProxyHandler);\n})();\n\n//# sourceMappingURL=row.mjs.map\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.\nimport { Vector } from '../vector';\nimport { MapRow, StructRow } from '../vector/row';\nimport { compareArrayLike } from '../util/buffer';\nimport { BigInt, BigIntAvailable } from './compat';\n/** @ignore */\nexport function clampIndex(source, index, then) {\n    const length = source.length;\n    const adjust = index > -1 ? index : (length + (index % length));\n    return then ? then(source, adjust) : adjust;\n}\n/** @ignore */\nlet tmp;\n/** @ignore */\nexport function clampRange(source, begin, end, then) {\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    return then ? then(source, lhs, rhs) : [lhs, rhs];\n}\nconst big0 = BigIntAvailable ? BigInt(0) : 0;\nconst isNaNFast = (value) => value !== value;\n/** @ignore */\nexport function createElementComparator(search) {\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) => value === search\n            : (value) => (big0 + value) === search;\n    }\n    // Compare Dates\n    if (search instanceof Date) {\n        const valueOfSearch = search.valueOf();\n        return (value) => value instanceof Date ? (value.valueOf() === valueOfSearch) : false;\n    }\n    // Compare TypedArrays\n    if (ArrayBuffer.isView(search)) {\n        return (value) => value ? compareArrayLike(search, value) : false;\n    }\n    // Compare Maps and Rows\n    if (search instanceof Map) {\n        return creatMapComparator(search);\n    }\n    // Compare Array-likes\n    if (Array.isArray(search)) {\n        return createArrayLikeComparator(search);\n    }\n    // Compare Vectors\n    if (search instanceof Vector) {\n        return createVectorComparator(search);\n    }\n    // Compare non-empty Objects\n    return createObjectComparator(search);\n}\n/** @ignore */\nfunction createArrayLikeComparator(lhs) {\n    const comparators = [];\n    for (let i = -1, n = lhs.length; ++i < n;) {\n        comparators[i] = createElementComparator(lhs[i]);\n    }\n    return createSubElementsComparator(comparators);\n}\n/** @ignore */\nfunction creatMapComparator(lhs) {\n    let i = -1;\n    const comparators = [];\n    lhs.forEach((v) => comparators[++i] = createElementComparator(v));\n    return createSubElementsComparator(comparators);\n}\n/** @ignore */\nfunction createVectorComparator(lhs) {\n    const comparators = [];\n    for (let i = -1, n = lhs.length; ++i < n;) {\n        comparators[i] = createElementComparator(lhs.get(i));\n    }\n    return createSubElementsComparator(comparators);\n}\n/** @ignore */\nfunction createObjectComparator(lhs) {\n    const keys = Object.keys(lhs);\n    // Only compare non-empty Objects\n    if (keys.length === 0) {\n        return () => false;\n    }\n    const comparators = [];\n    for (let i = -1, n = keys.length; ++i < n;) {\n        comparators[i] = createElementComparator(lhs[keys[i]]);\n    }\n    return createSubElementsComparator(comparators, keys);\n}\nfunction createSubElementsComparator(comparators, keys) {\n    return (rhs) => {\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}\nfunction compareArray(comparators, arr) {\n    const n = comparators.length;\n    if (arr.length !== n) {\n        return false;\n    }\n    for (let i = -1; ++i < n;) {\n        if (!(comparators[i](arr[i]))) {\n            return false;\n        }\n    }\n    return true;\n}\nfunction compareVector(comparators, vec) {\n    const n = comparators.length;\n    if (vec.length !== n) {\n        return false;\n    }\n    for (let i = -1; ++i < n;) {\n        if (!(comparators[i](vec.get(i)))) {\n            return false;\n        }\n    }\n    return true;\n}\nfunction compareObject(comparators, obj, keys) {\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    let i = 0;\n    let n = comparators.length;\n    let rVal = rValItr.next();\n    let lKey = lKeyItr.next();\n    let rKey = rKeyItr.next();\n    for (; i < n && !lKey.done && !rKey.done && !rVal.done; ++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\n//# sourceMappingURL=vector.mjs.map\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.\nimport { clampRange } from '../util/vector';\nimport { DataType } from '../type';\nimport { selectChunkArgs } from '../util/args';\nimport { AbstractVector, Vector } from '../vector';\n/** @ignore */\nexport class Chunked extends AbstractVector {\n    constructor(type, chunks = [], offsets = calculateOffsets(chunks)) {\n        super();\n        this._nullCount = -1;\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    /** @nocollapse */\n    static flatten(...vectors) {\n        return selectChunkArgs(Vector, vectors);\n    }\n    /** @nocollapse */\n    static concat(...vectors) {\n        const chunks = Chunked.flatten(...vectors);\n        return new Chunked(chunks[0].type, chunks);\n    }\n    get type() { return this._type; }\n    get length() { return this._length; }\n    get chunks() { return this._chunks; }\n    get typeId() { return this._type.typeId; }\n    get VectorName() { return `Chunked<${this._type}>`; }\n    get data() {\n        return this._chunks[0] ? this._chunks[0].data : null;\n    }\n    get ArrayType() { return this._type.ArrayType; }\n    get numChildren() { return this._numChildren; }\n    get stride() { return this._chunks[0] ? this._chunks[0].stride : 1; }\n    get byteLength() {\n        return this._chunks.reduce((byteLength, chunk) => byteLength + chunk.byteLength, 0);\n    }\n    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    get indices() {\n        if (DataType.isDictionary(this._type)) {\n            if (!this._indices) {\n                const chunks = this._chunks;\n                this._indices = (chunks.length === 1\n                    ? chunks[0].indices\n                    : Chunked.concat(...chunks.map((x) => x.indices)));\n            }\n            return this._indices;\n        }\n        return null;\n    }\n    get dictionary() {\n        if (DataType.isDictionary(this._type)) {\n            return this._chunks[this._chunks.length - 1].data.dictionary;\n        }\n        return null;\n    }\n    *[Symbol.iterator]() {\n        for (const chunk of this._chunks) {\n            yield* chunk;\n        }\n    }\n    clone(chunks = this._chunks) {\n        return new Chunked(this._type, chunks);\n    }\n    concat(...others) {\n        return this.clone(Chunked.flatten(this, ...others));\n    }\n    slice(begin, end) {\n        return clampRange(this, begin, end, this._sliceInternal);\n    }\n    getChildAt(index) {\n        if (index < 0 || index >= this._numChildren) {\n            return null;\n        }\n        let columns = this._children || (this._children = []);\n        let child, field, chunks;\n        if (child = columns[index]) {\n            return child;\n        }\n        if (field = (this._type.children || [])[index]) {\n            chunks = this._chunks\n                .map((vector) => vector.getChildAt(index))\n                .filter((vec) => vec != null);\n            if (chunks.length > 0) {\n                return (columns[index] = new Chunked(field.type, chunks));\n            }\n        }\n        return null;\n    }\n    search(index, then) {\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) {\n            return null;\n        }\n        if (idx >= offsets[rhs]) {\n            return null;\n        }\n        if (rhs <= 1) {\n            return then ? then(this, 0, idx) : [0, idx];\n        }\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    isValid(index) {\n        return !!this.search(index, this.isValidInternal);\n    }\n    get(index) {\n        return this.search(index, this.getInternal);\n    }\n    set(index, value) {\n        this.search(index, ({ chunks }, i, j) => chunks[i].set(j, value));\n    }\n    indexOf(element, offset) {\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    toArray() {\n        const { chunks } = this;\n        const n = chunks.length;\n        let ArrayType = this._type.ArrayType;\n        if (n <= 0) {\n            return new ArrayType(0);\n        }\n        if (n <= 1) {\n            return chunks[0].toArray();\n        }\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 = 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    getInternal({ _chunks }, i, j) { return _chunks[i].get(j); }\n    isValidInternal({ _chunks }, i, j) { return _chunks[i].isValid(j); }\n    indexOfInternal({ _chunks }, chunkIndex, fromIndex, element) {\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    _sliceInternal(self, begin, end) {\n        const slices = [];\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) {\n                break;\n            }\n            // If the child is to the left of of the slice boundary, exclude\n            if (begin >= chunkOffset + chunkLength) {\n                continue;\n            }\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));\n        }\n        return self.clone(slices);\n    }\n}\n/** @ignore */\nfunction calculateOffsets(vectors) {\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/** @ignore */\nconst typedSet = (src, dst, offset) => {\n    dst.set(src, offset);\n    return (offset + src.length);\n};\n/** @ignore */\nconst arraySet = (src, dst, offset) => {\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//# sourceMappingURL=chunked.mjs.map\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.\nimport { Field } from './schema';\nimport { Vector } from './vector';\nimport { Chunked } from './vector/chunked';\nexport class Column extends Chunked {\n    constructor(field, vectors = [], offsets) {\n        vectors = Chunked.flatten(...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    /** @nocollapse */\n    static new(field, data, ...rest) {\n        const chunks = Chunked.flatten(Array.isArray(data) ? [...data, ...rest] :\n            data instanceof Vector ? [data, ...rest] :\n                [Vector.new(data, ...rest)]);\n        if (typeof field === 'string') {\n            const type = chunks[0].data.type;\n            field = new Field(field, type, true);\n        }\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    get field() { return this._field; }\n    get name() { return this._field.name; }\n    get nullable() { return this._field.nullable; }\n    get metadata() { return this._field.metadata; }\n    clone(chunks = this._chunks) {\n        return new Column(this._field, chunks);\n    }\n    getChildAt(index) {\n        if (index < 0 || index >= this.numChildren) {\n            return null;\n        }\n        let columns = this._children || (this._children = []);\n        let column, field, chunks;\n        if (column = columns[index]) {\n            return column;\n        }\n        if (field = (this.type.children || [])[index]) {\n            chunks = this._chunks\n                .map((vector) => vector.getChildAt(index))\n                .filter((vec) => vec != null);\n            if (chunks.length > 0) {\n                return (columns[index] = new Column(field, chunks));\n            }\n        }\n        return null;\n    }\n}\n/** @ignore */\nclass SingleChunkColumn extends Column {\n    constructor(field, vector, offsets) {\n        super(field, [vector], offsets);\n        this._chunk = vector;\n    }\n    search(index, then) {\n        return then ? then(this, 0, index) : [0, index];\n    }\n    isValid(index) {\n        return this._chunk.isValid(index);\n    }\n    get(index) {\n        return this._chunk.get(index);\n    }\n    set(index, value) {\n        this._chunk.set(index, value);\n    }\n    indexOf(element, offset) {\n        return this._chunk.indexOf(element, offset);\n    }\n}\n\n//# sourceMappingURL=column.mjs.map\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.\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';\nconst isArray = Array.isArray;\n/** @ignore */\nexport const selectArgs = (Ctor, vals) => _selectArgs(Ctor, vals, [], 0);\n/** @ignore */\nexport const selectColumnArgs = (args) => {\n    const [fields, values] = _selectFieldArgs(args, [[], []]);\n    return values.map((x, i) => x instanceof Column ? Column.new(x.field.clone(fields[i]), x) :\n        x instanceof Vector ? Column.new(fields[i], x) :\n            Column.new(fields[i], []));\n};\n/** @ignore */\nexport const selectFieldArgs = (args) => _selectFieldArgs(args, [[], []]);\n/** @ignore */\nexport const selectChunkArgs = (Ctor, vals) => _selectChunkArgs(Ctor, vals, [], 0);\n/** @ignore */\nexport const selectVectorChildrenArgs = (Ctor, vals) => _selectVectorChildrenArgs(Ctor, vals, [], 0);\n/** @ignore */\nexport const selectColumnChildrenArgs = (Ctor, vals) => _selectColumnChildrenArgs(Ctor, vals, [], 0);\n/** @ignore */\nfunction _selectArgs(Ctor, vals, res, idx) {\n    let value, 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        }\n        else if (value instanceof Ctor) {\n            res[j++] = value;\n        }\n    }\n    return res;\n}\n/** @ignore */\nfunction _selectChunkArgs(Ctor, vals, res, idx) {\n    let value, 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        }\n        else if (value instanceof Chunked) {\n            j = _selectChunkArgs(Ctor, value.chunks, res, j).length;\n        }\n        else if (value instanceof Ctor) {\n            res[j++] = value;\n        }\n    }\n    return res;\n}\n/** @ignore */\nfunction _selectVectorChildrenArgs(Ctor, vals, res, idx) {\n    let value, 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        }\n        else if (value instanceof Ctor) {\n            j = _selectArgs(Vector, value.schema.fields.map((_, i) => value.getChildAt(i)), res, j).length;\n        }\n        else if (value instanceof Vector) {\n            res[j++] = value;\n        }\n    }\n    return res;\n}\n/** @ignore */\nfunction _selectColumnChildrenArgs(Ctor, vals, res, idx) {\n    let value, 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        }\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        }\n        else if (value instanceof Column) {\n            res[j++] = value;\n        }\n    }\n    return res;\n}\n/** @ignore */\nconst toKeysAndValues = (xs, [k, v], i) => (xs[0][i] = k, xs[1][i] = v, xs);\n/** @ignore */\nfunction _selectFieldArgs(vals, ret) {\n    let keys, n;\n    switch (n = vals.length) {\n        case 0: return ret;\n        case 1:\n            keys = ret[0];\n            if (!(vals[0])) {\n                return ret;\n            }\n            if (isArray(vals[0])) {\n                return _selectFieldArgs(vals[0], ret);\n            }\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    let fieldIndex = -1;\n    let valueIndex = -1;\n    let idx = -1, len = vals.length;\n    let field;\n    let val;\n    let [fields, values] = ret;\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        }\n        else {\n            ({ [idx]: field = idx } = keys);\n            if (val instanceof DataType && (values[++valueIndex] = val)) {\n                fields[++fieldIndex] = Field.new(field, val, true);\n            }\n            else if (val && val.type && (values[++valueIndex] = val)) {\n                val instanceof Data && (values[valueIndex] = val = Vector.new(val));\n                fields[++fieldIndex] = Field.new(field, val.type, true);\n            }\n        }\n    }\n    return ret;\n}\n\n//# sourceMappingURL=args.mjs.map\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.\nimport { DataType } from './type';\nimport { selectArgs } from './util/args';\nimport { selectFieldArgs } from './util/args';\nimport { instance as comparer } from './visitor/typecomparator';\nexport class Schema {\n    constructor(fields = [], metadata, dictionaries) {\n        this.fields = (fields || []);\n        this.metadata = metadata || new Map();\n        if (!dictionaries) {\n            dictionaries = generateDictionaryMap(fields);\n        }\n        this.dictionaries = dictionaries;\n    }\n    /** @nocollapse */\n    static from(...args) {\n        return Schema.new(args[0], args[1]);\n    }\n    /** @nocollapse */\n    static new(...args) {\n        return new Schema(selectFieldArgs(args)[0]);\n    }\n    get [Symbol.toStringTag]() { return 'Schema'; }\n    toString() {\n        return `Schema<{ ${this.fields.map((f, i) => `${i}: ${f}`).join(', ')} }>`;\n    }\n    compareTo(other) {\n        return comparer.compareSchemas(this, other);\n    }\n    select(...columnNames) {\n        const names = columnNames.reduce((xs, x) => (xs[x] = true) && xs, Object.create(null));\n        return new Schema(this.fields.filter((f) => names[f.name]), this.metadata);\n    }\n    selectAt(...columnIndices) {\n        return new Schema(columnIndices.map((i) => this.fields[i]).filter(Boolean), this.metadata);\n    }\n    assign(...args) {\n        const other = args[0] instanceof Schema ? args[0]\n            : new Schema(selectArgs(Field, args));\n        const curFields = [...this.fields];\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        });\n        const newDictionaries = generateDictionaryMap(newFields, new Map());\n        return new Schema([...curFields, ...newFields], metadata, new Map([...this.dictionaries, ...newDictionaries]));\n    }\n}\nexport class Field {\n    constructor(name, type, nullable = false, metadata) {\n        this.name = name;\n        this.type = type;\n        this.nullable = nullable;\n        this.metadata = metadata || new Map();\n    }\n    /** @nocollapse */\n    static new(...args) {\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(`${name}`, type, nullable, metadata);\n    }\n    get typeId() { return this.type.typeId; }\n    get [Symbol.toStringTag]() { return 'Field'; }\n    toString() { return `${this.name}: ${this.type}`; }\n    compareTo(other) {\n        return comparer.compareField(this, other);\n    }\n    clone(...args) {\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(name, type, nullable, metadata);\n    }\n}\n/** @ignore */\nfunction mergeMaps(m1, m2) {\n    return new Map([...(m1 || new Map()), ...(m2 || new Map())]);\n}\n/** @ignore */\nfunction generateDictionaryMap(fields, dictionaries = new Map()) {\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            }\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    return dictionaries;\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\nSchema.prototype.fields = null;\nSchema.prototype.metadata = null;\nSchema.prototype.dictionaries = null;\nField.prototype.type = null;\nField.prototype.name = null;\nField.prototype.nullable = null;\nField.prototype.metadata = null;\n\n//# sourceMappingURL=schema.mjs.map\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.\nimport { Run } from './run';\nimport { Field } from '../schema';\nimport { List } from '../type';\nimport { OffsetsBufferBuilder } from './buffer';\nimport { VariableWidthBuilder } from '../builder';\n/** @ignore */\nexport class ListBuilder extends VariableWidthBuilder {\n    constructor(opts) {\n        super(opts);\n        this._run = new Run();\n        this._offsets = new OffsetsBufferBuilder();\n    }\n    addChild(child, 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    clear() {\n        this._run.clear();\n        return super.clear();\n    }\n    _flushPending(pending) {\n        const run = this._run;\n        const offsets = this._offsets;\n        const setValue = this._setValue;\n        let index = 0, value;\n        for ([index, value] of pending) {\n            if (value === undefined) {\n                offsets.set(index, 0);\n            }\n            else {\n                offsets.set(index, value.length);\n                setValue(this, index, run.bind(value));\n            }\n        }\n    }\n}\n\n//# sourceMappingURL=list.mjs.map\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.\nimport { Run } from './run';\nimport { Field } from '../schema';\nimport { Builder } from '../builder';\nimport { FixedSizeList } from '../type';\n/** @ignore */\nexport class FixedSizeListBuilder extends Builder {\n    constructor() {\n        super(...arguments);\n        this._run = new Run();\n    }\n    setValue(index, value) {\n        super.setValue(index, this._run.bind(value));\n    }\n    addChild(child, 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    clear() {\n        this._run.clear();\n        return super.clear();\n    }\n}\n\n//# sourceMappingURL=fixedsizelist.mjs.map\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.\nimport { Field } from '../schema';\nimport { Map_ } from '../type';\nimport { VariableWidthBuilder } from '../builder';\n/** @ignore */\nexport class MapBuilder extends VariableWidthBuilder {\n    set(index, value) {\n        return super.set(index, value);\n    }\n    setValue(index, value) {\n        value = value instanceof Map ? value : new Map(Object.entries(value));\n        const pending = this._pending || (this._pending = new Map());\n        const current = pending.get(index);\n        current && (this._pendingLength -= current.size);\n        this._pendingLength += value.size;\n        pending.set(index, value);\n    }\n    addChild(child, 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_(new Field(name, child.type, true), this.type.keysSorted);\n        return this.numChildren - 1;\n    }\n    _flushPending(pending) {\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            }\n            else {\n                offsets.set(index, value.size);\n                setValue(this, index, value);\n            }\n        });\n    }\n}\n\n//# sourceMappingURL=map.mjs.map\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.\nimport { Field } from '../schema';\nimport { Builder } from '../builder';\nimport { Struct } from '../type';\n/** @ignore */\nexport class StructBuilder extends Builder {\n    addChild(child, 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\n//# sourceMappingURL=struct.mjs.map\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.\nimport { Field } from '../schema';\nimport { DataBufferBuilder } from './buffer';\nimport { Builder } from '../builder';\nimport { Union } from '../type';\n/** @ignore */\nexport class UnionBuilder extends Builder {\n    constructor(options) {\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    get typeIdToChildIndex() { return this.type.typeIdToChildIndex; }\n    append(value, childTypeId) {\n        return this.set(this.length, value, childTypeId);\n    }\n    set(index, value, childTypeId) {\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    // @ts-ignore\n    setValue(index, value, childTypeId) {\n        this._typeIds.set(index, childTypeId);\n        super.setValue(index, value);\n    }\n    // @ts-ignore\n    addChild(child, 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 = new Union(mode, [...typeIds, childTypeId], fields);\n        return childTypeId;\n    }\n    /** @ignore */\n    // @ts-ignore\n    _valueToChildTypeId(builder, value, offset) {\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/** @ignore */\nexport class SparseUnionBuilder extends UnionBuilder {\n}\n/** @ignore */\nexport class DenseUnionBuilder extends UnionBuilder {\n    constructor(options) {\n        super(options);\n        this._offsets = new DataBufferBuilder(new Int32Array(0));\n    }\n    /** @ignore */\n    setValue(index, value, childTypeId) {\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\n//# sourceMappingURL=union.mjs.map\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.\nimport { Vector } from '../vector';\nimport { Visitor } from '../visitor';\nimport { encodeUtf8 } from '../util/utf8';\nimport { float64ToUint16 } from '../util/math';\nimport { toArrayBufferView } from '../util/buffer';\nimport { UnionMode, Precision, DateUnit, TimeUnit, IntervalUnit } from '../enum';\n/** @ignore */\nexport class SetVisitor extends Visitor {\n}\n/** @ignore */\nconst setEpochMsToDays = (data, index, epochMs) => { data[index] = (epochMs / 86400000) | 0; };\n/** @ignore */\nconst setEpochMsToMillisecondsLong = (data, index, epochMs) => {\n    data[index] = (epochMs % 4294967296) | 0;\n    data[index + 1] = (epochMs / 4294967296) | 0;\n};\n/** @ignore */\nconst setEpochMsToMicrosecondsLong = (data, index, epochMs) => {\n    data[index] = ((epochMs * 1000) % 4294967296) | 0;\n    data[index + 1] = ((epochMs * 1000) / 4294967296) | 0;\n};\n/** @ignore */\nconst setEpochMsToNanosecondsLong = (data, index, epochMs) => {\n    data[index] = ((epochMs * 1000000) % 4294967296) | 0;\n    data[index + 1] = ((epochMs * 1000000) / 4294967296) | 0;\n};\n/** @ignore */\nconst setVariableWidthBytes = (values, valueOffsets, index, value) => {\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/** @ignore */\nconst setBool = ({ offset, values }, index, val) => {\n    const idx = offset + index;\n    val ? (values[idx >> 3] |= (1 << (idx % 8))) // true\n        : (values[idx >> 3] &= ~(1 << (idx % 8))); // false\n};\n/** @ignore */\nconst setDateDay = ({ values }, index, value) => { setEpochMsToDays(values, index, value.valueOf()); };\n/** @ignore */\nconst setDateMillisecond = ({ values }, index, value) => { setEpochMsToMillisecondsLong(values, index * 2, value.valueOf()); };\n/** @ignore */\nconst setNumeric = ({ stride, values }, index, value) => { values[stride * index] = value; };\n/** @ignore */\nconst setFloat16 = ({ stride, values }, index, value) => { values[stride * index] = float64ToUint16(value); };\n/** @ignore */\nconst setNumericX2 = (vector, index, value) => {\n    switch (typeof value) {\n        case 'bigint':\n            vector.values64[index] = value;\n            break;\n        case 'number':\n            vector.values[index * vector.stride] = value;\n            break;\n        default:\n            const val = value;\n            const { stride, ArrayType } = vector;\n            const long = toArrayBufferView(ArrayType, val);\n            vector.values.set(long.subarray(0, stride), stride * index);\n    }\n};\n/** @ignore */\nconst setFixedSizeBinary = ({ stride, values }, index, value) => { values.set(value.subarray(0, stride), stride * index); };\n/** @ignore */\nconst setBinary = ({ values, valueOffsets }, index, value) => setVariableWidthBytes(values, valueOffsets, index, value);\n/** @ignore */\nconst setUtf8 = ({ values, valueOffsets }, index, value) => {\n    setVariableWidthBytes(values, valueOffsets, index, encodeUtf8(value));\n};\n/* istanbul ignore next */\n/** @ignore */\nconst setInt = (vector, index, value) => {\n    vector.type.bitWidth < 64\n        ? setNumeric(vector, index, value)\n        : setNumericX2(vector, index, value);\n};\n/* istanbul ignore next */\n/** @ignore */\nconst setFloat = (vector, index, value) => {\n    vector.type.precision !== Precision.HALF\n        ? setNumeric(vector, index, value)\n        : setFloat16(vector, index, value);\n};\n/* istanbul ignore next */\nconst setDate = (vector, index, value) => {\n    vector.type.unit === DateUnit.DAY\n        ? setDateDay(vector, index, value)\n        : setDateMillisecond(vector, index, value);\n};\n/** @ignore */\nconst setTimestampSecond = ({ values }, index, value) => setEpochMsToMillisecondsLong(values, index * 2, value / 1000);\n/** @ignore */\nconst setTimestampMillisecond = ({ values }, index, value) => setEpochMsToMillisecondsLong(values, index * 2, value);\n/** @ignore */\nconst setTimestampMicrosecond = ({ values }, index, value) => setEpochMsToMicrosecondsLong(values, index * 2, value);\n/** @ignore */\nconst setTimestampNanosecond = ({ values }, index, value) => setEpochMsToNanosecondsLong(values, index * 2, value);\n/* istanbul ignore next */\n/** @ignore */\nconst setTimestamp = (vector, index, value) => {\n    switch (vector.type.unit) {\n        case TimeUnit.SECOND: return setTimestampSecond(vector, index, value);\n        case TimeUnit.MILLISECOND: return setTimestampMillisecond(vector, index, value);\n        case TimeUnit.MICROSECOND: return setTimestampMicrosecond(vector, index, value);\n        case TimeUnit.NANOSECOND: return setTimestampNanosecond(vector, index, value);\n    }\n};\n/** @ignore */\nconst setTimeSecond = ({ values, stride }, index, value) => { values[stride * index] = value; };\n/** @ignore */\nconst setTimeMillisecond = ({ values, stride }, index, value) => { values[stride * index] = value; };\n/** @ignore */\nconst setTimeMicrosecond = ({ values }, index, value) => { values.set(value.subarray(0, 2), 2 * index); };\n/** @ignore */\nconst setTimeNanosecond = ({ values }, index, value) => { values.set(value.subarray(0, 2), 2 * index); };\n/* istanbul ignore next */\n/** @ignore */\nconst setTime = (vector, index, value) => {\n    switch (vector.type.unit) {\n        case TimeUnit.SECOND: return setTimeSecond(vector, index, value);\n        case TimeUnit.MILLISECOND: return setTimeMillisecond(vector, index, value);\n        case TimeUnit.MICROSECOND: return setTimeMicrosecond(vector, index, value);\n        case TimeUnit.NANOSECOND: return setTimeNanosecond(vector, index, value);\n    }\n};\n/** @ignore */\nconst setDecimal = ({ values }, index, value) => { values.set(value.subarray(0, 4), 4 * index); };\n/** @ignore */\nconst setList = (vector, index, value) => {\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/** @ignore */\nconst setMap = (vector, index, value) => {\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/** @ignore */ const _setStructArrayValue = (o, v) => (c, _, i) => c && c.set(o, v[i]);\n/** @ignore */ const _setStructVectorValue = (o, v) => (c, _, i) => c && c.set(o, v.get(i));\n/** @ignore */ const _setStructMapValue = (o, v) => (c, f, _) => c && c.set(o, v.get(f.name));\n/** @ignore */ const _setStructObjectValue = (o, v) => (c, f, _) => c && c.set(o, v[f.name]);\n/** @ignore */\nconst setStruct = (vector, index, value) => {\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    vector.type.children.forEach((f, i) => setValue(vector.getChildAt(i), f, i));\n};\n/* istanbul ignore next */\n/** @ignore */\nconst setUnion = (vector, index, value) => {\n    vector.type.mode === UnionMode.Dense ?\n        setDenseUnion(vector, index, value) :\n        setSparseUnion(vector, index, value);\n};\n/** @ignore */\nconst setDenseUnion = (vector, index, value) => {\n    const childIndex = vector.typeIdToChildIndex[vector.typeIds[index]];\n    const child = vector.getChildAt(childIndex);\n    child && child.set(vector.valueOffsets[index], value);\n};\n/** @ignore */\nconst setSparseUnion = (vector, index, value) => {\n    const childIndex = vector.typeIdToChildIndex[vector.typeIds[index]];\n    const child = vector.getChildAt(childIndex);\n    child && child.set(index, value);\n};\n/** @ignore */\nconst setDictionary = (vector, index, value) => {\n    const key = vector.getKey(index);\n    if (key !== null) {\n        vector.setValue(key, value);\n    }\n};\n/* istanbul ignore next */\n/** @ignore */\nconst setIntervalValue = (vector, index, value) => {\n    (vector.type.unit === IntervalUnit.DAY_TIME)\n        ? setIntervalDayTime(vector, index, value)\n        : setIntervalYearMonth(vector, index, value);\n};\n/** @ignore */\nconst setIntervalDayTime = ({ values }, index, value) => { values.set(value.subarray(0, 2), 2 * index); };\n/** @ignore */\nconst setIntervalYearMonth = ({ values }, index, value) => { values[index] = (value[0] * 12) + (value[1] % 12); };\n/** @ignore */\nconst setFixedSizeList = (vector, index, value) => {\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};\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/** @ignore */\nexport const instance = new SetVisitor();\n\n//# sourceMappingURL=set.mjs.map\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.\nimport { Visitor } from '../visitor';\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/** @ignore */\nexport class GetBuilderCtor extends Visitor {\n    visitNull() { return NullBuilder; }\n    visitBool() { return BoolBuilder; }\n    visitInt() { return IntBuilder; }\n    visitInt8() { return Int8Builder; }\n    visitInt16() { return Int16Builder; }\n    visitInt32() { return Int32Builder; }\n    visitInt64() { return Int64Builder; }\n    visitUint8() { return Uint8Builder; }\n    visitUint16() { return Uint16Builder; }\n    visitUint32() { return Uint32Builder; }\n    visitUint64() { return Uint64Builder; }\n    visitFloat() { return FloatBuilder; }\n    visitFloat16() { return Float16Builder; }\n    visitFloat32() { return Float32Builder; }\n    visitFloat64() { return Float64Builder; }\n    visitUtf8() { return Utf8Builder; }\n    visitBinary() { return BinaryBuilder; }\n    visitFixedSizeBinary() { return FixedSizeBinaryBuilder; }\n    visitDate() { return DateBuilder; }\n    visitDateDay() { return DateDayBuilder; }\n    visitDateMillisecond() { return DateMillisecondBuilder; }\n    visitTimestamp() { return TimestampBuilder; }\n    visitTimestampSecond() { return TimestampSecondBuilder; }\n    visitTimestampMillisecond() { return TimestampMillisecondBuilder; }\n    visitTimestampMicrosecond() { return TimestampMicrosecondBuilder; }\n    visitTimestampNanosecond() { return TimestampNanosecondBuilder; }\n    visitTime() { return TimeBuilder; }\n    visitTimeSecond() { return TimeSecondBuilder; }\n    visitTimeMillisecond() { return TimeMillisecondBuilder; }\n    visitTimeMicrosecond() { return TimeMicrosecondBuilder; }\n    visitTimeNanosecond() { return TimeNanosecondBuilder; }\n    visitDecimal() { return DecimalBuilder; }\n    visitList() { return ListBuilder; }\n    visitStruct() { return StructBuilder; }\n    visitUnion() { return UnionBuilder; }\n    visitDenseUnion() { return DenseUnionBuilder; }\n    visitSparseUnion() { return SparseUnionBuilder; }\n    visitDictionary() { return DictionaryBuilder; }\n    visitInterval() { return IntervalBuilder; }\n    visitIntervalDayTime() { return IntervalDayTimeBuilder; }\n    visitIntervalYearMonth() { return IntervalYearMonthBuilder; }\n    visitFixedSizeList() { return FixedSizeListBuilder; }\n    visitMap() { return MapBuilder; }\n}\n/** @ignore */\nexport const instance = new GetBuilderCtor();\n\n//# sourceMappingURL=builderctor.mjs.map\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/** @ignore */\nexport { Builder } 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';\nimport { Type } from '../enum';\nimport { Utf8Builder } from './utf8';\nimport { Builder } from '../builder';\nimport { instance as setVisitor } from '../visitor/set';\nimport { instance as getBuilderConstructor } from '../visitor/builderctor';\n/** @nocollapse */\nBuilder.new = newBuilder;\nfunction newBuilder(options) {\n    const type = options.type;\n    const builder = new (getBuilderConstructor.getVisitFn(type)())(options);\n    if (type.children && type.children.length > 0) {\n        const children = options['children'] || [];\n        const defaultOptions = { 'nullValues': options['nullValues'] };\n        const getChildOptions = Array.isArray(children)\n            ? ((_, i) => children[i] || defaultOptions)\n            : (({ name }) => children[name] || defaultOptions);\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    return builder;\n}\nObject.keys(Type)\n    .map((T) => Type[T])\n    .filter((T) => typeof T === 'number' && T !== Type.NONE)\n    .forEach((typeId) => {\n    const BuilderCtor = getBuilderConstructor.visit(typeId);\n    BuilderCtor.prototype._setValue = setVisitor.getVisitFn(typeId);\n});\nUtf8Builder.prototype._setValue = setVisitor.visitBinary;\n\n//# sourceMappingURL=index.mjs.map\n","// automatically generated by the FlatBuffers compiler, do not modify\nimport * as NS7624605610262437867 from './Schema';\n/**\n * ----------------------------------------------------------------------\n * Arrow File metadata\n *\n *\n * @constructor\n */\nexport var org;\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Footer {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Footer\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\n                    }\n                    /**\n                     * @param flatbuffers.ByteBuffer bb\n                     * @param Footer= obj\n                     * @returns Footer\n                     */\n                    static getRootAsFooter(bb, obj) {\n                        return (obj || new Footer).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n                    }\n                    /**\n                     * @returns org.apache.arrow.flatbuf.MetadataVersion\n                     */\n                    version() {\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                     * @param org.apache.arrow.flatbuf.Schema= obj\n                     * @returns org.apache.arrow.flatbuf.Schema|null\n                     */\n                    schema(obj) {\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                     * @param number index\n                     * @param org.apache.arrow.flatbuf.Block= obj\n                     * @returns org.apache.arrow.flatbuf.Block\n                     */\n                    dictionaries(index, obj) {\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                     * @returns number\n                     */\n                    dictionariesLength() {\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                     * @param number index\n                     * @param org.apache.arrow.flatbuf.Block= obj\n                     * @returns org.apache.arrow.flatbuf.Block\n                     */\n                    recordBatches(index, obj) {\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                     * @returns number\n                     */\n                    recordBatchesLength() {\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                     * @param flatbuffers.Builder builder\n                     */\n                    static startFooter(builder) {\n                        builder.startObject(4);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param org.apache.arrow.flatbuf.MetadataVersion version\n                     */\n                    static addVersion(builder, version) {\n                        builder.addFieldInt16(0, version, NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion.V1);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset schemaOffset\n                     */\n                    static addSchema(builder, schemaOffset) {\n                        builder.addFieldOffset(1, schemaOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset dictionariesOffset\n                     */\n                    static addDictionaries(builder, dictionariesOffset) {\n                        builder.addFieldOffset(2, dictionariesOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param number numElems\n                     */\n                    static startDictionariesVector(builder, numElems) {\n                        builder.startVector(24, numElems, 8);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset recordBatchesOffset\n                     */\n                    static addRecordBatches(builder, recordBatchesOffset) {\n                        builder.addFieldOffset(3, recordBatchesOffset, 0);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param number numElems\n                     */\n                    static startRecordBatchesVector(builder, numElems) {\n                        builder.startVector(24, numElems, 8);\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @returns flatbuffers.Offset\n                     */\n                    static endFooter(builder) {\n                        let offset = builder.endObject();\n                        return offset;\n                    }\n                    /**\n                     * @param flatbuffers.Builder builder\n                     * @param flatbuffers.Offset offset\n                     */\n                    static finishFooterBuffer(builder, offset) {\n                        builder.finish(offset);\n                    }\n                    static createFooter(builder, version, schemaOffset, dictionariesOffset, recordBatchesOffset) {\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                flatbuf.Footer = Footer;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n/**\n * @constructor\n */\n(function (org) {\n    var apache;\n    (function (apache) {\n        var arrow;\n        (function (arrow) {\n            var flatbuf;\n            (function (flatbuf) {\n                class Block {\n                    constructor() {\n                        this.bb = null;\n                        this.bb_pos = 0;\n                    }\n                    /**\n                     * @param number i\n                     * @param flatbuffers.ByteBuffer bb\n                     * @returns Block\n                     */\n                    __init(i, bb) {\n                        this.bb_pos = i;\n                        this.bb = bb;\n                        return this;\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() {\n                        return this.bb.readInt64(this.bb_pos);\n                    }\n                    /**\n                     * Length of the metadata\n                     *\n                     * @returns number\n                     */\n                    metaDataLength() {\n                        return this.bb.readInt32(this.bb_pos + 8);\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() {\n                        return this.bb.readInt64(this.bb_pos + 16);\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, offset, metaDataLength, bodyLength) {\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                flatbuf.Block = Block;\n            })(flatbuf = arrow.flatbuf || (arrow.flatbuf = {}));\n        })(arrow = apache.arrow || (apache.arrow = {}));\n    })(apache = org.apache || (org.apache = {}));\n})(org || (org = {}));\n\n//# sourceMappingURL=File.mjs.map\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/* tslint:disable:class-name */\nimport * as File_ from '../../fb/File';\nimport { flatbuffers } from 'flatbuffers';\nvar Long = flatbuffers.Long;\nvar Builder = flatbuffers.Builder;\nvar ByteBuffer = flatbuffers.ByteBuffer;\nvar _Block = File_.org.apache.arrow.flatbuf.Block;\nvar _Footer = File_.org.apache.arrow.flatbuf.Footer;\nimport { Schema } from '../../schema';\nimport { MetadataVersion } from '../../enum';\nimport { toUint8Array } from '../../util/buffer';\n/** @ignore */\nclass Footer_ {\n    constructor(schema, version = MetadataVersion.V4, recordBatches, dictionaryBatches) {\n        this.schema = schema;\n        this.version = version;\n        recordBatches && (this._recordBatches = recordBatches);\n        dictionaryBatches && (this._dictionaryBatches = dictionaryBatches);\n    }\n    /** @nocollapse */\n    static decode(buf) {\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);\n    }\n    /** @nocollapse */\n    static encode(footer) {\n        const b = new Builder();\n        const schemaOffset = Schema.encode(b, footer.schema);\n        _Footer.startRecordBatchesVector(b, footer.numRecordBatches);\n        [...footer.recordBatches()].slice().reverse().forEach((rb) => FileBlock.encode(b, rb));\n        const recordBatchesOffset = b.endVector();\n        _Footer.startDictionariesVector(b, footer.numDictionaries);\n        [...footer.dictionaryBatches()].slice().reverse().forEach((db) => FileBlock.encode(b, db));\n        const dictionaryBatchesOffset = b.endVector();\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        return b.asUint8Array();\n    }\n    get numRecordBatches() { return this._recordBatches.length; }\n    get numDictionaries() { return this._dictionaryBatches.length; }\n    *recordBatches() {\n        for (let block, i = -1, n = this.numRecordBatches; ++i < n;) {\n            if (block = this.getRecordBatch(i)) {\n                yield block;\n            }\n        }\n    }\n    *dictionaryBatches() {\n        for (let block, i = -1, n = this.numDictionaries; ++i < n;) {\n            if (block = this.getDictionaryBatch(i)) {\n                yield block;\n            }\n        }\n    }\n    getRecordBatch(index) {\n        return index >= 0\n            && index < this.numRecordBatches\n            && this._recordBatches[index] || null;\n    }\n    getDictionaryBatch(index) {\n        return index >= 0\n            && index < this.numDictionaries\n            && this._dictionaryBatches[index] || null;\n    }\n}\nexport { Footer_ as Footer };\n/** @ignore */\nclass OffHeapFooter extends Footer_ {\n    constructor(schema, _footer) {\n        super(schema, _footer.version());\n        this._footer = _footer;\n    }\n    get numRecordBatches() { return this._footer.recordBatchesLength(); }\n    get numDictionaries() { return this._footer.dictionariesLength(); }\n    getRecordBatch(index) {\n        if (index >= 0 && index < this.numRecordBatches) {\n            const fileBlock = this._footer.recordBatches(index);\n            if (fileBlock) {\n                return FileBlock.decode(fileBlock);\n            }\n        }\n        return null;\n    }\n    getDictionaryBatch(index) {\n        if (index >= 0 && index < this.numDictionaries) {\n            const fileBlock = this._footer.dictionaries(index);\n            if (fileBlock) {\n                return FileBlock.decode(fileBlock);\n            }\n        }\n        return null;\n    }\n}\n/** @ignore */\nexport class FileBlock {\n    /** @nocollapse */\n    static decode(block) {\n        return new FileBlock(block.metaDataLength(), block.bodyLength(), block.offset());\n    }\n    /** @nocollapse */\n    static encode(b, 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    constructor(metaDataLength, bodyLength, offset) {\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\n//# sourceMappingURL=file.mjs.map\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.\nimport streamAdapters from './adapters';\nimport { decodeUtf8 } from '../util/utf8';\nimport { ITERATOR_DONE, AsyncQueue } from './interfaces';\nimport { toUint8Array, joinUint8Arrays } from '../util/buffer';\nimport { isPromise, isFetchResponse, isIterable, isAsyncIterable, isReadableDOMStream, isReadableNodeStream } from '../util/compat';\n/** @ignore */\nexport class AsyncByteQueue extends AsyncQueue {\n    write(value) {\n        if ((value = toUint8Array(value)).byteLength > 0) {\n            return super.write(value);\n        }\n    }\n    toString(sync = false) {\n        return sync\n            ? decodeUtf8(this.toUint8Array(true))\n            : this.toUint8Array(false).then(decodeUtf8);\n    }\n    toUint8Array(sync = false) {\n        return sync ? joinUint8Arrays(this._values)[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/** @ignore */\nexport class ByteStream {\n    constructor(source) {\n        if (source) {\n            this.source = new ByteStreamSource(streamAdapters.fromIterable(source));\n        }\n    }\n    [Symbol.iterator]() { return this; }\n    next(value) { return this.source.next(value); }\n    throw(value) { return this.source.throw(value); }\n    return(value) { return this.source.return(value); }\n    peek(size) { return this.source.peek(size); }\n    read(size) { return this.source.read(size); }\n}\n/** @ignore */\nexport class AsyncByteStream {\n    constructor(source) {\n        if (source instanceof AsyncByteStream) {\n            this.source = source.source;\n        }\n        else if (source instanceof AsyncByteQueue) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromAsyncIterable(source));\n        }\n        else if (isReadableNodeStream(source)) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromNodeStream(source));\n        }\n        else if (isReadableDOMStream(source)) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromDOMStream(source));\n        }\n        else if (isFetchResponse(source)) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromDOMStream(source.body));\n        }\n        else if (isIterable(source)) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromIterable(source));\n        }\n        else if (isPromise(source)) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromAsyncIterable(source));\n        }\n        else if (isAsyncIterable(source)) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromAsyncIterable(source));\n        }\n    }\n    [Symbol.asyncIterator]() { return this; }\n    next(value) { return this.source.next(value); }\n    throw(value) { return this.source.throw(value); }\n    return(value) { return this.source.return(value); }\n    get closed() { return this.source.closed; }\n    cancel(reason) { return this.source.cancel(reason); }\n    peek(size) { return this.source.peek(size); }\n    read(size) { return this.source.read(size); }\n}\n/** @ignore */\nclass ByteStreamSource {\n    constructor(source) {\n        this.source = source;\n    }\n    cancel(reason) { this.return(reason); }\n    peek(size) { return this.next(size, 'peek').value; }\n    read(size) { return this.next(size, 'read').value; }\n    next(size, cmd = 'read') { return this.source.next({ cmd, size }); }\n    throw(value) { return Object.create((this.source.throw && this.source.throw(value)) || ITERATOR_DONE); }\n    return(value) { return Object.create((this.source.return && this.source.return(value)) || ITERATOR_DONE); }\n}\n/** @ignore */\nclass AsyncByteStreamSource {\n    constructor(source) {\n        this.source = source;\n        this._closedPromise = new Promise((r) => this._closedPromiseResolve = r);\n    }\n    async cancel(reason) { await this.return(reason); }\n    get closed() { return this._closedPromise; }\n    async read(size) { return (await this.next(size, 'read')).value; }\n    async peek(size) { return (await this.next(size, 'peek')).value; }\n    async next(size, cmd = 'read') { return (await this.source.next({ cmd, size })); }\n    async throw(value) {\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    async return(value) {\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\n//# sourceMappingURL=stream.mjs.map\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.\nimport { ByteStream, AsyncByteStream } from './stream';\nimport { toUint8Array } from '../util/buffer';\n/** @ignore */\nexport class RandomAccessFile extends ByteStream {\n    constructor(buffer, byteLength) {\n        super();\n        this.position = 0;\n        this.buffer = toUint8Array(buffer);\n        this.size = typeof byteLength === 'undefined' ? this.buffer.byteLength : byteLength;\n    }\n    readInt32(position) {\n        const { buffer, byteOffset } = this.readAt(position, 4);\n        return new DataView(buffer, byteOffset).getInt32(0, true);\n    }\n    seek(position) {\n        this.position = Math.min(position, this.size);\n        return position < this.size;\n    }\n    read(nBytes) {\n        const { buffer, size, position } = this;\n        if (buffer && position < size) {\n            if (typeof nBytes !== 'number') {\n                nBytes = Infinity;\n            }\n            this.position = Math.min(size, position + Math.min(size - position, nBytes));\n            return buffer.subarray(position, this.position);\n        }\n        return null;\n    }\n    readAt(position, nBytes) {\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    close() { this.buffer && (this.buffer = null); }\n    throw(value) { this.close(); return { done: true, value }; }\n    return(value) { this.close(); return { done: true, value }; }\n}\n/** @ignore */\nexport class AsyncRandomAccessFile extends AsyncByteStream {\n    constructor(file, byteLength) {\n        super();\n        this.position = 0;\n        this._handle = file;\n        if (typeof byteLength === 'number') {\n            this.size = byteLength;\n        }\n        else {\n            this._pending = (async () => {\n                this.size = (await file.stat()).size;\n                delete this._pending;\n            })();\n        }\n    }\n    async readInt32(position) {\n        const { buffer, byteOffset } = await this.readAt(position, 4);\n        return new DataView(buffer, byteOffset).getInt32(0, true);\n    }\n    async seek(position) {\n        this._pending && await this._pending;\n        this.position = Math.min(position, this.size);\n        return position < this.size;\n    }\n    async read(nBytes) {\n        this._pending && await this._pending;\n        const { _handle: file, size, position } = this;\n        if (file && position < size) {\n            if (typeof nBytes !== 'number') {\n                nBytes = Infinity;\n            }\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    async readAt(position, nBytes) {\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    async close() { const f = this._handle; this._handle = null; f && await f.close(); }\n    async throw(value) { await this.close(); return { done: true, value }; }\n    async return(value) { await this.close(); return { done: true, value }; }\n}\n\n//# sourceMappingURL=file.mjs.map\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/** @ignore */\nconst carryBit16 = 1 << 16;\n/** @ignore */\nfunction intAsHex(value) {\n    if (value < 0) {\n        value = 0xFFFFFFFF + value + 1;\n    }\n    return `0x${value.toString(16)}`;\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/** @ignore */\nexport class BaseInt64 {\n    constructor(buffer) {\n        this.buffer = buffer;\n    }\n    high() { return this.buffer[1]; }\n    low() { return this.buffer[0]; }\n    _times(other) {\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        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        let product = L[3] * R[3];\n        this.buffer[0] = product & 0xFFFF;\n        let sum = product >>> 16;\n        product = L[2] * R[3];\n        sum += product;\n        product = (L[3] * R[2]) >>> 0;\n        sum += product;\n        this.buffer[0] += sum << 16;\n        this.buffer[1] = (sum >>> 0 < product ? carryBit16 : 0);\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        return this;\n    }\n    _plus(other) {\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    lessThan(other) {\n        return this.buffer[1] < other.buffer[1] ||\n            (this.buffer[1] === other.buffer[1] && this.buffer[0] < other.buffer[0]);\n    }\n    equals(other) {\n        return this.buffer[1] === other.buffer[1] && this.buffer[0] == other.buffer[0];\n    }\n    greaterThan(other) {\n        return other.lessThan(this);\n    }\n    hex() {\n        return `${intAsHex(this.buffer[1])} ${intAsHex(this.buffer[0])}`;\n    }\n}\n/** @ignore */\nexport class Uint64 extends BaseInt64 {\n    times(other) {\n        this._times(other);\n        return this;\n    }\n    plus(other) {\n        this._plus(other);\n        return this;\n    }\n    /** @nocollapse */\n    static from(val, out_buffer = new Uint32Array(2)) {\n        return Uint64.fromString(typeof (val) === 'string' ? val : val.toString(), out_buffer);\n    }\n    /** @nocollapse */\n    static fromNumber(num, out_buffer = new Uint32Array(2)) {\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    /** @nocollapse */\n    static fromString(str, out_buffer = new Uint32Array(2)) {\n        const length = str.length;\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            out.times(multiple);\n            out.plus(chunk);\n            posn += group;\n        }\n        return out;\n    }\n    /** @nocollapse */\n    static convertArray(values) {\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    /** @nocollapse */\n    static multiply(left, right) {\n        let rtrn = new Uint64(new Uint32Array(left.buffer));\n        return rtrn.times(right);\n    }\n    /** @nocollapse */\n    static add(left, right) {\n        let rtrn = new Uint64(new Uint32Array(left.buffer));\n        return rtrn.plus(right);\n    }\n}\n/** @ignore */\nexport class Int64 extends BaseInt64 {\n    negate() {\n        this.buffer[0] = ~this.buffer[0] + 1;\n        this.buffer[1] = ~this.buffer[1];\n        if (this.buffer[0] == 0) {\n            ++this.buffer[1];\n        }\n        return this;\n    }\n    times(other) {\n        this._times(other);\n        return this;\n    }\n    plus(other) {\n        this._plus(other);\n        return this;\n    }\n    lessThan(other) {\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    /** @nocollapse */\n    static from(val, out_buffer = new Uint32Array(2)) {\n        return Int64.fromString(typeof (val) === 'string' ? val : val.toString(), out_buffer);\n    }\n    /** @nocollapse */\n    static fromNumber(num, out_buffer = new Uint32Array(2)) {\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    /** @nocollapse */\n    static fromString(str, out_buffer = new Uint32Array(2)) {\n        // TODO: Assert that out_buffer is 0 and length = 2\n        const negate = str.startsWith('-');\n        const length = str.length;\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            out.times(multiple);\n            out.plus(chunk);\n            posn += group;\n        }\n        return negate ? out.negate() : out;\n    }\n    /** @nocollapse */\n    static convertArray(values) {\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    /** @nocollapse */\n    static multiply(left, right) {\n        let rtrn = new Int64(new Uint32Array(left.buffer));\n        return rtrn.times(right);\n    }\n    /** @nocollapse */\n    static add(left, right) {\n        let rtrn = new Int64(new Uint32Array(left.buffer));\n        return rtrn.plus(right);\n    }\n}\n/** @ignore */\nexport class Int128 {\n    constructor(buffer) {\n        this.buffer = buffer;\n        // buffer[3] MSB (high)\n        // buffer[2]\n        // buffer[1]\n        // buffer[0] LSB (low)\n    }\n    high() {\n        return new Int64(new Uint32Array(this.buffer.buffer, this.buffer.byteOffset + 8, 2));\n    }\n    low() {\n        return new Int64(new Uint32Array(this.buffer.buffer, this.buffer.byteOffset, 2));\n    }\n    negate() {\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        if (this.buffer[0] == 0) {\n            ++this.buffer[1];\n        }\n        if (this.buffer[1] == 0) {\n            ++this.buffer[2];\n        }\n        if (this.buffer[2] == 0) {\n            ++this.buffer[3];\n        }\n        return this;\n    }\n    times(other) {\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        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        let product = Uint64.multiply(L3, R3);\n        this.buffer[0] = product.low();\n        let sum = new Uint64(new Uint32Array([product.high(), 0]));\n        product = Uint64.multiply(L2, R3);\n        sum.plus(product);\n        product = Uint64.multiply(L3, R2);\n        sum.plus(product);\n        this.buffer[1] = sum.low();\n        this.buffer[3] = (sum.lessThan(product) ? 1 : 0);\n        this.buffer[2] = sum.high();\n        let high = new Uint64(new Uint32Array(this.buffer.buffer, this.buffer.byteOffset + 8, 2));\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        return this;\n    }\n    plus(other) {\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        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        this.buffer[3] = sums[3];\n        this.buffer[2] = sums[2];\n        this.buffer[1] = sums[1];\n        this.buffer[0] = sums[0];\n        return this;\n    }\n    hex() {\n        return `${intAsHex(this.buffer[3])} ${intAsHex(this.buffer[2])} ${intAsHex(this.buffer[1])} ${intAsHex(this.buffer[0])}`;\n    }\n    /** @nocollapse */\n    static multiply(left, right) {\n        let rtrn = new Int128(new Uint32Array(left.buffer));\n        return rtrn.times(right);\n    }\n    /** @nocollapse */\n    static add(left, right) {\n        let rtrn = new Int128(new Uint32Array(left.buffer));\n        return rtrn.plus(right);\n    }\n    /** @nocollapse */\n    static from(val, out_buffer = new Uint32Array(4)) {\n        return Int128.fromString(typeof (val) === 'string' ? val : val.toString(), out_buffer);\n    }\n    /** @nocollapse */\n    static fromNumber(num, out_buffer = new Uint32Array(4)) {\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    /** @nocollapse */\n    static fromString(str, out_buffer = new Uint32Array(4)) {\n        // TODO: Assert that out_buffer is 0 and length = 4\n        const negate = str.startsWith('-');\n        const length = str.length;\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            out.times(multiple);\n            out.plus(chunk);\n            posn += group;\n        }\n        return negate ? out.negate() : out;\n    }\n    /** @nocollapse */\n    static convertArray(values) {\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\n//# sourceMappingURL=int.mjs.map\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.\nimport { Data } from '../data';\nimport { Field } from '../schema';\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';\n/** @ignore */\nexport class VectorLoader extends Visitor {\n    constructor(bytes, nodes, buffers, dictionaries) {\n        super();\n        this.nodesIndex = -1;\n        this.buffersIndex = -1;\n        this.bytes = bytes;\n        this.nodes = nodes;\n        this.buffers = buffers;\n        this.dictionaries = dictionaries;\n    }\n    visit(node) {\n        return super.visit(node instanceof Field ? node.type : node);\n    }\n    visitNull(type, { length, } = this.nextFieldNode()) { return Data.Null(type, 0, length); }\n    visitBool(type, { length, nullCount } = this.nextFieldNode()) { return Data.Bool(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type)); }\n    visitInt(type, { length, nullCount } = this.nextFieldNode()) { return Data.Int(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type)); }\n    visitFloat(type, { length, nullCount } = this.nextFieldNode()) { return Data.Float(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type)); }\n    visitUtf8(type, { length, nullCount } = this.nextFieldNode()) { return Data.Utf8(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readOffsets(type), this.readData(type)); }\n    visitBinary(type, { length, nullCount } = this.nextFieldNode()) { return Data.Binary(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readOffsets(type), this.readData(type)); }\n    visitFixedSizeBinary(type, { length, nullCount } = this.nextFieldNode()) { return Data.FixedSizeBinary(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type)); }\n    visitDate(type, { length, nullCount } = this.nextFieldNode()) { return Data.Date(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type)); }\n    visitTimestamp(type, { length, nullCount } = this.nextFieldNode()) { return Data.Timestamp(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type)); }\n    visitTime(type, { length, nullCount } = this.nextFieldNode()) { return Data.Time(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type)); }\n    visitDecimal(type, { length, nullCount } = this.nextFieldNode()) { return Data.Decimal(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type)); }\n    visitList(type, { length, nullCount } = this.nextFieldNode()) { return Data.List(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readOffsets(type), this.visit(type.children[0])); }\n    visitStruct(type, { length, nullCount } = this.nextFieldNode()) { return Data.Struct(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.visitMany(type.children)); }\n    visitUnion(type) { return type.mode === UnionMode.Sparse ? this.visitSparseUnion(type) : this.visitDenseUnion(type); }\n    visitDenseUnion(type, { 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    visitSparseUnion(type, { length, nullCount } = this.nextFieldNode()) { return Data.Union(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readTypeIds(type), this.visitMany(type.children)); }\n    visitDictionary(type, { length, nullCount } = this.nextFieldNode()) { return Data.Dictionary(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type.indices), this.readDictionary(type)); }\n    visitInterval(type, { length, nullCount } = this.nextFieldNode()) { return Data.Interval(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type)); }\n    visitFixedSizeList(type, { length, nullCount } = this.nextFieldNode()) { return Data.FixedSizeList(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.visit(type.children[0])); }\n    visitMap(type, { length, nullCount } = this.nextFieldNode()) { return Data.Map(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readOffsets(type), this.visit(type.children[0])); }\n    nextFieldNode() { return this.nodes[++this.nodesIndex]; }\n    nextBufferRange() { return this.buffers[++this.buffersIndex]; }\n    readNullBitmap(type, nullCount, buffer = this.nextBufferRange()) {\n        return nullCount > 0 && this.readData(type, buffer) || new Uint8Array(0);\n    }\n    readOffsets(type, buffer) { return this.readData(type, buffer); }\n    readTypeIds(type, buffer) { return this.readData(type, buffer); }\n    readData(_type, { length, offset } = this.nextBufferRange()) {\n        return this.bytes.subarray(offset, offset + length);\n    }\n    readDictionary(type) {\n        return this.dictionaries.get(type.id);\n    }\n}\n/** @ignore */\nexport class JSONVectorLoader extends VectorLoader {\n    constructor(sources, nodes, buffers, dictionaries) {\n        super(new Uint8Array(0), nodes, buffers, dictionaries);\n        this.sources = sources;\n    }\n    readNullBitmap(_type, nullCount, { offset } = this.nextBufferRange()) {\n        return nullCount <= 0 ? new Uint8Array(0) : packBools(this.sources[offset]);\n    }\n    readOffsets(_type, { offset } = this.nextBufferRange()) {\n        return toArrayBufferView(Uint8Array, toArrayBufferView(Int32Array, this.sources[offset]));\n    }\n    readTypeIds(type, { offset } = this.nextBufferRange()) {\n        return toArrayBufferView(Uint8Array, toArrayBufferView(type.ArrayType, this.sources[offset]));\n    }\n    readData(type, { offset } = this.nextBufferRange()) {\n        const { sources } = this;\n        if (DataType.isTimestamp(type)) {\n            return toArrayBufferView(Uint8Array, Int64.convertArray(sources[offset]));\n        }\n        else if ((DataType.isInt(type) || DataType.isTime(type)) && type.bitWidth === 64) {\n            return toArrayBufferView(Uint8Array, Int64.convertArray(sources[offset]));\n        }\n        else if (DataType.isDate(type) && type.unit === DateUnit.MILLISECOND) {\n            return toArrayBufferView(Uint8Array, Int64.convertArray(sources[offset]));\n        }\n        else if (DataType.isDecimal(type)) {\n            return toArrayBufferView(Uint8Array, Int128.convertArray(sources[offset]));\n        }\n        else if (DataType.isBinary(type) || DataType.isFixedSizeBinary(type)) {\n            return binaryDataFromJSON(sources[offset]);\n        }\n        else if (DataType.isBool(type)) {\n            return packBools(sources[offset]);\n        }\n        else if (DataType.isUtf8(type)) {\n            return encodeUtf8(sources[offset].join(''));\n        }\n        return toArrayBufferView(Uint8Array, toArrayBufferView(type.ArrayType, sources[offset].map((x) => +x)));\n    }\n}\n/** @ignore */\nfunction binaryDataFromJSON(values) {\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\n//# sourceMappingURL=vectorloader.mjs.map\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.\nimport { flatbuffers } from 'flatbuffers';\nvar Long = flatbuffers.Long;\nimport * as Schema_ from '../fb/Schema';\nimport { Visitor } from '../visitor';\nvar Null = Schema_.org.apache.arrow.flatbuf.Null;\nvar Int = Schema_.org.apache.arrow.flatbuf.Int;\nvar FloatingPoint = Schema_.org.apache.arrow.flatbuf.FloatingPoint;\nvar Binary = Schema_.org.apache.arrow.flatbuf.Binary;\nvar Bool = Schema_.org.apache.arrow.flatbuf.Bool;\nvar Utf8 = Schema_.org.apache.arrow.flatbuf.Utf8;\nvar Decimal = Schema_.org.apache.arrow.flatbuf.Decimal;\nvar Date = Schema_.org.apache.arrow.flatbuf.Date;\nvar Time = Schema_.org.apache.arrow.flatbuf.Time;\nvar Timestamp = Schema_.org.apache.arrow.flatbuf.Timestamp;\nvar Interval = Schema_.org.apache.arrow.flatbuf.Interval;\nvar List = Schema_.org.apache.arrow.flatbuf.List;\nvar Struct = Schema_.org.apache.arrow.flatbuf.Struct_;\nvar Union = Schema_.org.apache.arrow.flatbuf.Union;\nvar DictionaryEncoding = Schema_.org.apache.arrow.flatbuf.DictionaryEncoding;\nvar FixedSizeBinary = Schema_.org.apache.arrow.flatbuf.FixedSizeBinary;\nvar FixedSizeList = Schema_.org.apache.arrow.flatbuf.FixedSizeList;\nvar Map_ = Schema_.org.apache.arrow.flatbuf.Map;\n/** @ignore */\nexport class TypeAssembler extends Visitor {\n    visit(node, builder) {\n        return (node == null || builder == null) ? undefined : super.visit(node, builder);\n    }\n    visitNull(_node, b) {\n        Null.startNull(b);\n        return Null.endNull(b);\n    }\n    visitInt(node, b) {\n        Int.startInt(b);\n        Int.addBitWidth(b, node.bitWidth);\n        Int.addIsSigned(b, node.isSigned);\n        return Int.endInt(b);\n    }\n    visitFloat(node, b) {\n        FloatingPoint.startFloatingPoint(b);\n        FloatingPoint.addPrecision(b, node.precision);\n        return FloatingPoint.endFloatingPoint(b);\n    }\n    visitBinary(_node, b) {\n        Binary.startBinary(b);\n        return Binary.endBinary(b);\n    }\n    visitBool(_node, b) {\n        Bool.startBool(b);\n        return Bool.endBool(b);\n    }\n    visitUtf8(_node, b) {\n        Utf8.startUtf8(b);\n        return Utf8.endUtf8(b);\n    }\n    visitDecimal(node, b) {\n        Decimal.startDecimal(b);\n        Decimal.addScale(b, node.scale);\n        Decimal.addPrecision(b, node.precision);\n        return Decimal.endDecimal(b);\n    }\n    visitDate(node, b) {\n        Date.startDate(b);\n        Date.addUnit(b, node.unit);\n        return Date.endDate(b);\n    }\n    visitTime(node, b) {\n        Time.startTime(b);\n        Time.addUnit(b, node.unit);\n        Time.addBitWidth(b, node.bitWidth);\n        return Time.endTime(b);\n    }\n    visitTimestamp(node, b) {\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    visitInterval(node, b) {\n        Interval.startInterval(b);\n        Interval.addUnit(b, node.unit);\n        return Interval.endInterval(b);\n    }\n    visitList(_node, b) {\n        List.startList(b);\n        return List.endList(b);\n    }\n    visitStruct(_node, b) {\n        Struct.startStruct_(b);\n        return Struct.endStruct_(b);\n    }\n    visitUnion(node, b) {\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    visitDictionary(node, b) {\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    visitFixedSizeBinary(node, b) {\n        FixedSizeBinary.startFixedSizeBinary(b);\n        FixedSizeBinary.addByteWidth(b, node.byteWidth);\n        return FixedSizeBinary.endFixedSizeBinary(b);\n    }\n    visitFixedSizeList(node, b) {\n        FixedSizeList.startFixedSizeList(b);\n        FixedSizeList.addListSize(b, node.listSize);\n        return FixedSizeList.endFixedSizeList(b);\n    }\n    visitMap(node, b) {\n        Map_.startMap(b);\n        Map_.addKeysSorted(b, node.keysSorted);\n        return Map_.endMap(b);\n    }\n}\n/** @ignore */\nexport const instance = new TypeAssembler();\n\n//# sourceMappingURL=typeassembler.mjs.map\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.\nimport { Schema, Field } from '../../schema';\nimport { Dictionary, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct, Union, Bool, Null, Int, Float, Date_, Time, Interval, Timestamp, Int32, } from '../../type';\nimport { DictionaryBatch, RecordBatch, FieldNode, BufferRegion } from './message';\nimport { TimeUnit, Precision, IntervalUnit, UnionMode, DateUnit } from '../../enum';\n/** @ignore */\nexport function schemaFromJSON(_schema, dictionaries = new Map()) {\n    return new Schema(schemaFieldsFromJSON(_schema, dictionaries), customMetadataFromJSON(_schema['customMetadata']), dictionaries);\n}\n/** @ignore */\nexport function recordBatchFromJSON(b) {\n    return new RecordBatch(b['count'], fieldNodesFromJSON(b['columns']), buffersFromJSON(b['columns']));\n}\n/** @ignore */\nexport function dictionaryBatchFromJSON(b) {\n    return new DictionaryBatch(recordBatchFromJSON(b['data']), b['id'], b['isDelta']);\n}\n/** @ignore */\nfunction schemaFieldsFromJSON(_schema, dictionaries) {\n    return (_schema['fields'] || []).filter(Boolean).map((f) => Field.fromJSON(f, dictionaries));\n}\n/** @ignore */\nfunction fieldChildrenFromJSON(_field, dictionaries) {\n    return (_field['children'] || []).filter(Boolean).map((f) => Field.fromJSON(f, dictionaries));\n}\n/** @ignore */\nfunction fieldNodesFromJSON(xs) {\n    return (xs || []).reduce((fieldNodes, column) => [\n        ...fieldNodes,\n        new FieldNode(column['count'], nullCountFromJSON(column['VALIDITY'])),\n        ...fieldNodesFromJSON(column['children'])\n    ], []);\n}\n/** @ignore */\nfunction buffersFromJSON(xs, buffers = []) {\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/** @ignore */\nfunction nullCountFromJSON(validity) {\n    return (validity || []).reduce((sum, val) => sum + +(val === 0), 0);\n}\n/** @ignore */\nexport function fieldFromJSON(_field, dictionaries) {\n    let id;\n    let keys;\n    let field;\n    let dictMeta;\n    let type;\n    let dictType;\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) : 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) : 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/** @ignore */\nfunction customMetadataFromJSON(_metadata) {\n    return new Map(Object.entries(_metadata || {}));\n}\n/** @ignore */\nfunction indexTypeFromJSON(_type) {\n    return new Int(_type['isSigned'], _type['bitWidth']);\n}\n/** @ignore */\nfunction typeFromJSON(f, children) {\n    const typeId = f['type']['name'];\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    switch (typeId) {\n        case 'int': {\n            const t = f['type'];\n            return new Int(t['isSigned'], t['bitWidth']);\n        }\n        case 'floatingpoint': {\n            const t = f['type'];\n            return new Float(Precision[t['precision']]);\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']]);\n        }\n        case 'time': {\n            const t = f['type'];\n            return new Time(TimeUnit[t['unit']], t['bitWidth']);\n        }\n        case 'timestamp': {\n            const t = f['type'];\n            return new Timestamp(TimeUnit[t['unit']], t['timezone']);\n        }\n        case 'interval': {\n            const t = f['type'];\n            return new Interval(IntervalUnit[t['unit']]);\n        }\n        case 'union': {\n            const t = f['type'];\n            return new Union(UnionMode[t['mode']], (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\n//# sourceMappingURL=json.mjs.map\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.\nimport { flatbuffers } from 'flatbuffers';\nimport * as Schema_ from '../../fb/Schema';\nimport * as Message_ from '../../fb/Message';\nimport { Schema, Field } from '../../schema';\nimport { toUint8Array } from '../../util/buffer';\nimport { MessageHeader, MetadataVersion } from '../../enum';\nimport { instance as typeAssembler } from '../../visitor/typeassembler';\nimport { fieldFromJSON, schemaFromJSON, recordBatchFromJSON, dictionaryBatchFromJSON } from './json';\nvar Long = flatbuffers.Long;\nvar Builder = flatbuffers.Builder;\nvar ByteBuffer = flatbuffers.ByteBuffer;\nvar Type = Schema_.org.apache.arrow.flatbuf.Type;\nvar _Field = Schema_.org.apache.arrow.flatbuf.Field;\nvar _Schema = Schema_.org.apache.arrow.flatbuf.Schema;\nvar _Buffer = Schema_.org.apache.arrow.flatbuf.Buffer;\nvar _Message = Message_.org.apache.arrow.flatbuf.Message;\nvar _KeyValue = Schema_.org.apache.arrow.flatbuf.KeyValue;\nvar _FieldNode = Message_.org.apache.arrow.flatbuf.FieldNode;\nvar _Endianness = Schema_.org.apache.arrow.flatbuf.Endianness;\nvar _RecordBatch = Message_.org.apache.arrow.flatbuf.RecordBatch;\nvar _DictionaryBatch = Message_.org.apache.arrow.flatbuf.DictionaryBatch;\nimport { DataType, Dictionary, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct, Union, Bool, Null, Int, Float, Date_, Time, Interval, Timestamp, Int32, } from '../../type';\n/**\n * @ignore\n * @private\n **/\nexport class Message {\n    constructor(bodyLength, version, headerType, header) {\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    /** @nocollapse */\n    static fromJSON(msg, headerType) {\n        const message = new Message(0, MetadataVersion.V4, headerType);\n        message._createHeader = messageHeaderFromJSON(msg, headerType);\n        return message;\n    }\n    /** @nocollapse */\n    static decode(buf) {\n        buf = new ByteBuffer(toUint8Array(buf));\n        const _message = _Message.getRootAsMessage(buf);\n        const bodyLength = _message.bodyLength();\n        const version = _message.version();\n        const headerType = _message.headerType();\n        const message = new Message(bodyLength, version, headerType);\n        message._createHeader = decodeMessageHeader(_message, headerType);\n        return message;\n    }\n    /** @nocollapse */\n    static encode(message) {\n        let b = new Builder(), headerOffset = -1;\n        if (message.isSchema()) {\n            headerOffset = Schema.encode(b, message.header());\n        }\n        else if (message.isRecordBatch()) {\n            headerOffset = RecordBatch.encode(b, message.header());\n        }\n        else if (message.isDictionaryBatch()) {\n            headerOffset = DictionaryBatch.encode(b, message.header());\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    /** @nocollapse */\n    static from(header, 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    get type() { return this.headerType; }\n    get version() { return this._version; }\n    get headerType() { return this._headerType; }\n    get bodyLength() { return this._bodyLength; }\n    header() { return this._createHeader(); }\n    isSchema() { return this.headerType === MessageHeader.Schema; }\n    isRecordBatch() { return this.headerType === MessageHeader.RecordBatch; }\n    isDictionaryBatch() { return this.headerType === MessageHeader.DictionaryBatch; }\n}\n/**\n * @ignore\n * @private\n **/\nexport class RecordBatch {\n    get nodes() { return this._nodes; }\n    get length() { return this._length; }\n    get buffers() { return this._buffers; }\n    constructor(length, nodes, buffers) {\n        this._nodes = nodes;\n        this._buffers = buffers;\n        this._length = typeof length === 'number' ? length : length.low;\n    }\n}\n/**\n * @ignore\n * @private\n **/\nexport class DictionaryBatch {\n    get id() { return this._id; }\n    get data() { return this._data; }\n    get isDelta() { return this._isDelta; }\n    get length() { return this.data.length; }\n    get nodes() { return this.data.nodes; }\n    get buffers() { return this.data.buffers; }\n    constructor(data, id, isDelta = false) {\n        this._data = data;\n        this._isDelta = isDelta;\n        this._id = typeof id === 'number' ? id : id.low;\n    }\n}\n/**\n * @ignore\n * @private\n **/\nexport class BufferRegion {\n    constructor(offset, length) {\n        this.offset = typeof offset === 'number' ? offset : offset.low;\n        this.length = typeof length === 'number' ? length : length.low;\n    }\n}\n/**\n * @ignore\n * @private\n **/\nexport class FieldNode {\n    constructor(length, nullCount) {\n        this.length = typeof length === 'number' ? length : length.low;\n        this.nullCount = typeof nullCount === 'number' ? nullCount : nullCount.low;\n    }\n}\n/** @ignore */\nfunction messageHeaderFromJSON(message, type) {\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    });\n}\n/** @ignore */\nfunction decodeMessageHeader(message, type) {\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    });\n}\nField['encode'] = encodeField;\nField['decode'] = decodeField;\nField['fromJSON'] = fieldFromJSON;\nSchema['encode'] = encodeSchema;\nSchema['decode'] = decodeSchema;\nSchema['fromJSON'] = schemaFromJSON;\nRecordBatch['encode'] = encodeRecordBatch;\nRecordBatch['decode'] = decodeRecordBatch;\nRecordBatch['fromJSON'] = recordBatchFromJSON;\nDictionaryBatch['encode'] = encodeDictionaryBatch;\nDictionaryBatch['decode'] = decodeDictionaryBatch;\nDictionaryBatch['fromJSON'] = dictionaryBatchFromJSON;\nFieldNode['encode'] = encodeFieldNode;\nFieldNode['decode'] = decodeFieldNode;\nBufferRegion['encode'] = encodeBufferRegion;\nBufferRegion['decode'] = decodeBufferRegion;\n/** @ignore */\nfunction decodeSchema(_schema, dictionaries = new Map()) {\n    const fields = decodeSchemaFields(_schema, dictionaries);\n    return new Schema(fields, decodeCustomMetadata(_schema), dictionaries);\n}\n/** @ignore */\nfunction decodeRecordBatch(batch, version = MetadataVersion.V4) {\n    return new RecordBatch(batch.length(), decodeFieldNodes(batch), decodeBuffers(batch, version));\n}\n/** @ignore */\nfunction decodeDictionaryBatch(batch, version = MetadataVersion.V4) {\n    return new DictionaryBatch(RecordBatch.decode(batch.data(), version), batch.id(), batch.isDelta());\n}\n/** @ignore */\nfunction decodeBufferRegion(b) {\n    return new BufferRegion(b.offset(), b.length());\n}\n/** @ignore */\nfunction decodeFieldNode(f) {\n    return new FieldNode(f.length(), f.nullCount());\n}\n/** @ignore */\nfunction decodeFieldNodes(batch) {\n    const nodes = [];\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/** @ignore */\nfunction decodeBuffers(batch, version) {\n    const bufferRegions = [];\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/** @ignore */\nfunction decodeSchemaFields(schema, dictionaries) {\n    const fields = [];\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/** @ignore */\nfunction decodeFieldChildren(field, dictionaries) {\n    const children = [];\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/** @ignore */\nfunction decodeField(f, dictionaries) {\n    let id;\n    let field;\n    let type;\n    let keys;\n    let dictType;\n    let dictMeta;\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) : 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) : 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/** @ignore */\nfunction decodeCustomMetadata(parent) {\n    const data = new Map();\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/** @ignore */\nfunction decodeIndexType(_type) {\n    return new Int(_type.isSigned(), _type.bitWidth());\n}\n/** @ignore */\nfunction decodeFieldType(f, children) {\n    const typeId = f.typeType();\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    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());\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/** @ignore */\nfunction encodeSchema(b, schema) {\n    const fieldOffsets = schema.fields.map((f) => Field.encode(b, f));\n    _Schema.startFieldsVector(b, fieldOffsets.length);\n    const fieldsVectorOffset = _Schema.createFieldsVector(b, fieldOffsets);\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    _Schema.startSchema(b);\n    _Schema.addFields(b, fieldsVectorOffset);\n    _Schema.addEndianness(b, platformIsLittleEndian ? _Endianness.Little : _Endianness.Big);\n    if (metadataOffset !== -1) {\n        _Schema.addCustomMetadata(b, metadataOffset);\n    }\n    return _Schema.endSchema(b);\n}\n/** @ignore */\nfunction encodeField(b, field) {\n    let nameOffset = -1;\n    let typeOffset = -1;\n    let dictionaryOffset = -1;\n    let type = field.type;\n    let typeId = field.typeId;\n    if (!DataType.isDictionary(type)) {\n        typeOffset = typeAssembler.visit(type, b);\n    }\n    else {\n        typeId = type.dictionary.typeId;\n        dictionaryOffset = typeAssembler.visit(type, b);\n        typeOffset = typeAssembler.visit(type.dictionary, b);\n    }\n    const childOffsets = (type.children || []).map((f) => Field.encode(b, f));\n    const childrenVectorOffset = _Field.createChildrenVector(b, childOffsets);\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    if (field.name) {\n        nameOffset = b.createString(field.name);\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    if (nameOffset !== -1) {\n        _Field.addName(b, nameOffset);\n    }\n    if (dictionaryOffset !== -1) {\n        _Field.addDictionary(b, dictionaryOffset);\n    }\n    if (metadataOffset !== -1) {\n        _Field.addCustomMetadata(b, metadataOffset);\n    }\n    return _Field.endField(b);\n}\n/** @ignore */\nfunction encodeRecordBatch(b, recordBatch) {\n    const nodes = recordBatch.nodes || [];\n    const buffers = recordBatch.buffers || [];\n    _RecordBatch.startNodesVector(b, nodes.length);\n    nodes.slice().reverse().forEach((n) => FieldNode.encode(b, n));\n    const nodesVectorOffset = b.endVector();\n    _RecordBatch.startBuffersVector(b, buffers.length);\n    buffers.slice().reverse().forEach((b_) => BufferRegion.encode(b, b_));\n    const buffersVectorOffset = b.endVector();\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/** @ignore */\nfunction encodeDictionaryBatch(b, 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/** @ignore */\nfunction encodeFieldNode(b, node) {\n    return _FieldNode.createFieldNode(b, new Long(node.length, 0), new Long(node.nullCount, 0));\n}\n/** @ignore */\nfunction encodeBufferRegion(b, node) {\n    return _Buffer.createBuffer(b, new Long(node.offset, 0), new Long(node.length, 0));\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//# sourceMappingURL=message.mjs.map\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.\nimport { MessageHeader } from '../enum';\nimport { flatbuffers } from 'flatbuffers';\nvar ByteBuffer = flatbuffers.ByteBuffer;\nimport { Message } from './metadata/message';\nimport { isFileHandle } from '../util/compat';\nimport { AsyncRandomAccessFile } from '../io/file';\nimport { toUint8Array } from '../util/buffer';\nimport { ByteStream, AsyncByteStream } from '../io/stream';\nimport { ArrowJSON, ITERATOR_DONE } from '../io/interfaces';\n/** @ignore */ const invalidMessageType = (type) => `Expected ${MessageHeader[type]} Message in stream, but was null or length 0.`;\n/** @ignore */ const nullMessage = (type) => `Header pointer of flatbuffer-encoded ${MessageHeader[type]} Message is null or length 0.`;\n/** @ignore */ const invalidMessageMetadata = (expected, actual) => `Expected to read ${expected} metadata bytes, but only read ${actual}.`;\n/** @ignore */ const invalidMessageBodyLength = (expected, actual) => `Expected to read ${expected} bytes for message body, but only read ${actual}.`;\n/** @ignore */\nexport class MessageReader {\n    constructor(source) {\n        this.source = source instanceof ByteStream ? source : new ByteStream(source);\n    }\n    [Symbol.iterator]() { return this; }\n    next() {\n        let r;\n        if ((r = this.readMetadataLength()).done) {\n            return ITERATOR_DONE;\n        }\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) {\n            return ITERATOR_DONE;\n        }\n        if ((r = this.readMetadata(r.value)).done) {\n            return ITERATOR_DONE;\n        }\n        return r;\n    }\n    throw(value) { return this.source.throw(value); }\n    return(value) { return this.source.return(value); }\n    readMessage(type) {\n        let r;\n        if ((r = this.next()).done) {\n            return null;\n        }\n        if ((type != null) && r.value.headerType !== type) {\n            throw new Error(invalidMessageType(type));\n        }\n        return r.value;\n    }\n    readMessageBody(bodyLength) {\n        if (bodyLength <= 0) {\n            return new Uint8Array(0);\n        }\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    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    readMetadataLength() {\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    readMetadata(metadataLength) {\n        const buf = this.source.read(metadataLength);\n        if (!buf) {\n            return ITERATOR_DONE;\n        }\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/** @ignore */\nexport class AsyncMessageReader {\n    constructor(source, byteLength) {\n        this.source = source instanceof AsyncByteStream ? source\n            : isFileHandle(source)\n                ? new AsyncRandomAccessFile(source, byteLength)\n                : new AsyncByteStream(source);\n    }\n    [Symbol.asyncIterator]() { return this; }\n    async next() {\n        let r;\n        if ((r = await this.readMetadataLength()).done) {\n            return ITERATOR_DONE;\n        }\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) {\n            return ITERATOR_DONE;\n        }\n        if ((r = await this.readMetadata(r.value)).done) {\n            return ITERATOR_DONE;\n        }\n        return r;\n    }\n    async throw(value) { return await this.source.throw(value); }\n    async return(value) { return await this.source.return(value); }\n    async readMessage(type) {\n        let r;\n        if ((r = await this.next()).done) {\n            return null;\n        }\n        if ((type != null) && r.value.headerType !== type) {\n            throw new Error(invalidMessageType(type));\n        }\n        return r.value;\n    }\n    async readMessageBody(bodyLength) {\n        if (bodyLength <= 0) {\n            return new Uint8Array(0);\n        }\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    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    async readMetadataLength() {\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    async readMetadata(metadataLength) {\n        const buf = await this.source.read(metadataLength);\n        if (!buf) {\n            return ITERATOR_DONE;\n        }\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/** @ignore */\nexport class JSONMessageReader extends MessageReader {\n    constructor(source) {\n        super(new Uint8Array(0));\n        this._schema = false;\n        this._body = [];\n        this._batchIndex = 0;\n        this._dictionaryIndex = 0;\n        this._json = source instanceof ArrowJSON ? source : new ArrowJSON(source);\n    }\n    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    readMessageBody(_bodyLength) {\n        return flattenDataSources(this._body);\n        function flattenDataSources(xs) {\n            return (xs || []).reduce((buffers, column) => [\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            ], []);\n        }\n    }\n    readMessage(type) {\n        let r;\n        if ((r = this.next()).done) {\n            return null;\n        }\n        if ((type != null) && r.value.headerType !== type) {\n            throw new Error(invalidMessageType(type));\n        }\n        return r.value;\n    }\n    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/** @ignore */\nexport const PADDING = 4;\n/** @ignore */\nexport const MAGIC_STR = 'ARROW1';\n/** @ignore */\nexport const MAGIC = new Uint8Array(MAGIC_STR.length);\nfor (let i = 0; i < MAGIC_STR.length; i += 1 | 0) {\n    MAGIC[i] = MAGIC_STR.charCodeAt(i);\n}\n/** @ignore */\nexport function checkForMagicArrowString(buffer, 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/** @ignore */\nexport const magicLength = MAGIC.length;\n/** @ignore */\nexport const magicAndPadding = magicLength + PADDING;\n/** @ignore */\nexport const magicX2AndPadding = magicLength * 2 + PADDING;\n\n//# sourceMappingURL=message.mjs.map\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.\nimport { Visitor } from '../visitor';\nimport { UnionMode } from '../enum';\nimport { RecordBatch } from '../recordbatch';\nimport { rebaseValueOffsets } from '../util/buffer';\nimport { packBools, truncateBitmap } from '../util/bit';\nimport { selectVectorChildrenArgs } from '../util/args';\nimport { BufferRegion, FieldNode } from '../ipc/metadata/message';\nimport { DataType, } from '../type';\n/** @ignore */\nexport class VectorAssembler extends Visitor {\n    constructor() {\n        super();\n        this._byteLength = 0;\n        this._nodes = [];\n        this._buffers = [];\n        this._bufferRegions = [];\n    }\n    /** @nocollapse */\n    static assemble(...args) {\n        const assembler = new VectorAssembler();\n        const vectorChildren = selectVectorChildrenArgs(RecordBatch, args);\n        const [assembleResult = assembler] = assembler.visitMany(vectorChildren);\n        return assembleResult;\n    }\n    visit(vector) {\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            this.nodes.push(new FieldNode(length, nullCount));\n        }\n        return super.visit(vector);\n    }\n    visitNull(_nullV) {\n        return this;\n    }\n    visitDictionary(vector) {\n        // Assemble the indices here, Dictionary assembled separately.\n        return this.visit(vector.indices);\n    }\n    get nodes() { return this._nodes; }\n    get buffers() { return this._buffers; }\n    get byteLength() { return this._byteLength; }\n    get bufferRegions() { return this._bufferRegions; }\n}\n/** @ignore */\nfunction addBuffer(values) {\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/** @ignore */\nfunction assembleUnion(vector) {\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    }\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        }\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, 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/** @ignore */\nfunction assembleBoolVector(vector) {\n    // Bool vector is a special case of FlatVector, as its data buffer needs to stay packed\n    let values;\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    }\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/** @ignore */\nfunction assembleFlatVector(vector) {\n    return addBuffer.call(this, vector.values.subarray(0, vector.length * vector.stride));\n}\n/** @ignore */\nfunction assembleFlatListVector(vector) {\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/** @ignore */\nfunction assembleListVector(vector) {\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/** @ignore */\nfunction assembleNestedVector(vector) {\n    return this.visitMany(vector.type.children.map((_, i) => vector.getChildAt(i)).filter(Boolean))[0];\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\n//# sourceMappingURL=vectorassembler.mjs.map\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.\nimport { Table } from '../table';\nimport { MAGIC } from './message';\nimport { Column } from '../column';\nimport { DataType } from '../type';\nimport { 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 { AsyncByteQueue } from '../io/stream';\nimport { VectorAssembler } from '../visitor/vectorassembler';\nimport { JSONTypeAssembler } from '../visitor/jsontypeassembler';\nimport { JSONVectorAssembler } from '../visitor/jsonvectorassembler';\nimport { toUint8Array } from '../util/buffer';\nimport { RecordBatch, _InternalEmptyPlaceholderRecordBatch } from '../recordbatch';\nimport { ReadableInterop } from '../io/interfaces';\nimport { isPromise, isAsyncIterable, isWritableDOMStream, isWritableNodeStream, isIterable, isObject } from '../util/compat';\nexport class RecordBatchWriter extends ReadableInterop {\n    constructor(options) {\n        super();\n        this._position = 0;\n        this._started = false;\n        // @ts-ignore\n        this._sink = new AsyncByteQueue();\n        this._schema = null;\n        this._dictionaryBlocks = [];\n        this._recordBatchBlocks = [];\n        this._dictionaryDeltaOffsets = new Map();\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    /** @nocollapse */\n    // @ts-ignore\n    static throughNode(options) {\n        throw new Error(`\"throughNode\" not available in this environment`);\n    }\n    /** @nocollapse */\n    static throughDOM(\n    // @ts-ignore\n    writableStrategy, \n    // @ts-ignore\n    readableStrategy) {\n        throw new Error(`\"throughDOM\" not available in this environment`);\n    }\n    toString(sync = false) {\n        return this._sink.toString(sync);\n    }\n    toUint8Array(sync = false) {\n        return this._sink.toUint8Array(sync);\n    }\n    writeAll(input) {\n        if (isPromise(input)) {\n            return input.then((x) => this.writeAll(x));\n        }\n        else if (isAsyncIterable(input)) {\n            return writeAllAsync(this, input);\n        }\n        return writeAll(this, input);\n    }\n    get closed() { return this._sink.closed; }\n    [Symbol.asyncIterator]() { return this._sink[Symbol.asyncIterator](); }\n    toDOMStream(options) { return this._sink.toDOMStream(options); }\n    toNodeStream(options) { return this._sink.toNodeStream(options); }\n    close() {\n        return this.reset()._sink.close();\n    }\n    abort(reason) {\n        return this.reset()._sink.abort(reason);\n    }\n    finish() {\n        this._autoDestroy ? this.close() : this.reset(this._sink, this._schema);\n        return this;\n    }\n    reset(sink = this._sink, schema = null) {\n        if ((sink === this._sink) || (sink instanceof AsyncByteQueue)) {\n            this._sink = sink;\n        }\n        else {\n            this._sink = new AsyncByteQueue();\n            if (sink && isWritableDOMStream(sink)) {\n                this.toDOMStream({ type: 'bytes' }).pipeTo(sink);\n            }\n            else if (sink && isWritableNodeStream(sink)) {\n                this.toNodeStream({ objectMode: false }).pipe(sink);\n            }\n        }\n        if (this._started && this._schema) {\n            this._writeFooter(this._schema);\n        }\n        this._started = false;\n        this._dictionaryBlocks = [];\n        this._recordBatchBlocks = [];\n        this._dictionaryDeltaOffsets = new Map();\n        if (!schema || !(schema.compareTo(this._schema))) {\n            if (schema === null) {\n                this._position = 0;\n                this._schema = null;\n            }\n            else {\n                this._started = true;\n                this._schema = schema;\n                this._writeSchema(schema);\n            }\n        }\n        return this;\n    }\n    write(payload) {\n        let schema = null;\n        if (!this._sink) {\n            throw new Error(`RecordBatchWriter is closed`);\n        }\n        else if (payload === null || payload === undefined) {\n            return this.finish() && undefined;\n        }\n        else if (payload instanceof Table && !(schema = payload.schema)) {\n            return this.finish() && undefined;\n        }\n        else if (payload instanceof RecordBatch && !(schema = payload.schema)) {\n            return this.finish() && undefined;\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        if (payload instanceof RecordBatch) {\n            if (!(payload instanceof _InternalEmptyPlaceholderRecordBatch)) {\n                this._writeRecordBatch(payload);\n            }\n        }\n        else if (payload instanceof Table) {\n            this.writeAll(payload.chunks);\n        }\n        else if (isIterable(payload)) {\n            this.writeAll(payload);\n        }\n    }\n    _writeMessage(message, alignment = 8) {\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        if (message.headerType === MessageHeader.RecordBatch) {\n            this._recordBatchBlocks.push(new FileBlock(alignedSize, message.bodyLength, this._position));\n        }\n        else if (message.headerType === MessageHeader.DictionaryBatch) {\n            this._dictionaryBlocks.push(new FileBlock(alignedSize, message.bodyLength, this._position));\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) {\n            this._write(buffer);\n        }\n        // Write any padding\n        return this._writePadding(nPaddingBytes);\n    }\n    _write(chunk) {\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    _writeSchema(schema) {\n        return this._writeMessage(Message.from(schema));\n    }\n    // @ts-ignore\n    _writeFooter(schema) {\n        // eos bytes\n        return this._writeLegacyIpcFormat\n            ? this._write(Int32Array.of(0))\n            : this._write(Int32Array.of(-1, 0));\n    }\n    _writeMagic() {\n        return this._write(MAGIC);\n    }\n    _writePadding(nBytes) {\n        return nBytes > 0 ? this._write(new Uint8Array(nBytes)) : this;\n    }\n    _writeRecordBatch(batch) {\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    _writeDictionaryBatch(dictionary, id, 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    _writeBodyBuffers(buffers) {\n        let buffer;\n        let size, padding;\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    _writeDictionaries(batch) {\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.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/** @ignore */\nexport class RecordBatchStreamWriter extends RecordBatchWriter {\n    /** @nocollapse */\n    static writeAll(input, options) {\n        const writer = new RecordBatchStreamWriter(options);\n        if (isPromise(input)) {\n            return input.then((x) => writer.writeAll(x));\n        }\n        else if (isAsyncIterable(input)) {\n            return writeAllAsync(writer, input);\n        }\n        return writeAll(writer, input);\n    }\n}\n/** @ignore */\nexport class RecordBatchFileWriter extends RecordBatchWriter {\n    constructor() {\n        super();\n        this._autoDestroy = true;\n    }\n    /** @nocollapse */\n    static writeAll(input) {\n        const writer = new RecordBatchFileWriter();\n        if (isPromise(input)) {\n            return input.then((x) => writer.writeAll(x));\n        }\n        else if (isAsyncIterable(input)) {\n            return writeAllAsync(writer, input);\n        }\n        return writeAll(writer, input);\n    }\n    // @ts-ignore\n    _writeSchema(schema) {\n        return this._writeMagic()._writePadding(2);\n    }\n    _writeFooter(schema) {\n        const buffer = Footer.encode(new Footer(schema, MetadataVersion.V4, this._recordBatchBlocks, this._dictionaryBlocks));\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/** @ignore */\nexport class RecordBatchJSONWriter extends RecordBatchWriter {\n    constructor() {\n        super();\n        this._autoDestroy = true;\n        this._recordBatches = [];\n        this._dictionaries = [];\n    }\n    /** @nocollapse */\n    static writeAll(input) {\n        return new RecordBatchJSONWriter().writeAll(input);\n    }\n    _writeMessage() { return this; }\n    // @ts-ignore\n    _writeFooter(schema) { return this; }\n    _writeSchema(schema) {\n        return this._write(`{\\n  \"schema\": ${JSON.stringify({ fields: schema.fields.map(fieldToJSON) }, null, 2)}`);\n    }\n    _writeDictionaries(batch) {\n        if (batch.dictionaries.size > 0) {\n            this._dictionaries.push(batch);\n        }\n        return this;\n    }\n    _writeDictionaryBatch(dictionary, id, 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    _writeRecordBatch(batch) {\n        this._writeDictionaries(batch);\n        this._recordBatches.push(batch);\n        return this;\n    }\n    close() {\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        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        if (this._schema) {\n            this._write(`\\n}`);\n        }\n        this._dictionaries = [];\n        this._recordBatches = [];\n        return super.close();\n    }\n}\n/** @ignore */\nfunction writeAll(writer, input) {\n    let chunks = input;\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/** @ignore */\nasync function writeAllAsync(writer, batches) {\n    for await (const batch of batches) {\n        writer.write(batch);\n    }\n    return writer.finish();\n}\n/** @ignore */\nfunction fieldToJSON({ name, type, nullable }) {\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/** @ignore */\nfunction dictionaryBatchToJSON(dictionary, id, 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/** @ignore */\nfunction recordBatchToJSON(records) {\n    return JSON.stringify({\n        'count': records.length,\n        'columns': JSONVectorAssembler.assemble(records)\n    }, null, 2);\n}\n\n//# sourceMappingURL=writer.mjs.map\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.\nimport { Data } from '../data';\nimport { Schema } from '../schema';\nimport { Chunked } from '../vector/chunked';\nimport { RecordBatch } from '../recordbatch';\nconst noopBuf = new Uint8Array(0);\nconst nullBufs = (bitmapLength) => [\n    noopBuf, noopBuf, new Uint8Array(bitmapLength), noopBuf\n];\n/** @ignore */\nexport function ensureSameLengthData(schema, chunks, batchLength = chunks.reduce((l, c) => Math.max(l, c.length), 0)) {\n    let data;\n    let field;\n    let i = -1, n = chunks.length;\n    const fields = [...schema.fields];\n    const batchData = [];\n    const bitmapLength = ((batchLength + 63) & ~63) >> 3;\n    while (++i < n) {\n        if ((data = chunks[i]) && data.length === batchLength) {\n            batchData[i] = data;\n        }\n        else {\n            (field = fields[i]).nullable || (fields[i] = fields[i].clone({ nullable: true }));\n            batchData[i] = data ? data._changeLengthAndBackfillNullBitmap(batchLength)\n                : Data.new(field.type, 0, batchLength, batchLength, nullBufs(bitmapLength));\n        }\n    }\n    return [new Schema(fields), batchLength, batchData];\n}\n/** @ignore */\nexport function distributeColumnsIntoRecordBatches(columns) {\n    return distributeVectorsIntoRecordBatches(new Schema(columns.map(({ field }) => field)), columns);\n}\n/** @ignore */\nexport function distributeVectorsIntoRecordBatches(schema, vecs) {\n    return uniformlyDistributeChunksAcrossRecordBatches(schema, vecs.map((v) => v instanceof Chunked ? v.chunks.map((c) => c.data) : [v.data]));\n}\n/** @ignore */\nfunction uniformlyDistributeChunksAcrossRecordBatches(schema, columns) {\n    const fields = [...schema.fields];\n    const batchArgs = [];\n    const memo = { numBatches: columns.reduce((n, c) => Math.max(n, c.length), 0) };\n    let numBatches = 0, batchLength = 0;\n    let i = -1, numColumns = columns.length;\n    let child, childData = [];\n    while (memo.numBatches-- > 0) {\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        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(fields, schema.metadata),\n        batchArgs.map((xs) => new RecordBatch(schema, ...xs))\n    ];\n}\n/** @ignore */\nfunction distributeChildData(fields, batchLength, childData, columns, memo) {\n    let data;\n    let field;\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            }\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        }\n        else {\n            (field = fields[i]).nullable || (fields[i] = field.clone({ nullable: true }));\n            childData[i] = data ? data._changeLengthAndBackfillNullBitmap(batchLength)\n                : Data.new(field.type, 0, batchLength, batchLength, nullBufs(bitmapLength));\n        }\n    }\n    return childData;\n}\n\n//# sourceMappingURL=recordbatch.mjs.map\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.\nimport { Type } from '../enum';\nimport { Chunked } from './chunked';\nimport { clampRange } from '../util/vector';\nimport { AbstractVector, Vector } from '../vector';\n/** @ignore */\nexport class BaseVector extends AbstractVector {\n    constructor(data, children) {\n        super();\n        this._children = children;\n        this.numChildren = data.childData.length;\n        this._bindDataAccessors(this.data = data);\n    }\n    get type() { return this.data.type; }\n    get typeId() { return this.data.typeId; }\n    get length() { return this.data.length; }\n    get offset() { return this.data.offset; }\n    get stride() { return this.data.stride; }\n    get nullCount() { return this.data.nullCount; }\n    get byteLength() { return this.data.byteLength; }\n    get VectorName() { return `${Type[this.typeId]}Vector`; }\n    get ArrayType() { return this.type.ArrayType; }\n    get values() { return this.data.values; }\n    get typeIds() { return this.data.typeIds; }\n    get nullBitmap() { return this.data.nullBitmap; }\n    get valueOffsets() { return this.data.valueOffsets; }\n    get [Symbol.toStringTag]() { return `${this.VectorName}<${this.type[Symbol.toStringTag]}>`; }\n    clone(data, children = this._children) {\n        return Vector.new(data, children);\n    }\n    concat(...others) {\n        return Chunked.concat(this, ...others);\n    }\n    slice(begin, end) {\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    isValid(index) {\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    getChildAt(index) {\n        return index < 0 || index >= this.numChildren ? null : ((this._children || (this._children = []))[index] ||\n            (this._children[index] = Vector.new(this.data.childData[index])));\n    }\n    toJSON() { return [...this]; }\n    _sliceInternal(self, begin, end) {\n        return self.clone(self.data.slice(begin, end - begin), null);\n    }\n    // @ts-ignore\n    _bindDataAccessors(data) {\n        // Implementation in src/vectors/index.ts due to circular dependency/packaging shenanigans\n    }\n}\nBaseVector.prototype[Symbol.isConcatSpreadable] = true;\n\n//# sourceMappingURL=base.mjs.map\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.\nimport { Vector } from '../vector';\nimport { BaseVector } from './base';\nimport { Utf8 } from '../type';\n/** @ignore */\nexport class BinaryVector extends BaseVector {\n    asUtf8() {\n        return Vector.new(this.data.clone(new Utf8()));\n    }\n}\n\n//# sourceMappingURL=binary.mjs.map\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.\nimport { Bool } from '../type';\nimport { BaseVector } from './base';\nimport { vectorFromValuesWithType } from './index';\n/** @ignore */\nexport class BoolVector extends BaseVector {\n    /** @nocollapse */\n    static from(input) {\n        return vectorFromValuesWithType(() => new Bool(), input);\n    }\n}\n\n//# sourceMappingURL=bool.mjs.map\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.\nimport { DateUnit } from '../enum';\nimport { BaseVector } from './base';\nimport { vectorFromValuesWithType } from './index';\nimport { DateDay, DateMillisecond } from '../type';\n/** @ignore */\nexport class DateVector extends BaseVector {\n    /** @nocollapse */\n    static from(...args) {\n        if (args.length === 2) {\n            return vectorFromValuesWithType(() => args[1] === DateUnit.DAY ? new DateDay() : new DateMillisecond(), args[0]);\n        }\n        return vectorFromValuesWithType(() => new DateMillisecond(), args[0]);\n    }\n}\n/** @ignore */\nexport class DateDayVector extends DateVector {\n}\n/** @ignore */\nexport class DateMillisecondVector extends DateVector {\n}\n\n//# sourceMappingURL=date.mjs.map\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.\nimport { BaseVector } from './base';\n/** @ignore */\nexport class DecimalVector extends BaseVector {\n}\n\n//# sourceMappingURL=decimal.mjs.map\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.\nimport { Data } from '../data';\nimport { Vector } from '../vector';\nimport { BaseVector } from './base';\nimport { vectorFromValuesWithType } from './index';\nimport { Dictionary } from '../type';\n/** @ignore */\nexport class DictionaryVector extends BaseVector {\n    constructor(data) {\n        super(data);\n        this.indices = Vector.new(data.clone(this.type.indices));\n    }\n    /** @nocollapse */\n    static from(...args) {\n        if (args.length === 3) {\n            const [values, indices, keys] = args;\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    get dictionary() { return this.data.dictionary; }\n    reverseLookup(value) { return this.dictionary.indexOf(value); }\n    getKey(idx) { return this.indices.get(idx); }\n    getValue(key) { return this.dictionary.get(key); }\n    setKey(idx, key) { return this.indices.set(idx, key); }\n    setValue(key, value) { return this.dictionary.set(key, value); }\n}\nDictionaryVector.prototype.indices = null;\n\n//# sourceMappingURL=dictionary.mjs.map\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.\nimport { BaseVector } from './base';\n/** @ignore */\nexport class FixedSizeBinaryVector extends BaseVector {\n}\n\n//# sourceMappingURL=fixedsizebinary.mjs.map\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.\nimport { BaseVector } from './base';\n/** @ignore */\nexport class FixedSizeListVector extends BaseVector {\n}\n\n//# sourceMappingURL=fixedsizelist.mjs.map\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.\nimport { Data } from '../data';\nimport { Vector } from '../vector';\nimport { BaseVector } from './base';\nimport { vectorFromValuesWithType } from './index';\nimport { Float16, Float32, Float64 } from '../type';\n/** @ignore */\nexport class FloatVector extends BaseVector {\n    /** @nocollapse */\n    static from(input) {\n        let ArrowType = vectorTypeToDataType(this);\n        if ((input instanceof ArrayBuffer) || ArrayBuffer.isView(input)) {\n            let InputType = arrayTypeToDataType(input.constructor) || 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));\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(), input);\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        throw new TypeError('Unrecognized FloatVector input');\n    }\n}\n/** @ignore */\nexport class Float16Vector extends FloatVector {\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    toFloat32Array() { return new Float32Array(this); }\n    toFloat64Array() { return new Float64Array(this); }\n}\n/** @ignore */\nexport class Float32Vector extends FloatVector {\n}\n/** @ignore */\nexport class Float64Vector extends FloatVector {\n}\nconst convertTo16Bit = (typeCtor, dataCtor) => {\n    return (typeCtor === Float16) && (dataCtor !== Uint16Array);\n};\n/** @ignore */\nconst arrayTypeToDataType = (ctor) => {\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/** @ignore */\nconst vectorTypeToDataType = (ctor) => {\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\n//# sourceMappingURL=float.mjs.map\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.\nimport { BaseVector } from './base';\n/** @ignore */\nexport class IntervalVector extends BaseVector {\n}\n/** @ignore */\nexport class IntervalDayTimeVector extends IntervalVector {\n}\n/** @ignore */\nexport class IntervalYearMonthVector extends IntervalVector {\n}\n\n//# sourceMappingURL=interval.mjs.map\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.\nimport { Data } from '../data';\nimport { Vector } from '../vector';\nimport { BaseVector } from './base';\nimport { vectorFromValuesWithType } from './index';\nimport { BigInt64Array, BigUint64Array } from '../util/compat';\nimport { toBigInt64Array, toBigUint64Array } from '../util/buffer';\nimport { Uint8, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64 } from '../type';\n/** @ignore */\nexport class IntVector extends BaseVector {\n    /** @nocollapse */\n    static from(...args) {\n        let [input, is64bit = false] = args;\n        let ArrowType = vectorTypeToDataType(this, is64bit);\n        if ((input instanceof ArrayBuffer) || ArrayBuffer.isView(input)) {\n            let InputType = arrayTypeToDataType(input.constructor, 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));\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(), input);\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        throw new TypeError('Unrecognized IntVector input');\n    }\n}\n/** @ignore */\nexport class Int8Vector extends IntVector {\n}\n/** @ignore */\nexport class Int16Vector extends IntVector {\n}\n/** @ignore */\nexport class Int32Vector extends IntVector {\n}\n/** @ignore */\nexport class Int64Vector extends IntVector {\n    toBigInt64Array() {\n        return toBigInt64Array(this.values);\n    }\n    get values64() {\n        return this._values64 || (this._values64 = this.toBigInt64Array());\n    }\n}\n/** @ignore */\nexport class Uint8Vector extends IntVector {\n}\n/** @ignore */\nexport class Uint16Vector extends IntVector {\n}\n/** @ignore */\nexport class Uint32Vector extends IntVector {\n}\n/** @ignore */\nexport class Uint64Vector extends IntVector {\n    toBigUint64Array() {\n        return toBigUint64Array(this.values);\n    }\n    get values64() {\n        return this._values64 || (this._values64 = this.toBigUint64Array());\n    }\n}\nconst convert32To64Bit = (typeCtor, dataCtor) => {\n    return (typeCtor === Int64 || typeCtor === Uint64) &&\n        (dataCtor === Int32Array || dataCtor === Uint32Array);\n};\n/** @ignore */\nconst arrayTypeToDataType = (ctor, is64bit) => {\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/** @ignore */\nconst vectorTypeToDataType = (ctor, is64bit) => {\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\n//# sourceMappingURL=int.mjs.map\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.\nimport { BaseVector } from './base';\n/** @ignore */\nexport class ListVector extends BaseVector {\n}\n\n//# sourceMappingURL=list.mjs.map\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.\nimport { MapRow } from './row';\nimport { Vector } from '../vector';\nimport { BaseVector } from './base';\nimport { List } from '../type';\n/** @ignore */\nexport class MapVector extends BaseVector {\n    asList() {\n        const child = this.type.children[0];\n        return Vector.new(this.data.clone(new List(child)));\n    }\n    bind(index) {\n        const child = this.getChildAt(0);\n        const { [index]: begin, [index + 1]: end } = this.valueOffsets;\n        return new MapRow(child.slice(begin, end));\n    }\n}\n\n//# sourceMappingURL=map.mjs.map\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.\nimport { BaseVector } from './base';\n/** @ignore */\nexport class NullVector extends BaseVector {\n}\n\n//# sourceMappingURL=null.mjs.map\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.\nimport { StructRow } from './row';\nimport { BaseVector } from './base';\n/** @ignore */ const kRowIndex = Symbol.for('rowIndex');\n/** @ignore */\nexport class StructVector extends BaseVector {\n    bind(index) {\n        const proto = this._row || (this._row = new StructRow(this));\n        const bound = Object.create(proto);\n        bound[kRowIndex] = index;\n        return bound;\n    }\n}\n\n//# sourceMappingURL=struct.mjs.map\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.\nimport { BaseVector } from './base';\n/** @ignore */\nexport class TimestampVector extends BaseVector {\n}\n/** @ignore */\nexport class TimestampSecondVector extends TimestampVector {\n}\n/** @ignore */\nexport class TimestampMillisecondVector extends TimestampVector {\n}\n/** @ignore */\nexport class TimestampMicrosecondVector extends TimestampVector {\n}\n/** @ignore */\nexport class TimestampNanosecondVector extends TimestampVector {\n}\n\n//# sourceMappingURL=timestamp.mjs.map\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.\nimport { BaseVector } from './base';\n/** @ignore */\nexport class TimeVector extends BaseVector {\n}\n/** @ignore */\nexport class TimeSecondVector extends TimeVector {\n}\n/** @ignore */\nexport class TimeMillisecondVector extends TimeVector {\n}\n/** @ignore */\nexport class TimeMicrosecondVector extends TimeVector {\n}\n/** @ignore */\nexport class TimeNanosecondVector extends TimeVector {\n}\n\n//# sourceMappingURL=time.mjs.map\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.\nimport { BaseVector } from './base';\n/** @ignore */\nexport class UnionVector extends BaseVector {\n    get typeIdToChildIndex() { return this.data.type.typeIdToChildIndex; }\n}\n/** @ignore */\nexport class DenseUnionVector extends UnionVector {\n    get valueOffsets() { return this.data.valueOffsets; }\n}\n/** @ignore */\nexport class SparseUnionVector extends UnionVector {\n}\n\n//# sourceMappingURL=union.mjs.map\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.\nimport { Vector } from '../vector';\nimport { BaseVector } from './base';\nimport { Binary, Utf8 } from '../type';\nimport { vectorFromValuesWithType } from './index';\n/** @ignore */\nexport class Utf8Vector extends BaseVector {\n    /** @nocollapse */\n    static from(input) {\n        return vectorFromValuesWithType(() => new Utf8(), input);\n    }\n    asBinary() {\n        return Vector.new(this.data.clone(new Binary()));\n    }\n}\n\n//# sourceMappingURL=utf8.mjs.map\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/** @ignore */\nexport function partial0(visit) {\n    return function () { return visit(this); };\n}\n/** @ignore */\nexport function partial1(visit) {\n    return function (a) { return visit(this, a); };\n}\n/** @ignore */\nexport function partial2(visit) {\n    return function (a, b) { return visit(this, a, b); };\n}\n\n//# sourceMappingURL=fn.mjs.map\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.\nimport { BN } from '../util/bn';\nimport { Visitor } from '../visitor';\nimport { decodeUtf8 } from '../util/utf8';\nimport { uint16ToFloat64 } from '../util/math';\nimport { UnionMode, Precision, DateUnit, TimeUnit, IntervalUnit } from '../enum';\n/** @ignore */\nexport class GetVisitor extends Visitor {\n}\n/** @ignore */ const epochDaysToMs = (data, index) => 86400000 * data[index];\n/** @ignore */ const epochMillisecondsLongToMs = (data, index) => 4294967296 * (data[index + 1]) + (data[index] >>> 0);\n/** @ignore */ const epochMicrosecondsLongToMs = (data, index) => 4294967296 * (data[index + 1] / 1000) + ((data[index] >>> 0) / 1000);\n/** @ignore */ const epochNanosecondsLongToMs = (data, index) => 4294967296 * (data[index + 1] / 1000000) + ((data[index] >>> 0) / 1000000);\n/** @ignore */ const epochMillisecondsToDate = (epochMs) => new Date(epochMs);\n/** @ignore */ const epochDaysToDate = (data, index) => epochMillisecondsToDate(epochDaysToMs(data, index));\n/** @ignore */ const epochMillisecondsLongToDate = (data, index) => epochMillisecondsToDate(epochMillisecondsLongToMs(data, index));\n/** @ignore */\nconst getNull = (_vector, _index) => null;\n/** @ignore */\nconst getVariableWidthBytes = (values, valueOffsets, index) => {\n    const { [index]: x, [index + 1]: y } = valueOffsets;\n    return x != null && y != null ? values.subarray(x, y) : null;\n};\n/** @ignore */\nconst getBool = ({ offset, values }, index) => {\n    const idx = offset + index;\n    const byte = values[idx >> 3];\n    return (byte & 1 << (idx % 8)) !== 0;\n};\n/** @ignore */\nconst getDateDay = ({ values }, index) => epochDaysToDate(values, index);\n/** @ignore */\nconst getDateMillisecond = ({ values }, index) => epochMillisecondsLongToDate(values, index * 2);\n/** @ignore */\nconst getNumeric = ({ stride, values }, index) => values[stride * index];\n/** @ignore */\nconst getFloat16 = ({ stride, values }, index) => uint16ToFloat64(values[stride * index]);\n/** @ignore */\nconst getBigInts = ({ stride, values, type }, index) => BN.new(values.subarray(stride * index, stride * (index + 1)), type.isSigned);\n/** @ignore */\nconst getFixedSizeBinary = ({ stride, values }, index) => values.subarray(stride * index, stride * (index + 1));\n/** @ignore */\nconst getBinary = ({ values, valueOffsets }, index) => getVariableWidthBytes(values, valueOffsets, index);\n/** @ignore */\nconst getUtf8 = ({ values, valueOffsets }, index) => {\n    const bytes = getVariableWidthBytes(values, valueOffsets, index);\n    return bytes !== null ? decodeUtf8(bytes) : null;\n};\n/* istanbul ignore next */\n/** @ignore */\nconst getInt = (vector, index) => (vector.type.bitWidth < 64\n    ? getNumeric(vector, index)\n    : getBigInts(vector, index));\n/* istanbul ignore next */\n/** @ignore */\nconst getFloat = (vector, index) => (vector.type.precision !== Precision.HALF\n    ? getNumeric(vector, index)\n    : getFloat16(vector, index));\n/* istanbul ignore next */\n/** @ignore */\nconst getDate = (vector, index) => (vector.type.unit === DateUnit.DAY\n    ? getDateDay(vector, index)\n    : getDateMillisecond(vector, index));\n/** @ignore */\nconst getTimestampSecond = ({ values }, index) => 1000 * epochMillisecondsLongToMs(values, index * 2);\n/** @ignore */\nconst getTimestampMillisecond = ({ values }, index) => epochMillisecondsLongToMs(values, index * 2);\n/** @ignore */\nconst getTimestampMicrosecond = ({ values }, index) => epochMicrosecondsLongToMs(values, index * 2);\n/** @ignore */\nconst getTimestampNanosecond = ({ values }, index) => epochNanosecondsLongToMs(values, index * 2);\n/* istanbul ignore next */\n/** @ignore */\nconst getTimestamp = (vector, index) => {\n    switch (vector.type.unit) {\n        case TimeUnit.SECOND: return getTimestampSecond(vector, index);\n        case TimeUnit.MILLISECOND: return getTimestampMillisecond(vector, index);\n        case TimeUnit.MICROSECOND: return getTimestampMicrosecond(vector, index);\n        case TimeUnit.NANOSECOND: return getTimestampNanosecond(vector, index);\n    }\n};\n/** @ignore */\nconst getTimeSecond = ({ values, stride }, index) => values[stride * index];\n/** @ignore */\nconst getTimeMillisecond = ({ values, stride }, index) => values[stride * index];\n/** @ignore */\nconst getTimeMicrosecond = ({ values }, index) => BN.signed(values.subarray(2 * index, 2 * (index + 1)));\n/** @ignore */\nconst getTimeNanosecond = ({ values }, index) => BN.signed(values.subarray(2 * index, 2 * (index + 1)));\n/* istanbul ignore next */\n/** @ignore */\nconst getTime = (vector, index) => {\n    switch (vector.type.unit) {\n        case TimeUnit.SECOND: return getTimeSecond(vector, index);\n        case TimeUnit.MILLISECOND: return getTimeMillisecond(vector, index);\n        case TimeUnit.MICROSECOND: return getTimeMicrosecond(vector, index);\n        case TimeUnit.NANOSECOND: return getTimeNanosecond(vector, index);\n    }\n};\n/** @ignore */\nconst getDecimal = ({ values }, index) => BN.decimal(values.subarray(4 * index, 4 * (index + 1)));\n/** @ignore */\nconst getList = (vector, index) => {\n    const child = vector.getChildAt(0), { valueOffsets, stride } = vector;\n    return child.slice(valueOffsets[index * stride], valueOffsets[(index * stride) + 1]);\n};\n/** @ignore */\nconst getMap = (vector, index) => {\n    return vector.bind(index);\n};\n/** @ignore */\nconst getStruct = (vector, index) => {\n    return vector.bind(index);\n};\n/* istanbul ignore next */\n/** @ignore */\nconst getUnion = (vector, index) => {\n    return vector.type.mode === UnionMode.Dense ?\n        getDenseUnion(vector, index) :\n        getSparseUnion(vector, index);\n};\n/** @ignore */\nconst getDenseUnion = (vector, index) => {\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/** @ignore */\nconst getSparseUnion = (vector, index) => {\n    const childIndex = vector.typeIdToChildIndex[vector.typeIds[index]];\n    const child = vector.getChildAt(childIndex);\n    return child ? child.get(index) : null;\n};\n/** @ignore */\nconst getDictionary = (vector, index) => {\n    return vector.getValue(vector.getKey(index));\n};\n/* istanbul ignore next */\n/** @ignore */\nconst getInterval = (vector, index) => (vector.type.unit === IntervalUnit.DAY_TIME)\n    ? getIntervalDayTime(vector, index)\n    : getIntervalYearMonth(vector, index);\n/** @ignore */\nconst getIntervalDayTime = ({ values }, index) => values.subarray(2 * index, 2 * (index + 1));\n/** @ignore */\nconst getIntervalYearMonth = ({ values }, index) => {\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/** @ignore */\nconst getFixedSizeList = (vector, index) => {\n    const child = vector.getChildAt(0), { stride } = vector;\n    return child.slice(index * stride, (index + 1) * stride);\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/** @ignore */\nexport const instance = new GetVisitor();\n\n//# sourceMappingURL=get.mjs.map\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.\nimport { Visitor } from '../visitor';\nimport { getBool, iterateBits } from '../util/bit';\nimport { createElementComparator } from '../util/vector';\n/** @ignore */\nexport class IndexOfVisitor extends Visitor {\n}\n/** @ignore */\nfunction nullIndexOf(vector, searchElement) {\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/** @ignore */\nfunction indexOfNull(vector, fromIndex) {\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) {\n            return i;\n        }\n        ++i;\n    }\n    return -1;\n}\n/** @ignore */\nfunction indexOfValue(vector, searchElement, fromIndex) {\n    if (searchElement === undefined) {\n        return -1;\n    }\n    if (searchElement === null) {\n        return indexOfNull(vector, fromIndex);\n    }\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/** @ignore */\nfunction indexOfUnion(vector, searchElement, fromIndex) {\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}\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/** @ignore */\nexport const instance = new IndexOfVisitor();\n\n//# sourceMappingURL=indexof.mjs.map\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.\nimport { Type } from '../enum';\nimport { Visitor } from '../visitor';\nimport { iterateBits } from '../util/bit';\nimport { instance as getVisitor } from './get';\n/** @ignore */\nexport class IteratorVisitor extends Visitor {\n}\n/** @ignore */\nfunction nullableIterator(vector) {\n    const getFn = getVisitor.getVisitFn(vector);\n    return iterateBits(vector.nullBitmap, vector.offset, vector.length, vector, (vec, idx, nullByte, nullBit) => ((nullByte & 1 << nullBit) !== 0) ? getFn(vec, idx) : null);\n}\n/** @ignore */\nfunction vectorIterator(vector) {\n    // If nullable, iterate manually\n    if (vector.nullCount > 0) {\n        return nullableIterator(vector);\n    }\n    const { type, typeId, length } = vector;\n    // Fast case, defer to native iterators if possible\n    if (vector.stride === 1 && ((typeId === Type.Timestamp) ||\n        (typeId === Type.Int && type.bitWidth !== 64) ||\n        (typeId === Type.Time && type.bitWidth !== 64) ||\n        (typeId === Type.Float && type.precision > 0 /* Precision.HALF */))) {\n        return vector.values.subarray(0, length)[Symbol.iterator]();\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}\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/** @ignore */\nexport const instance = new IteratorVisitor();\n\n//# sourceMappingURL=iterator.mjs.map\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.\nimport { Type } from '../enum';\nimport { Visitor } from '../visitor';\nimport { instance as iteratorVisitor } from './iterator';\n/** @ignore */\nexport class ToArrayVisitor extends Visitor {\n}\n/** @ignore */\nfunction arrayOfVector(vector) {\n    const { type, length, stride } = vector;\n    // Fast case, return subarray if possible\n    switch (type.typeId) {\n        case Type.Int:\n        case Type.Float:\n        case Type.Decimal:\n        case Type.Time:\n        case Type.Timestamp:\n            return vector.values.subarray(0, length * stride);\n    }\n    // Otherwise if not primitive, slow copy\n    return [...iteratorVisitor.visit(vector)];\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/** @ignore */\nexport const instance = new ToArrayVisitor();\n\n//# sourceMappingURL=toarray.mjs.map\n","/* istanbul ignore file */\nimport { Visitor } from '../visitor';\nimport { TimeUnit } from '../enum';\n/** @ignore */ const sum = (x, y) => x + y;\n/** @ignore */ const variableWidthColumnErrorMessage = (type) => `Cannot compute the byte width of variable-width column ${type}`;\n/** @ignore */\nexport class ByteWidthVisitor extends Visitor {\n    visitNull(____) { return 0; }\n    visitInt(type) { return type.bitWidth / 8; }\n    visitFloat(type) { return type.ArrayType.BYTES_PER_ELEMENT; }\n    visitBinary(type) { throw new Error(variableWidthColumnErrorMessage(type)); }\n    visitUtf8(type) { throw new Error(variableWidthColumnErrorMessage(type)); }\n    visitBool(____) { return 1 / 8; }\n    visitDecimal(____) { return 16; }\n    visitDate(type) { return (type.unit + 1) * 4; }\n    visitTime(type) { return type.bitWidth / 8; }\n    visitTimestamp(type) { return type.unit === TimeUnit.SECOND ? 4 : 8; }\n    visitInterval(type) { return (type.unit + 1) * 4; }\n    visitList(type) { throw new Error(variableWidthColumnErrorMessage(type)); }\n    visitStruct(type) { return this.visitFields(type.children).reduce(sum, 0); }\n    visitUnion(type) { return this.visitFields(type.children).reduce(sum, 0); }\n    visitFixedSizeBinary(type) { return type.byteWidth; }\n    visitFixedSizeList(type) { return type.listSize * this.visitFields(type.children).reduce(sum, 0); }\n    visitMap(type) { return this.visitFields(type.children).reduce(sum, 0); }\n    visitDictionary(type) { return this.visit(type.indices); }\n    visitFields(fields) { return (fields || []).map((field) => this.visit(field.type)); }\n    visitSchema(schema) { return this.visitFields(schema.fields).reduce(sum, 0); }\n}\n/** @ignore */\nexport const instance = new ByteWidthVisitor();\n\n//# sourceMappingURL=bytewidth.mjs.map\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.\nimport { Visitor } from '../visitor';\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/** @ignore */\nexport class GetVectorConstructor extends Visitor {\n    visitNull() { return NullVector; }\n    visitBool() { return BoolVector; }\n    visitInt() { return IntVector; }\n    visitInt8() { return Int8Vector; }\n    visitInt16() { return Int16Vector; }\n    visitInt32() { return Int32Vector; }\n    visitInt64() { return Int64Vector; }\n    visitUint8() { return Uint8Vector; }\n    visitUint16() { return Uint16Vector; }\n    visitUint32() { return Uint32Vector; }\n    visitUint64() { return Uint64Vector; }\n    visitFloat() { return FloatVector; }\n    visitFloat16() { return Float16Vector; }\n    visitFloat32() { return Float32Vector; }\n    visitFloat64() { return Float64Vector; }\n    visitUtf8() { return Utf8Vector; }\n    visitBinary() { return BinaryVector; }\n    visitFixedSizeBinary() { return FixedSizeBinaryVector; }\n    visitDate() { return DateVector; }\n    visitDateDay() { return DateDayVector; }\n    visitDateMillisecond() { return DateMillisecondVector; }\n    visitTimestamp() { return TimestampVector; }\n    visitTimestampSecond() { return TimestampSecondVector; }\n    visitTimestampMillisecond() { return TimestampMillisecondVector; }\n    visitTimestampMicrosecond() { return TimestampMicrosecondVector; }\n    visitTimestampNanosecond() { return TimestampNanosecondVector; }\n    visitTime() { return TimeVector; }\n    visitTimeSecond() { return TimeSecondVector; }\n    visitTimeMillisecond() { return TimeMillisecondVector; }\n    visitTimeMicrosecond() { return TimeMicrosecondVector; }\n    visitTimeNanosecond() { return TimeNanosecondVector; }\n    visitDecimal() { return DecimalVector; }\n    visitList() { return ListVector; }\n    visitStruct() { return StructVector; }\n    visitUnion() { return UnionVector; }\n    visitDenseUnion() { return DenseUnionVector; }\n    visitSparseUnion() { return SparseUnionVector; }\n    visitDictionary() { return DictionaryVector; }\n    visitInterval() { return IntervalVector; }\n    visitIntervalDayTime() { return IntervalDayTimeVector; }\n    visitIntervalYearMonth() { return IntervalYearMonthVector; }\n    visitFixedSizeList() { return FixedSizeListVector; }\n    visitMap() { return MapVector; }\n}\n/** @ignore */\nexport const instance = new GetVectorConstructor();\n\n//# sourceMappingURL=vectorctor.mjs.map\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.\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';\nimport * as fn from '../util/fn';\nimport { Type } from '../enum';\nimport { Vector } from '../vector';\nimport { Chunked } from './chunked';\nimport { BaseVector } from './base';\nimport { setBool } from '../util/bit';\nimport { isIterable, isAsyncIterable } from '../util/compat';\nimport { Builder } from '../builder';\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/** @nocollapse */\nVector.new = newVector;\n/** @nocollapse */\nVector.from = vectorFrom;\n/** @ignore */\nfunction newVector(data, ...args) {\n    return new (getVectorConstructor.getVisitFn(data)())(data, ...args);\n}\n/** @ignore */\nexport function vectorFromValuesWithType(newDataType, input) {\n    if (isIterable(input)) {\n        return Vector.from({ 'nullValues': [null, undefined], type: newDataType(), 'values': input });\n    }\n    else if (isAsyncIterable(input)) {\n        return Vector.from({ 'nullValues': [null, undefined], type: newDataType(), 'values': input });\n    }\n    const { 'values': values = [], 'type': type = newDataType(), 'nullValues': nullValues = [null, undefined], } = { ...input };\n    return isIterable(values)\n        ? Vector.from({ nullValues, ...input, type })\n        : Vector.from({ nullValues, ...input, type });\n}\nfunction vectorFrom(input) {\n    const { 'values': values = [], ...options } = { 'nullValues': [null, undefined], ...input };\n    if (isIterable(values)) {\n        const chunks = [...Builder.throughIterable(options)(values)];\n        return chunks.length === 1 ? chunks[0] : Chunked.concat(chunks);\n    }\n    return (async (chunks) => {\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(chunks);\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//\nBaseVector.prototype.get = function baseVectorGet(index) {\n    return getVisitor.visit(this, index);\n};\nBaseVector.prototype.set = function baseVectorSet(index, value) {\n    return setVisitor.visit(this, index, value);\n};\nBaseVector.prototype.indexOf = function baseVectorIndexOf(value, fromIndex) {\n    return indexOfVisitor.visit(this, value, fromIndex);\n};\nBaseVector.prototype.toArray = function baseVectorToArray() {\n    return toArrayVisitor.visit(this);\n};\nBaseVector.prototype.getByteWidth = function baseVectorGetByteWidth() {\n    return byteWidthVisitor.visit(this.type);\n};\nBaseVector.prototype[Symbol.iterator] = function baseVectorSymbolIterator() {\n    return iteratorVisitor.visit(this);\n};\nBaseVector.prototype._bindDataAccessors = bindBaseVectorDataAccessors;\n// Perf: bind and assign the operator Visitor methods to each of the Vector subclasses for each Type\nObject.keys(Type)\n    .map((T) => Type[T])\n    .filter((T) => 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/** @ignore */\nfunction partialType0(visit) {\n    return function () { return visit(this.type); };\n}\n/** @ignore */\nfunction wrapNullableGet(fn) {\n    return function (i) { return this.isValid(i) ? fn.call(this, i) : null; };\n}\n/** @ignore */\nfunction wrapNullableSet(fn) {\n    return function (i, a) {\n        if (setBool(this.nullBitmap, this.offset + i, !(a === null || a === undefined))) {\n            fn.call(this, i, a);\n        }\n    };\n}\n/** @ignore */\nfunction bindBaseVectorDataAccessors() {\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\n//# sourceMappingURL=index.mjs.map\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.\nimport { Column } from './column';\nimport { Schema } from './schema';\nimport { RecordBatch, _InternalEmptyPlaceholderRecordBatch } from './recordbatch';\nimport { RecordBatchReader } from './ipc/reader';\nimport { Struct } from './type';\nimport { selectColumnArgs, selectArgs } from './util/args';\nimport { isPromise, isIterable, isAsyncIterable } from './util/compat';\nimport { RecordBatchFileWriter, RecordBatchStreamWriter } from './ipc/writer';\nimport { distributeColumnsIntoRecordBatches, distributeVectorsIntoRecordBatches } from './util/recordbatch';\nimport { Chunked, StructVector } from './vector/index';\nexport class Table extends Chunked {\n    constructor(...args) {\n        let schema = null;\n        if (args[0] instanceof Schema) {\n            schema = args.shift();\n        }\n        let chunks = selectArgs(RecordBatch, args);\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        chunks[0] || (chunks[0] = new _InternalEmptyPlaceholderRecordBatch(schema));\n        super(new Struct(schema.fields), chunks);\n        this._schema = schema;\n        this._chunks = chunks;\n    }\n    /** @nocollapse */\n    static empty(schema = new Schema([])) { return new Table(schema, []); }\n    /** @nocollapse */\n    static from(input) {\n        if (!input) {\n            return Table.empty();\n        }\n        if (typeof input === 'object') {\n            let table = isIterable(input['values']) ? tableFromIterable(input)\n                : isAsyncIterable(input['values']) ? tableFromAsyncIterable(input)\n                    : null;\n            if (table !== null) {\n                return table;\n            }\n        }\n        let reader = RecordBatchReader.from(input);\n        if (isPromise(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(reader.schema, [...reader]);\n        }\n        return (async (opening) => {\n            const reader = await opening;\n            const schema = reader.schema;\n            const batches = [];\n            if (schema) {\n                for await (let batch of reader) {\n                    batches.push(batch);\n                }\n                return new Table(schema, batches);\n            }\n            return Table.empty();\n        })(reader.open());\n    }\n    /** @nocollapse */\n    static async fromAsync(source) {\n        return await Table.from(source);\n    }\n    /** @nocollapse */\n    static fromStruct(vector) {\n        return Table.new(vector.data.childData, vector.type.children);\n    }\n    /** @nocollapse */\n    static new(...cols) {\n        return new Table(...distributeColumnsIntoRecordBatches(selectColumnArgs(cols)));\n    }\n    get schema() { return this._schema; }\n    get length() { return this._length; }\n    get chunks() { return this._chunks; }\n    get numCols() { return this._numChildren; }\n    clone(chunks = this._chunks) {\n        return new Table(this._schema, chunks);\n    }\n    getColumn(name) {\n        return this.getColumnAt(this.getColumnIndex(name));\n    }\n    getColumnAt(index) {\n        return this.getChildAt(index);\n    }\n    getColumnIndex(name) {\n        return this._schema.fields.findIndex((f) => f.name === name);\n    }\n    getChildAt(index) {\n        if (index < 0 || index >= this.numChildren) {\n            return null;\n        }\n        let field, child;\n        const fields = this._schema.fields;\n        const columns = this._children || (this._children = []);\n        if (child = columns[index]) {\n            return child;\n        }\n        if (field = fields[index]) {\n            const chunks = this._chunks\n                .map((chunk) => chunk.getChildAt(index))\n                .filter((vec) => vec != null);\n            if (chunks.length > 0) {\n                return (columns[index] = new Column(field, chunks));\n            }\n        }\n        return null;\n    }\n    // @ts-ignore\n    serialize(encoding = 'binary', stream = true) {\n        const Writer = !stream\n            ? RecordBatchFileWriter\n            : RecordBatchStreamWriter;\n        return Writer.writeAll(this).toUint8Array(true);\n    }\n    count() {\n        return this._length;\n    }\n    select(...columnNames) {\n        const nameToIndex = this._schema.fields.reduce((m, f, i) => m.set(f.name, i), new Map());\n        return this.selectAt(...columnNames.map((columnName) => nameToIndex.get(columnName)).filter((x) => x > -1));\n    }\n    selectAt(...columnIndices) {\n        const schema = this._schema.selectAt(...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    assign(other) {\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        }, [[], []]);\n        const schema = this._schema.assign(other.schema);\n        const columns = [\n            ...fields.map((_f, i, _fs, j = oldToNew[i]) => (j === undefined ? this.getColumnAt(i) : other.getColumnAt(j))),\n            ...indices.map((i) => other.getColumnAt(i))\n        ].filter(Boolean);\n        return new Table(...distributeVectorsIntoRecordBatches(schema, columns));\n    }\n}\nfunction tableFromIterable(input) {\n    const { type } = input;\n    if (type instanceof Struct) {\n        return Table.fromStruct(StructVector.from(input));\n    }\n    return null;\n}\nfunction tableFromAsyncIterable(input) {\n    const { type } = input;\n    if (type instanceof Struct) {\n        return StructVector.from(input).then((vector) => Table.fromStruct(vector));\n    }\n    return null;\n}\n\n//# sourceMappingURL=table.mjs.map\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.\nimport { Data } from './data';\nimport { Table } from './table';\nimport { Vector } from './vector';\nimport { Visitor } from './visitor';\nimport { Schema } from './schema';\nimport { isIterable } from './util/compat';\nimport { Chunked } from './vector/chunked';\nimport { selectFieldArgs } from './util/args';\nimport { DataType, Struct } from './type';\nimport { ensureSameLengthData } from './util/recordbatch';\nimport { StructVector } from './vector/index';\nexport class RecordBatch extends StructVector {\n    constructor(...args) {\n        let data;\n        let schema = args[0];\n        let children;\n        if (args[1] instanceof Data) {\n            [, data, children] = args;\n        }\n        else {\n            const fields = schema.fields;\n            const [, length, childData] = args;\n            data = Data.Struct(new Struct(fields), 0, length, 0, null, childData);\n        }\n        super(data, children);\n        this._schema = schema;\n    }\n    /** @nocollapse */\n    static from(options) {\n        if (isIterable(options['values'])) {\n            return Table.from(options);\n        }\n        return Table.from(options);\n    }\n    /** @nocollapse */\n    static new(...args) {\n        const [fs, xs] = selectFieldArgs(args);\n        const vs = xs.filter((x) => x instanceof Vector);\n        return new RecordBatch(...ensureSameLengthData(new Schema(fs), vs.map((x) => x.data)));\n    }\n    clone(data, children = this._children) {\n        return new RecordBatch(this._schema, data, children);\n    }\n    concat(...others) {\n        const schema = this._schema, chunks = Chunked.flatten(this, ...others);\n        return new Table(schema, chunks.map(({ data }) => new RecordBatch(schema, data)));\n    }\n    get schema() { return this._schema; }\n    get numCols() { return this._schema.fields.length; }\n    get dictionaries() {\n        return this._dictionaries || (this._dictionaries = DictionaryCollector.collect(this));\n    }\n    select(...columnNames) {\n        const nameToIndex = this._schema.fields.reduce((m, f, i) => m.set(f.name, i), new Map());\n        return this.selectAt(...columnNames.map((columnName) => nameToIndex.get(columnName)).filter((x) => x > -1));\n    }\n    selectAt(...columnIndices) {\n        const schema = this._schema.selectAt(...columnIndices);\n        const childData = columnIndices.map((i) => this.data.childData[i]).filter(Boolean);\n        return new RecordBatch(schema, this.length, childData);\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 extends RecordBatch {\n    constructor(schema) {\n        super(schema, 0, schema.fields.map((f) => Data.new(f.type, 0, 0, 0)));\n    }\n}\n/** @ignore */\nclass DictionaryCollector extends Visitor {\n    constructor() {\n        super(...arguments);\n        this.dictionaries = new Map();\n    }\n    static collect(batch) {\n        return new DictionaryCollector().visit(batch.data, new Struct(batch.schema.fields)).dictionaries;\n    }\n    visit(data, type) {\n        if (DataType.isDictionary(type)) {\n            return this.visitDictionary(data, type);\n        }\n        else {\n            data.childData.forEach((child, i) => this.visit(child, type.children[i].type));\n        }\n        return this;\n    }\n    visitDictionary(data, type) {\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\n//# sourceMappingURL=recordbatch.mjs.map\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.\nimport { Vector } from '../vector';\nimport { MessageHeader } from '../enum';\nimport { Footer } from './metadata/file';\nimport streamAdapters from '../io/adapters';\nimport { ByteStream, AsyncByteStream } from '../io/stream';\nimport { RandomAccessFile, AsyncRandomAccessFile } from '../io/file';\nimport { VectorLoader, JSONVectorLoader } from '../visitor/vectorloader';\nimport { RecordBatch, _InternalEmptyPlaceholderRecordBatch } from '../recordbatch';\nimport { ITERATOR_DONE, ReadableInterop, } from '../io/interfaces';\nimport { MessageReader, AsyncMessageReader, JSONMessageReader, checkForMagicArrowString, magicLength, magicAndPadding, magicX2AndPadding } from './message';\nimport { isPromise, isIterable, isAsyncIterable, isIteratorResult, isArrowJSON, isFileHandle, isFetchResponse, isReadableDOMStream, isReadableNodeStream } from '../util/compat';\nexport class RecordBatchReader extends ReadableInterop {\n    constructor(impl) {\n        super();\n        this._impl = impl;\n    }\n    get closed() { return this._impl.closed; }\n    get schema() { return this._impl.schema; }\n    get autoDestroy() { return this._impl.autoDestroy; }\n    get dictionaries() { return this._impl.dictionaries; }\n    get numDictionaries() { return this._impl.numDictionaries; }\n    get numRecordBatches() { return this._impl.numRecordBatches; }\n    get footer() { return this._impl.isFile() ? this._impl.footer : null; }\n    isSync() { return this._impl.isSync(); }\n    isAsync() { return this._impl.isAsync(); }\n    isFile() { return this._impl.isFile(); }\n    isStream() { return this._impl.isStream(); }\n    next() {\n        return this._impl.next();\n    }\n    throw(value) {\n        return this._impl.throw(value);\n    }\n    return(value) {\n        return this._impl.return(value);\n    }\n    cancel() {\n        return this._impl.cancel();\n    }\n    reset(schema) {\n        this._impl.reset(schema);\n        this._DOMStream = undefined;\n        this._nodeStream = undefined;\n        return this;\n    }\n    open(options) {\n        const opening = this._impl.open(options);\n        return isPromise(opening) ? opening.then(() => this) : this;\n    }\n    readRecordBatch(index) {\n        return this._impl.isFile() ? this._impl.readRecordBatch(index) : null;\n    }\n    [Symbol.iterator]() {\n        return this._impl[Symbol.iterator]();\n    }\n    [Symbol.asyncIterator]() {\n        return this._impl[Symbol.asyncIterator]();\n    }\n    toDOMStream() {\n        return streamAdapters.toDOMStream((this.isSync()\n            ? { [Symbol.iterator]: () => this }\n            : { [Symbol.asyncIterator]: () => this }));\n    }\n    toNodeStream() {\n        return streamAdapters.toNodeStream((this.isSync()\n            ? { [Symbol.iterator]: () => this }\n            : { [Symbol.asyncIterator]: () => this }), { objectMode: true });\n    }\n    /** @nocollapse */\n    // @ts-ignore\n    static throughNode(options) {\n        throw new Error(`\"throughNode\" not available in this environment`);\n    }\n    /** @nocollapse */\n    static throughDOM(\n    // @ts-ignore\n    writableStrategy, \n    // @ts-ignore\n    readableStrategy) {\n        throw new Error(`\"throughDOM\" not available in this environment`);\n    }\n    /** @nocollapse */\n    static from(source) {\n        if (source instanceof RecordBatchReader) {\n            return source;\n        }\n        else if (isArrowJSON(source)) {\n            return fromArrowJSON(source);\n        }\n        else if (isFileHandle(source)) {\n            return fromFileHandle(source);\n        }\n        else if (isPromise(source)) {\n            return (async () => await RecordBatchReader.from(await source))();\n        }\n        else if (isFetchResponse(source) || isReadableDOMStream(source) || isReadableNodeStream(source) || isAsyncIterable(source)) {\n            return fromAsyncByteStream(new AsyncByteStream(source));\n        }\n        return fromByteStream(new ByteStream(source));\n    }\n    /** @nocollapse */\n    static readAll(source) {\n        if (source instanceof RecordBatchReader) {\n            return source.isSync() ? readAllSync(source) : readAllAsync(source);\n        }\n        else if (isArrowJSON(source) || ArrayBuffer.isView(source) || isIterable(source) || isIteratorResult(source)) {\n            return readAllSync(source);\n        }\n        return readAllAsync(source);\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/** @ignore */\nexport class RecordBatchStreamReader extends RecordBatchReader {\n    constructor(_impl) {\n        super(_impl);\n        this._impl = _impl;\n    }\n    [Symbol.iterator]() { return this._impl[Symbol.iterator](); }\n    async *[Symbol.asyncIterator]() { yield* this[Symbol.iterator](); }\n}\n/** @ignore */\nexport class AsyncRecordBatchStreamReader extends RecordBatchReader {\n    constructor(_impl) {\n        super(_impl);\n        this._impl = _impl;\n    }\n    [Symbol.iterator]() { throw new Error(`AsyncRecordBatchStreamReader is not Iterable`); }\n    [Symbol.asyncIterator]() { return this._impl[Symbol.asyncIterator](); }\n}\n/** @ignore */\nexport class RecordBatchFileReader extends RecordBatchStreamReader {\n    constructor(_impl) {\n        super(_impl);\n        this._impl = _impl;\n    }\n}\n/** @ignore */\nexport class AsyncRecordBatchFileReader extends AsyncRecordBatchStreamReader {\n    constructor(_impl) {\n        super(_impl);\n        this._impl = _impl;\n    }\n}\n/** @ignore */\nclass RecordBatchReaderImpl {\n    constructor(dictionaries = new Map()) {\n        this.closed = false;\n        this.autoDestroy = true;\n        this._dictionaryIndex = 0;\n        this._recordBatchIndex = 0;\n        this.dictionaries = dictionaries;\n    }\n    get numDictionaries() { return this._dictionaryIndex; }\n    get numRecordBatches() { return this._recordBatchIndex; }\n    isSync() { return false; }\n    isAsync() { return false; }\n    isFile() { return false; }\n    isStream() { return false; }\n    reset(schema) {\n        this._dictionaryIndex = 0;\n        this._recordBatchIndex = 0;\n        this.schema = schema;\n        this.dictionaries = new Map();\n        return this;\n    }\n    _loadRecordBatch(header, body) {\n        return new RecordBatch(this.schema, header.length, this._loadVectors(header, body, this.schema.fields));\n    }\n    _loadDictionaryBatch(header, body) {\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(Vector.new(this._loadVectors(data, body, [type])[0])) :\n                Vector.new(this._loadVectors(data, body, [type])[0]));\n        }\n        return dictionary;\n    }\n    _loadVectors(header, body, types) {\n        return new VectorLoader(body, header.nodes, header.buffers, this.dictionaries).visitMany(types);\n    }\n}\n/** @ignore */\nclass RecordBatchStreamReaderImpl extends RecordBatchReaderImpl {\n    constructor(source, dictionaries) {\n        super(dictionaries);\n        this._reader = !isArrowJSON(source)\n            ? new MessageReader(this._handle = source)\n            : new JSONMessageReader(this._handle = source);\n    }\n    isSync() { return true; }\n    isStream() { return true; }\n    [Symbol.iterator]() {\n        return this;\n    }\n    cancel() {\n        if (!this.closed && (this.closed = true)) {\n            this.reset()._reader.return();\n            this._reader = null;\n            this.dictionaries = null;\n        }\n    }\n    open(options) {\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    throw(value) {\n        if (!this.closed && this.autoDestroy && (this.closed = true)) {\n            return this.reset()._reader.throw(value);\n        }\n        return ITERATOR_DONE;\n    }\n    return(value) {\n        if (!this.closed && this.autoDestroy && (this.closed = true)) {\n            return this.reset()._reader.return(value);\n        }\n        return ITERATOR_DONE;\n    }\n    next() {\n        if (this.closed) {\n            return ITERATOR_DONE;\n        }\n        let message, { _reader: reader } = this;\n        while (message = this._readNextMessageAndValidate()) {\n            if (message.isSchema()) {\n                this.reset(message.header());\n            }\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            }\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(this.schema) };\n        }\n        return this.return();\n    }\n    _readNextMessageAndValidate(type) {\n        return this._reader.readMessage(type);\n    }\n}\n/** @ignore */\nclass AsyncRecordBatchStreamReaderImpl extends RecordBatchReaderImpl {\n    constructor(source, dictionaries) {\n        super(dictionaries);\n        this._reader = new AsyncMessageReader(this._handle = source);\n    }\n    isAsync() { return true; }\n    isStream() { return true; }\n    [Symbol.asyncIterator]() {\n        return this;\n    }\n    async cancel() {\n        if (!this.closed && (this.closed = true)) {\n            await this.reset()._reader.return();\n            this._reader = null;\n            this.dictionaries = null;\n        }\n    }\n    async open(options) {\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    async throw(value) {\n        if (!this.closed && this.autoDestroy && (this.closed = true)) {\n            return await this.reset()._reader.throw(value);\n        }\n        return ITERATOR_DONE;\n    }\n    async return(value) {\n        if (!this.closed && this.autoDestroy && (this.closed = true)) {\n            return await this.reset()._reader.return(value);\n        }\n        return ITERATOR_DONE;\n    }\n    async next() {\n        if (this.closed) {\n            return ITERATOR_DONE;\n        }\n        let message, { _reader: reader } = this;\n        while (message = await this._readNextMessageAndValidate()) {\n            if (message.isSchema()) {\n                await this.reset(message.header());\n            }\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            }\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(this.schema) };\n        }\n        return await this.return();\n    }\n    async _readNextMessageAndValidate(type) {\n        return await this._reader.readMessage(type);\n    }\n}\n/** @ignore */\nclass RecordBatchFileReaderImpl extends RecordBatchStreamReaderImpl {\n    constructor(source, dictionaries) {\n        super(source instanceof RandomAccessFile ? source : new RandomAccessFile(source), dictionaries);\n    }\n    get footer() { return this._footer; }\n    get numDictionaries() { return this._footer ? this._footer.numDictionaries : 0; }\n    get numRecordBatches() { return this._footer ? this._footer.numRecordBatches : 0; }\n    isSync() { return true; }\n    isFile() { return true; }\n    open(options) {\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    readRecordBatch(index) {\n        if (this.closed) {\n            return null;\n        }\n        if (!this._footer) {\n            this.open();\n        }\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    _readDictionaryBatch(index) {\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    _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    _readNextMessageAndValidate(type) {\n        if (!this._footer) {\n            this.open();\n        }\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/** @ignore */\nclass AsyncRecordBatchFileReaderImpl extends AsyncRecordBatchStreamReaderImpl {\n    constructor(source, ...rest) {\n        const byteLength = typeof rest[0] !== 'number' ? rest.shift() : undefined;\n        const dictionaries = rest[0] instanceof Map ? rest.shift() : undefined;\n        super(source instanceof AsyncRandomAccessFile ? source : new AsyncRandomAccessFile(source, byteLength), dictionaries);\n    }\n    get footer() { return this._footer; }\n    get numDictionaries() { return this._footer ? this._footer.numDictionaries : 0; }\n    get numRecordBatches() { return this._footer ? this._footer.numRecordBatches : 0; }\n    isFile() { return true; }\n    isAsync() { return true; }\n    async open(options) {\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    async readRecordBatch(index) {\n        if (this.closed) {\n            return null;\n        }\n        if (!this._footer) {\n            await this.open();\n        }\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    async _readDictionaryBatch(index) {\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    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    async _readNextMessageAndValidate(type) {\n        if (!this._footer) {\n            await this.open();\n        }\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/** @ignore */\nclass RecordBatchJSONReaderImpl extends RecordBatchStreamReaderImpl {\n    constructor(source, dictionaries) {\n        super(source, dictionaries);\n    }\n    _loadVectors(header, body, types) {\n        return new JSONVectorLoader(body, header.nodes, header.buffers, this.dictionaries).visitMany(types);\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/** @ignore */\nfunction shouldAutoDestroy(self, options) {\n    return options && (typeof options['autoDestroy'] === 'boolean') ? options['autoDestroy'] : self['autoDestroy'];\n}\n/** @ignore */\nfunction* readAllSync(source) {\n    const reader = RecordBatchReader.from(source);\n    try {\n        if (!reader.open({ autoDestroy: false }).closed) {\n            do {\n                yield reader;\n            } while (!(reader.reset().open()).closed);\n        }\n    }\n    finally {\n        reader.cancel();\n    }\n}\n/** @ignore */\nasync function* readAllAsync(source) {\n    const reader = await RecordBatchReader.from(source);\n    try {\n        if (!(await reader.open({ autoDestroy: false })).closed) {\n            do {\n                yield reader;\n            } while (!(await reader.reset().open()).closed);\n        }\n    }\n    finally {\n        await reader.cancel();\n    }\n}\n/** @ignore */\nfunction fromArrowJSON(source) {\n    return new RecordBatchStreamReader(new RecordBatchJSONReaderImpl(source));\n}\n/** @ignore */\nfunction fromByteStream(source) {\n    const bytes = source.peek((magicLength + 7) & ~7);\n    return bytes && bytes.byteLength >= 4 ? !checkForMagicArrowString(bytes)\n        ? new RecordBatchStreamReader(new RecordBatchStreamReaderImpl(source))\n        : new RecordBatchFileReader(new RecordBatchFileReaderImpl(source.read()))\n        : new RecordBatchStreamReader(new RecordBatchStreamReaderImpl(function* () { }()));\n}\n/** @ignore */\nasync function fromAsyncByteStream(source) {\n    const bytes = await source.peek((magicLength + 7) & ~7);\n    return bytes && bytes.byteLength >= 4 ? !checkForMagicArrowString(bytes)\n        ? new AsyncRecordBatchStreamReader(new AsyncRecordBatchStreamReaderImpl(source))\n        : new RecordBatchFileReader(new RecordBatchFileReaderImpl(await source.read()))\n        : new AsyncRecordBatchStreamReader(new AsyncRecordBatchStreamReaderImpl(async function* () { }()));\n}\n/** @ignore */\nasync function fromFileHandle(source) {\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(file));\n        }\n    }\n    return new AsyncRecordBatchStreamReader(new AsyncRecordBatchStreamReaderImpl(file));\n}\n\n//# sourceMappingURL=reader.mjs.map\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.\nimport { toUint8Array } from '../../util/buffer';\nimport { isIterable, isAsyncIterable } from '../../util/compat';\n/** @ignore */\nexport function toDOMStream(source, options) {\n    if (isAsyncIterable(source)) {\n        return asyncIterableAsReadableDOMStream(source, options);\n    }\n    if (isIterable(source)) {\n        return iterableAsReadableDOMStream(source, options);\n    }\n    /* istanbul ignore next */\n    throw new Error(`toDOMStream() must be called with an Iterable or AsyncIterable`);\n}\n/** @ignore */\nfunction iterableAsReadableDOMStream(source, options) {\n    let it = null;\n    const bm = (options && options.type === 'bytes') || false;\n    const hwm = options && options.highWaterMark || (2 ** 24);\n    return new ReadableStream({\n        ...options,\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    function next(controller, it) {\n        let buf;\n        let r = 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 = buf;\n            }\n            controller.enqueue(r.value);\n            if (size != null && --size <= 0) {\n                return;\n            }\n        }\n        controller.close();\n    }\n}\n/** @ignore */\nfunction asyncIterableAsReadableDOMStream(source, options) {\n    let it = null;\n    const bm = (options && options.type === 'bytes') || false;\n    const hwm = options && options.highWaterMark || (2 ** 24);\n    return new ReadableStream({\n        ...options,\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    async function next(controller, it) {\n        let buf;\n        let r = 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 = buf;\n            }\n            controller.enqueue(r.value);\n            if (size != null && --size <= 0) {\n                return;\n            }\n        }\n        controller.close();\n    }\n}\n\n//# sourceMappingURL=iterable.mjs.map\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.\nimport { Builder } from '../../builder/index';\n/** @ignore */\nexport function builderThroughDOMStream(options) {\n    return new BuilderTransform(options);\n}\n/** @ignore */\nexport class BuilderTransform {\n    constructor(options) {\n        // Access properties by string indexers to defeat closure compiler\n        this._numChunks = 0;\n        this._finished = false;\n        this._bufferedSize = 0;\n        const { ['readableStrategy']: readableStrategy, ['writableStrategy']: writableStrategy, ['queueingStrategy']: queueingStrategy = 'count', ...builderOptions } = options;\n        this._controller = null;\n        this._builder = Builder.new(builderOptions);\n        this._getSize = queueingStrategy !== 'bytes' ? chunkLength : chunkByteLength;\n        const { ['highWaterMark']: readableHighWaterMark = queueingStrategy === 'bytes' ? 2 ** 14 : 1000 } = { ...readableStrategy };\n        const { ['highWaterMark']: writableHighWaterMark = queueingStrategy === 'bytes' ? 2 ** 14 : 1000 } = { ...writableStrategy };\n        this['readable'] = new ReadableStream({\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        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) => this._writeValueAndReturnChunkSize(value),\n        });\n    }\n    _writeValueAndReturnChunkSize(value) {\n        const bufferedSize = this._bufferedSize;\n        this._bufferedSize = this._getSize(this._builder.append(value));\n        return this._bufferedSize - bufferedSize;\n    }\n    _maybeFlush(builder, controller) {\n        if (controller === null) {\n            return;\n        }\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    _enqueue(controller, chunk) {\n        this._bufferedSize = 0;\n        this._controller = null;\n        chunk === null ? controller.close() : controller.enqueue(chunk);\n    }\n}\n/** @ignore */ const chunkLength = (chunk) => chunk.length;\n/** @ignore */ const chunkByteLength = (chunk) => chunk.byteLength;\n\n//# sourceMappingURL=builder.mjs.map\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.\nimport { AsyncByteQueue } from '../../io/stream';\nimport { RecordBatchReader } from '../../ipc/reader';\n/** @ignore */\nexport function recordBatchReaderThroughDOMStream(writableStrategy, readableStrategy) {\n    const queue = new AsyncByteQueue();\n    let reader = null;\n    const readable = new ReadableStream({\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    return { writable: new WritableStream(queue, { 'highWaterMark': 2 ** 14, ...writableStrategy }), readable };\n    async function open() {\n        return await (await RecordBatchReader.from(queue)).open(readableStrategy);\n    }\n    async function next(controller, reader) {\n        let size = controller.desiredSize;\n        let r = 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\n//# sourceMappingURL=reader.mjs.map\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.\nimport { AsyncByteStream } from '../../io/stream';\n/** @ignore */\nexport function recordBatchWriterThroughDOMStream(writableStrategy, readableStrategy) {\n    const writer = new this(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    return { writable: new WritableStream(writer, writableStrategy), readable };\n    async function next(controller) {\n        let buf = 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) {\n                return;\n            }\n        }\n        controller.close();\n    }\n}\n\n//# sourceMappingURL=writer.mjs.map\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.\nimport { DictionaryVector } from '../vector/dictionary';\n/** @ignore */\nexport class Value {\n    eq(other) {\n        if (!(other instanceof Value)) {\n            other = new Literal(other);\n        }\n        return new Equals(this, other);\n    }\n    le(other) {\n        if (!(other instanceof Value)) {\n            other = new Literal(other);\n        }\n        return new LTeq(this, other);\n    }\n    ge(other) {\n        if (!(other instanceof Value)) {\n            other = new Literal(other);\n        }\n        return new GTeq(this, other);\n    }\n    lt(other) {\n        return new Not(this.ge(other));\n    }\n    gt(other) {\n        return new Not(this.le(other));\n    }\n    ne(other) {\n        return new Not(this.eq(other));\n    }\n}\n/** @ignore */\nexport class Literal extends Value {\n    constructor(v) {\n        super();\n        this.v = v;\n    }\n}\n/** @ignore */\nexport class Col extends Value {\n    constructor(name) {\n        super();\n        this.name = name;\n    }\n    bind(batch) {\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) {\n                throw new Error(`Failed to bind Col \"${this.name}\"`);\n            }\n        }\n        const vec = this.vector = batch.getChildAt(this.colidx);\n        return (idx) => vec.get(idx);\n    }\n}\n/** @ignore */\nexport class Predicate {\n    and(...expr) { return new And(this, ...expr); }\n    or(...expr) { return new Or(this, ...expr); }\n    not() { return new Not(this); }\n}\n/** @ignore */\nexport class ComparisonPredicate extends Predicate {\n    constructor(left, right) {\n        super();\n        this.left = left;\n        this.right = right;\n    }\n    bind(batch) {\n        if (this.left instanceof Literal) {\n            if (this.right instanceof Literal) {\n                return this._bindLitLit(batch, this.left, this.right);\n            }\n            else { // right is a Col\n                return this._bindLitCol(batch, this.left, this.right);\n            }\n        }\n        else { // left is a Col\n            if (this.right instanceof Literal) {\n                return this._bindColLit(batch, this.left, this.right);\n            }\n            else { // right is a Col\n                return this._bindColCol(batch, this.left, this.right);\n            }\n        }\n    }\n}\n/** @ignore */\nexport class CombinationPredicate extends Predicate {\n    constructor(...children) {\n        super();\n        this.children = children;\n    }\n}\n// add children to prototype so it doesn't get mangled in es2015/umd\nCombinationPredicate.prototype.children = Object.freeze([]); // freeze for safety\n/** @ignore */\nexport class And extends CombinationPredicate {\n    constructor(...children) {\n        // Flatten any Ands\n        children = children.reduce((accum, p) => {\n            return accum.concat(p instanceof And ? p.children : p);\n        }, []);\n        super(...children);\n    }\n    bind(batch) {\n        const bound = this.children.map((p) => p.bind(batch));\n        return (idx, batch) => bound.every((p) => p(idx, batch));\n    }\n}\n/** @ignore */\nexport class Or extends CombinationPredicate {\n    constructor(...children) {\n        // Flatten any Ors\n        children = children.reduce((accum, p) => {\n            return accum.concat(p instanceof Or ? p.children : p);\n        }, []);\n        super(...children);\n    }\n    bind(batch) {\n        const bound = this.children.map((p) => p.bind(batch));\n        return (idx, batch) => bound.some((p) => p(idx, batch));\n    }\n}\n/** @ignore */\nexport class Equals extends ComparisonPredicate {\n    _bindLitLit(_batch, left, right) {\n        const rtrn = left.v == right.v;\n        return () => rtrn;\n    }\n    _bindColCol(batch, left, right) {\n        const left_func = left.bind(batch);\n        const right_func = right.bind(batch);\n        return (idx, batch) => left_func(idx, batch) == right_func(idx, batch);\n    }\n    _bindColLit(batch, col, lit) {\n        const col_func = col.bind(batch);\n        if (col.vector instanceof DictionaryVector) {\n            let key;\n            const vector = col.vector;\n            if (vector.dictionary !== this.lastDictionary) {\n                key = vector.reverseLookup(lit.v);\n                this.lastDictionary = vector.dictionary;\n                this.lastKey = key;\n            }\n            else {\n                key = this.lastKey;\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            }\n            else {\n                return (idx) => {\n                    return vector.getKey(idx) === key;\n                };\n            }\n        }\n        else {\n            return (idx, cols) => col_func(idx, cols) == lit.v;\n        }\n    }\n    _bindLitCol(batch, lit, col) {\n        // Equals is commutative\n        return this._bindColLit(batch, col, lit);\n    }\n}\n/** @ignore */\nexport class LTeq extends ComparisonPredicate {\n    _bindLitLit(_batch, left, right) {\n        const rtrn = left.v <= right.v;\n        return () => rtrn;\n    }\n    _bindColCol(batch, left, right) {\n        const left_func = left.bind(batch);\n        const right_func = right.bind(batch);\n        return (idx, cols) => left_func(idx, cols) <= right_func(idx, cols);\n    }\n    _bindColLit(batch, col, lit) {\n        const col_func = col.bind(batch);\n        return (idx, cols) => col_func(idx, cols) <= lit.v;\n    }\n    _bindLitCol(batch, lit, col) {\n        const col_func = col.bind(batch);\n        return (idx, cols) => lit.v <= col_func(idx, cols);\n    }\n}\n/** @ignore */\nexport class GTeq extends ComparisonPredicate {\n    _bindLitLit(_batch, left, right) {\n        const rtrn = left.v >= right.v;\n        return () => rtrn;\n    }\n    _bindColCol(batch, left, right) {\n        const left_func = left.bind(batch);\n        const right_func = right.bind(batch);\n        return (idx, cols) => left_func(idx, cols) >= right_func(idx, cols);\n    }\n    _bindColLit(batch, col, lit) {\n        const col_func = col.bind(batch);\n        return (idx, cols) => col_func(idx, cols) >= lit.v;\n    }\n    _bindLitCol(batch, lit, col) {\n        const col_func = col.bind(batch);\n        return (idx, cols) => lit.v >= col_func(idx, cols);\n    }\n}\n/** @ignore */\nexport class Not extends Predicate {\n    constructor(child) {\n        super();\n        this.child = child;\n    }\n    bind(batch) {\n        const func = this.child.bind(batch);\n        return (idx, batch) => !func(idx, batch);\n    }\n}\n/** @ignore */\nexport class CustomPredicate extends Predicate {\n    constructor(next, bind_) {\n        super();\n        this.next = next;\n        this.bind_ = bind_;\n    }\n    bind(batch) {\n        this.bind_(batch);\n        return this.next;\n    }\n}\nexport function lit(v) { return new Literal(v); }\nexport function col(n) { return new Col(n); }\nexport function and(...p) { return new And(...p); }\nexport function or(...p) { return new Or(...p); }\nexport function custom(next, bind) {\n    return new CustomPredicate(next, bind);\n}\n\n//# sourceMappingURL=predicate.mjs.map\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.\nimport { Table } from '../table';\nimport { IntVector } from '../vector/int';\nimport { Field, Schema } from '../schema';\nimport { Col } from './predicate';\nimport { RecordBatch } from '../recordbatch';\nimport { DataType } from '../type';\nTable.prototype.countBy = function (name) { return new DataFrame(this.chunks).countBy(name); };\nTable.prototype.scan = function (next, bind) { return new DataFrame(this.chunks).scan(next, bind); };\nTable.prototype.scanReverse = function (next, bind) { return new DataFrame(this.chunks).scanReverse(next, bind); };\nTable.prototype.filter = function (predicate) { return new DataFrame(this.chunks).filter(predicate); };\nexport class DataFrame extends Table {\n    filter(predicate) {\n        return new FilteredDataFrame(this.chunks, predicate);\n    }\n    scan(next, bind) {\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) {\n                bind(batch);\n            }\n            // yield all indices\n            for (let index = -1, numRows = batch.length; ++index < numRows;) {\n                next(index, batch);\n            }\n        }\n    }\n    scanReverse(next, bind) {\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) {\n                bind(batch);\n            }\n            // yield all indices\n            for (let index = batch.length; --index >= 0;) {\n                next(index, batch);\n            }\n        }\n    }\n    countBy(name) {\n        const batches = this.chunks, numBatches = batches.length;\n        const count_by = typeof name === 'string' ? new Col(name) : name;\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;\n        if (!DataType.isDictionary(vector.type)) {\n            throw new Error('countBy currently only supports dictionary-encoded columns');\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        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.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) {\n                    counts[key]++;\n                }\n            }\n        }\n        return new CountByResult(vector.dictionary, IntVector.from(counts));\n    }\n}\n/** @ignore */\nexport class CountByResult extends Table {\n    constructor(values, counts) {\n        const schema = new Schema([\n            new Field('values', values.type),\n            new Field('counts', counts.type)\n        ]);\n        super(new RecordBatch(schema, counts.length, [values, counts]));\n    }\n    toJSON() {\n        const values = this.getColumnAt(0);\n        const counts = this.getColumnAt(1);\n        const result = {};\n        for (let i = -1; ++i < this.length;) {\n            result[values.get(i)] = counts.get(i);\n        }\n        return result;\n    }\n}\n/** @ignore */\nexport class FilteredDataFrame extends DataFrame {\n    constructor(batches, predicate) {\n        super(batches);\n        this._predicate = predicate;\n    }\n    scan(next, bind) {\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    scanReverse(next, bind) {\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    count() {\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)) {\n                    ++sum;\n                }\n            }\n        }\n        return sum;\n    }\n    *[Symbol.iterator]() {\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)) {\n                    yield batch.get(index);\n                }\n            }\n        }\n    }\n    filter(predicate) {\n        return new FilteredDataFrame(this._chunks, this._predicate.and(predicate));\n    }\n    countBy(name) {\n        const batches = this._chunks, numBatches = batches.length;\n        const count_by = typeof name === 'string' ? new Col(name) : name;\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;\n        if (!DataType.isDictionary(vector.type)) {\n            throw new Error('countBy currently only supports dictionary-encoded columns');\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        const counts = new CountsArrayType(vector.dictionary.length);\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.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)) {\n                    counts[key]++;\n                }\n            }\n        }\n        return new CountByResult(vector.dictionary, IntVector.from(counts));\n    }\n}\n\n//# sourceMappingURL=dataframe.mjs.map\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.\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';\nstreamAdapters.toDOMStream = toDOMStream;\nBuilder['throughDOM'] = builderThroughDOMStream;\nRecordBatchReader['throughDOM'] = recordBatchReaderThroughDOMStream;\nRecordBatchWriter['throughDOM'] = recordBatchWriterThroughDOMStream;\nexport { ArrowType, DateUnit, IntervalUnit, MessageHeader, MetadataVersion, Precision, TimeUnit, Type, UnionMode, BufferType, Data, DataType, Null, Bool, Int, Int8, Int16, Int32, Int64, Uint8, Uint16, Uint32, Uint64, Float, Float16, Float32, Float64, Utf8, Binary, FixedSizeBinary, Date_, DateDay, DateMillisecond, Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond, Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond, Decimal, List, Struct, Union, DenseUnion, SparseUnion, Dictionary, Interval, IntervalDayTime, IntervalYearMonth, FixedSizeList, Map_, Table, Column, Schema, Field, Visitor, Vector, BaseVector, BinaryVector, BoolVector, Chunked, DateVector, DateDayVector, DateMillisecondVector, DecimalVector, DictionaryVector, FixedSizeBinaryVector, FixedSizeListVector, FloatVector, Float16Vector, Float32Vector, Float64Vector, IntervalVector, IntervalDayTimeVector, IntervalYearMonthVector, IntVector, Int8Vector, Int16Vector, Int32Vector, Int64Vector, Uint8Vector, Uint16Vector, Uint32Vector, Uint64Vector, ListVector, MapVector, NullVector, StructVector, TimestampVector, TimestampSecondVector, TimestampMillisecondVector, TimestampMicrosecondVector, TimestampNanosecondVector, TimeVector, TimeSecondVector, TimeMillisecondVector, TimeMicrosecondVector, TimeNanosecondVector, UnionVector, DenseUnionVector, SparseUnionVector, Utf8Vector, ByteStream, AsyncByteStream, AsyncByteQueue, RecordBatchReader, RecordBatchFileReader, RecordBatchStreamReader, AsyncRecordBatchFileReader, AsyncRecordBatchStreamReader, RecordBatchWriter, RecordBatchFileWriter, RecordBatchStreamWriter, RecordBatchJSONWriter, MessageReader, AsyncMessageReader, JSONMessageReader, Message, RecordBatch, DataFrame, FilteredDataFrame, CountByResult, predicate, util, Builder, BinaryBuilder, BoolBuilder, DateBuilder, DateDayBuilder, DateMillisecondBuilder, DecimalBuilder, DictionaryBuilder, FixedSizeBinaryBuilder, FixedSizeListBuilder, FloatBuilder, Float16Builder, Float32Builder, Float64Builder, IntervalBuilder, IntervalDayTimeBuilder, IntervalYearMonthBuilder, IntBuilder, Int8Builder, Int16Builder, Int32Builder, Int64Builder, Uint8Builder, Uint16Builder, Uint32Builder, Uint64Builder, ListBuilder, MapBuilder, NullBuilder, StructBuilder, TimestampBuilder, TimestampSecondBuilder, TimestampMillisecondBuilder, TimestampMicrosecondBuilder, TimestampNanosecondBuilder, TimeBuilder, TimeSecondBuilder, TimeMillisecondBuilder, TimeMicrosecondBuilder, TimeNanosecondBuilder, UnionBuilder, DenseUnionBuilder, SparseUnionBuilder, Utf8Builder, } from './Arrow';\n\n//# sourceMappingURL=Arrow.dom.mjs.map\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';\nvar nativePropertyIsEnumerable = {}.propertyIsEnumerable;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.github.io/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n  var descriptor = getOwnPropertyDescriptor(this, V);\n  return !!descriptor && descriptor.enumerable;\n} : nativePropertyIsEnumerable;\n","var anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.github.io/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n/* eslint-disable no-proto */\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n  var CORRECT_SETTER = false;\n  var test = {};\n  var setter;\n  try {\n    setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set;\n    setter.call(test, []);\n    CORRECT_SETTER = test instanceof Array;\n  } catch (error) { /* empty */ }\n  return function setPrototypeOf(O, proto) {\n    anObject(O);\n    aPossiblePrototype(proto);\n    if (CORRECT_SETTER) setter.call(O, proto);\n    else O.__proto__ = proto;\n    return O;\n  };\n}() : undefined);\n","var defineProperty = require('../internals/object-define-property').f;\nvar has = require('../internals/has');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (it, TAG, STATIC) {\n  if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {\n    defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG });\n  }\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","var check = function (it) {\n  return it && it.Math == Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n  // eslint-disable-next-line no-undef\n  check(typeof globalThis == 'object' && globalThis) ||\n  check(typeof window == 'object' && window) ||\n  check(typeof self == 'object' && self) ||\n  check(typeof global == 'object' && global) ||\n  // eslint-disable-next-line no-new-func\n  Function('return this')();\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.github.io/ecma262/#sec-object.keys\nmodule.exports = Object.keys || function keys(O) {\n  return internalObjectKeys(O, enumBugKeys);\n};\n","var has = require('../internals/has');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar ObjectPrototype = Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.github.io/ecma262/#sec-object.getprototypeof\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {\n  O = toObject(O);\n  if (has(O, IE_PROTO)) return O[IE_PROTO];\n  if (typeof O.constructor == 'function' && O instanceof O.constructor) {\n    return O.constructor.prototype;\n  } return O instanceof Object ? ObjectPrototype : null;\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  function F() { /* empty */ }\n  F.prototype.constructor = null;\n  return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar Iterators = require('../internals/iterators');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar ARRAY_ITERATOR = 'Array Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);\n\n// `Array.prototype.entries` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.github.io/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.github.io/ecma262/#sec-createarrayiterator\nmodule.exports = defineIterator(Array, 'Array', function (iterated, kind) {\n  setInternalState(this, {\n    type: ARRAY_ITERATOR,\n    target: toIndexedObject(iterated), // target\n    index: 0,                          // next index\n    kind: kind                         // kind\n  });\n// `%ArrayIteratorPrototype%.next` method\n// https://tc39.github.io/ecma262/#sec-%arrayiteratorprototype%.next\n}, function () {\n  var state = getInternalState(this);\n  var target = state.target;\n  var kind = state.kind;\n  var index = state.index++;\n  if (!target || index >= target.length) {\n    state.target = undefined;\n    return { value: undefined, done: true };\n  }\n  if (kind == 'keys') return { value: index, done: false };\n  if (kind == 'values') return { value: target[index], done: false };\n  return { value: [index, target[index]], done: false };\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values%\n// https://tc39.github.io/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.github.io/ecma262/#sec-createmappedargumentsobject\nIterators.Arguments = Iterators.Array;\n\n// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n","var redefine = require('../internals/redefine');\n\nmodule.exports = function (target, src, options) {\n  for (var key in src) redefine(target, key, src[key], options);\n  return target;\n};\n","module.exports = function (exec) {\n  try {\n    return { error: false, value: exec() };\n  } catch (error) {\n    return { error: true, value: error };\n  }\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar global = require('../internals/global');\nvar getBuiltIn = require('../internals/get-built-in');\nvar NativePromise = require('../internals/native-promise-constructor');\nvar redefine = require('../internals/redefine');\nvar redefineAll = require('../internals/redefine-all');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar setSpecies = require('../internals/set-species');\nvar isObject = require('../internals/is-object');\nvar aFunction = require('../internals/a-function');\nvar anInstance = require('../internals/an-instance');\nvar classof = require('../internals/classof-raw');\nvar inspectSource = require('../internals/inspect-source');\nvar iterate = require('../internals/iterate');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar speciesConstructor = require('../internals/species-constructor');\nvar task = require('../internals/task').set;\nvar microtask = require('../internals/microtask');\nvar promiseResolve = require('../internals/promise-resolve');\nvar hostReportErrors = require('../internals/host-report-errors');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar InternalStateModule = require('../internals/internal-state');\nvar isForced = require('../internals/is-forced');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar SPECIES = wellKnownSymbol('species');\nvar PROMISE = 'Promise';\nvar getInternalState = InternalStateModule.get;\nvar setInternalState = InternalStateModule.set;\nvar getInternalPromiseState = InternalStateModule.getterFor(PROMISE);\nvar PromiseConstructor = NativePromise;\nvar TypeError = global.TypeError;\nvar document = global.document;\nvar process = global.process;\nvar $fetch = getBuiltIn('fetch');\nvar newPromiseCapability = newPromiseCapabilityModule.f;\nvar newGenericPromiseCapability = newPromiseCapability;\nvar IS_NODE = classof(process) == 'process';\nvar DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);\nvar UNHANDLED_REJECTION = 'unhandledrejection';\nvar REJECTION_HANDLED = 'rejectionhandled';\nvar PENDING = 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\nvar HANDLED = 1;\nvar UNHANDLED = 2;\nvar Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;\n\nvar FORCED = isForced(PROMISE, function () {\n  var GLOBAL_CORE_JS_PROMISE = inspectSource(PromiseConstructor) !== String(PromiseConstructor);\n  if (!GLOBAL_CORE_JS_PROMISE) {\n    // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n    // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n    // We can't detect it synchronously, so just check versions\n    if (V8_VERSION === 66) return true;\n    // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n    if (!IS_NODE && typeof PromiseRejectionEvent != 'function') return true;\n  }\n  // We need Promise#finally in the pure version for preventing prototype pollution\n  if (IS_PURE && !PromiseConstructor.prototype['finally']) return true;\n  // We can't use @@species feature detection in V8 since it causes\n  // deoptimization and performance degradation\n  // https://github.com/zloirock/core-js/issues/679\n  if (V8_VERSION >= 51 && /native code/.test(PromiseConstructor)) return false;\n  // Detect correctness of subclassing with @@species support\n  var promise = PromiseConstructor.resolve(1);\n  var FakePromise = function (exec) {\n    exec(function () { /* empty */ }, function () { /* empty */ });\n  };\n  var constructor = promise.constructor = {};\n  constructor[SPECIES] = FakePromise;\n  return !(promise.then(function () { /* empty */ }) instanceof FakePromise);\n});\n\nvar INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {\n  PromiseConstructor.all(iterable)['catch'](function () { /* empty */ });\n});\n\n// helpers\nvar isThenable = function (it) {\n  var then;\n  return isObject(it) && typeof (then = it.then) == 'function' ? then : false;\n};\n\nvar notify = function (promise, state, isReject) {\n  if (state.notified) return;\n  state.notified = true;\n  var chain = state.reactions;\n  microtask(function () {\n    var value = state.value;\n    var ok = state.state == FULFILLED;\n    var index = 0;\n    // variable length - can't use forEach\n    while (chain.length > index) {\n      var reaction = chain[index++];\n      var handler = ok ? reaction.ok : reaction.fail;\n      var resolve = reaction.resolve;\n      var reject = reaction.reject;\n      var domain = reaction.domain;\n      var result, then, exited;\n      try {\n        if (handler) {\n          if (!ok) {\n            if (state.rejection === UNHANDLED) onHandleUnhandled(promise, state);\n            state.rejection = HANDLED;\n          }\n          if (handler === true) result = value;\n          else {\n            if (domain) domain.enter();\n            result = handler(value); // can throw\n            if (domain) {\n              domain.exit();\n              exited = true;\n            }\n          }\n          if (result === reaction.promise) {\n            reject(TypeError('Promise-chain cycle'));\n          } else if (then = isThenable(result)) {\n            then.call(result, resolve, reject);\n          } else resolve(result);\n        } else reject(value);\n      } catch (error) {\n        if (domain && !exited) domain.exit();\n        reject(error);\n      }\n    }\n    state.reactions = [];\n    state.notified = false;\n    if (isReject && !state.rejection) onUnhandled(promise, state);\n  });\n};\n\nvar dispatchEvent = function (name, promise, reason) {\n  var event, handler;\n  if (DISPATCH_EVENT) {\n    event = document.createEvent('Event');\n    event.promise = promise;\n    event.reason = reason;\n    event.initEvent(name, false, true);\n    global.dispatchEvent(event);\n  } else event = { promise: promise, reason: reason };\n  if (handler = global['on' + name]) handler(event);\n  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);\n};\n\nvar onUnhandled = function (promise, state) {\n  task.call(global, function () {\n    var value = state.value;\n    var IS_UNHANDLED = isUnhandled(state);\n    var result;\n    if (IS_UNHANDLED) {\n      result = perform(function () {\n        if (IS_NODE) {\n          process.emit('unhandledRejection', value, promise);\n        } else dispatchEvent(UNHANDLED_REJECTION, promise, value);\n      });\n      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n      state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;\n      if (result.error) throw result.value;\n    }\n  });\n};\n\nvar isUnhandled = function (state) {\n  return state.rejection !== HANDLED && !state.parent;\n};\n\nvar onHandleUnhandled = function (promise, state) {\n  task.call(global, function () {\n    if (IS_NODE) {\n      process.emit('rejectionHandled', promise);\n    } else dispatchEvent(REJECTION_HANDLED, promise, state.value);\n  });\n};\n\nvar bind = function (fn, promise, state, unwrap) {\n  return function (value) {\n    fn(promise, state, value, unwrap);\n  };\n};\n\nvar internalReject = function (promise, state, value, unwrap) {\n  if (state.done) return;\n  state.done = true;\n  if (unwrap) state = unwrap;\n  state.value = value;\n  state.state = REJECTED;\n  notify(promise, state, true);\n};\n\nvar internalResolve = function (promise, state, value, unwrap) {\n  if (state.done) return;\n  state.done = true;\n  if (unwrap) state = unwrap;\n  try {\n    if (promise === value) throw TypeError(\"Promise can't be resolved itself\");\n    var then = isThenable(value);\n    if (then) {\n      microtask(function () {\n        var wrapper = { done: false };\n        try {\n          then.call(value,\n            bind(internalResolve, promise, wrapper, state),\n            bind(internalReject, promise, wrapper, state)\n          );\n        } catch (error) {\n          internalReject(promise, wrapper, error, state);\n        }\n      });\n    } else {\n      state.value = value;\n      state.state = FULFILLED;\n      notify(promise, state, false);\n    }\n  } catch (error) {\n    internalReject(promise, { done: false }, error, state);\n  }\n};\n\n// constructor polyfill\nif (FORCED) {\n  // 25.4.3.1 Promise(executor)\n  PromiseConstructor = function Promise(executor) {\n    anInstance(this, PromiseConstructor, PROMISE);\n    aFunction(executor);\n    Internal.call(this);\n    var state = getInternalState(this);\n    try {\n      executor(bind(internalResolve, this, state), bind(internalReject, this, state));\n    } catch (error) {\n      internalReject(this, state, error);\n    }\n  };\n  // eslint-disable-next-line no-unused-vars\n  Internal = function Promise(executor) {\n    setInternalState(this, {\n      type: PROMISE,\n      done: false,\n      notified: false,\n      parent: false,\n      reactions: [],\n      rejection: false,\n      state: PENDING,\n      value: undefined\n    });\n  };\n  Internal.prototype = redefineAll(PromiseConstructor.prototype, {\n    // `Promise.prototype.then` method\n    // https://tc39.github.io/ecma262/#sec-promise.prototype.then\n    then: function then(onFulfilled, onRejected) {\n      var state = getInternalPromiseState(this);\n      var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));\n      reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;\n      reaction.fail = typeof onRejected == 'function' && onRejected;\n      reaction.domain = IS_NODE ? process.domain : undefined;\n      state.parent = true;\n      state.reactions.push(reaction);\n      if (state.state != PENDING) notify(this, state, false);\n      return reaction.promise;\n    },\n    // `Promise.prototype.catch` method\n    // https://tc39.github.io/ecma262/#sec-promise.prototype.catch\n    'catch': function (onRejected) {\n      return this.then(undefined, onRejected);\n    }\n  });\n  OwnPromiseCapability = function () {\n    var promise = new Internal();\n    var state = getInternalState(promise);\n    this.promise = promise;\n    this.resolve = bind(internalResolve, promise, state);\n    this.reject = bind(internalReject, promise, state);\n  };\n  newPromiseCapabilityModule.f = newPromiseCapability = function (C) {\n    return C === PromiseConstructor || C === PromiseWrapper\n      ? new OwnPromiseCapability(C)\n      : newGenericPromiseCapability(C);\n  };\n\n  if (!IS_PURE && typeof NativePromise == 'function') {\n    nativeThen = NativePromise.prototype.then;\n\n    // wrap native Promise#then for native async functions\n    redefine(NativePromise.prototype, 'then', function then(onFulfilled, onRejected) {\n      var that = this;\n      return new PromiseConstructor(function (resolve, reject) {\n        nativeThen.call(that, resolve, reject);\n      }).then(onFulfilled, onRejected);\n    // https://github.com/zloirock/core-js/issues/640\n    }, { unsafe: true });\n\n    // wrap fetch result\n    if (typeof $fetch == 'function') $({ global: true, enumerable: true, forced: true }, {\n      // eslint-disable-next-line no-unused-vars\n      fetch: function fetch(input /* , init */) {\n        return promiseResolve(PromiseConstructor, $fetch.apply(global, arguments));\n      }\n    });\n  }\n}\n\n$({ global: true, wrap: true, forced: FORCED }, {\n  Promise: PromiseConstructor\n});\n\nsetToStringTag(PromiseConstructor, PROMISE, false, true);\nsetSpecies(PROMISE);\n\nPromiseWrapper = getBuiltIn(PROMISE);\n\n// statics\n$({ target: PROMISE, stat: true, forced: FORCED }, {\n  // `Promise.reject` method\n  // https://tc39.github.io/ecma262/#sec-promise.reject\n  reject: function reject(r) {\n    var capability = newPromiseCapability(this);\n    capability.reject.call(undefined, r);\n    return capability.promise;\n  }\n});\n\n$({ target: PROMISE, stat: true, forced: IS_PURE || FORCED }, {\n  // `Promise.resolve` method\n  // https://tc39.github.io/ecma262/#sec-promise.resolve\n  resolve: function resolve(x) {\n    return promiseResolve(IS_PURE && this === PromiseWrapper ? PromiseConstructor : this, x);\n  }\n});\n\n$({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {\n  // `Promise.all` method\n  // https://tc39.github.io/ecma262/#sec-promise.all\n  all: function all(iterable) {\n    var C = this;\n    var capability = newPromiseCapability(C);\n    var resolve = capability.resolve;\n    var reject = capability.reject;\n    var result = perform(function () {\n      var $promiseResolve = aFunction(C.resolve);\n      var values = [];\n      var counter = 0;\n      var remaining = 1;\n      iterate(iterable, function (promise) {\n        var index = counter++;\n        var alreadyCalled = false;\n        values.push(undefined);\n        remaining++;\n        $promiseResolve.call(C, promise).then(function (value) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = value;\n          --remaining || resolve(values);\n        }, reject);\n      });\n      --remaining || resolve(values);\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  },\n  // `Promise.race` method\n  // https://tc39.github.io/ecma262/#sec-promise.race\n  race: function race(iterable) {\n    var C = this;\n    var capability = newPromiseCapability(C);\n    var reject = capability.reject;\n    var result = perform(function () {\n      var $promiseResolve = aFunction(C.resolve);\n      iterate(iterable, function (promise) {\n        $promiseResolve.call(C, promise).then(capability.resolve, reject);\n      });\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  }\n});\n","var has = require('../internals/has');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source) {\n  var keys = ownKeys(source);\n  var defineProperty = definePropertyModule.f;\n  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n  for (var i = 0; i < keys.length; i++) {\n    var key = keys[i];\n    if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n  }\n};\n","var classof = require('../internals/classof-raw');\n\n// `IsArray` abstract operation\n// https://tc39.github.io/ecma262/#sec-isarray\nmodule.exports = Array.isArray || function isArray(arg) {\n  return classof(arg) == 'Array';\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayPrototype = Array.prototype;\n\n// check on default Array iterator\nmodule.exports = function (it) {\n  return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);\n};\n","'use strict';\nvar aFunction = require('../internals/a-function');\n\nvar PromiseCapability = function (C) {\n  var resolve, reject;\n  this.promise = new C(function ($$resolve, $$reject) {\n    if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');\n    resolve = $$resolve;\n    reject = $$reject;\n  });\n  this.resolve = aFunction(resolve);\n  this.reject = aFunction(reject);\n};\n\n// 25.4.1.5 NewPromiseCapability(C)\nmodule.exports.f = function (C) {\n  return new PromiseCapability(C);\n};\n","var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n  try {\n    return it[key];\n  } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n  var O, tag, result;\n  return it === undefined ? 'Undefined' : it === null ? 'Null'\n    // @@toStringTag case\n    : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag\n    // builtinTag case\n    : CORRECT_ARGUMENTS ? classofRaw(O)\n    // ES3 arguments fallback\n    : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result;\n};\n","var shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n  return keys[key] || (keys[key] = uid(key));\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar isObject = require('../internals/is-object');\nvar isArray = require('../internals/is-array');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar toLength = require('../internals/to-length');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar createProperty = require('../internals/create-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\nvar arrayMethodUsesToLength = require('../internals/array-method-uses-to-length');\n\nvar HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('slice');\nvar USES_TO_LENGTH = arrayMethodUsesToLength('slice', { ACCESSORS: true, 0: 0, 1: 2 });\n\nvar SPECIES = wellKnownSymbol('species');\nvar nativeSlice = [].slice;\nvar max = Math.max;\n\n// `Array.prototype.slice` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.slice\n// fallback for not array-like ES3 strings and DOM objects\n$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT || !USES_TO_LENGTH }, {\n  slice: function slice(start, end) {\n    var O = toIndexedObject(this);\n    var length = toLength(O.length);\n    var k = toAbsoluteIndex(start, length);\n    var fin = toAbsoluteIndex(end === undefined ? length : end, length);\n    // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible\n    var Constructor, result, n;\n    if (isArray(O)) {\n      Constructor = O.constructor;\n      // cross-realm fallback\n      if (typeof Constructor == 'function' && (Constructor === Array || isArray(Constructor.prototype))) {\n        Constructor = undefined;\n      } else if (isObject(Constructor)) {\n        Constructor = Constructor[SPECIES];\n        if (Constructor === null) Constructor = undefined;\n      }\n      if (Constructor === Array || Constructor === undefined) {\n        return nativeSlice.call(O, k, fin);\n      }\n    }\n    result = new (Constructor === undefined ? Array : Constructor)(max(fin - k, 0));\n    for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]);\n    result.length = n;\n    return result;\n  }\n});\n","// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n  return IndexedObject(requireObjectCoercible(it));\n};\n","var NATIVE_SYMBOL = require('../internals/native-symbol');\n\nmodule.exports = NATIVE_SYMBOL\n  // eslint-disable-next-line no-undef\n  && !Symbol.sham\n  // eslint-disable-next-line no-undef\n  && typeof Symbol.iterator == 'symbol';\n","var global = require('../internals/global');\n\nmodule.exports = global.Promise;\n"],"sourceRoot":""}