{"version":3,"mappings":"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","names":["e","t","n","r","o","a","i","l","s","d","c","u","f","g","h","p","m","y","w","b","v","x","E","S","A","C","D","N","M","B","R","$","X","Y","q","H","P","T","k","L","z","I","U","W","j","F","G","oe","J","K","O","Q","V","Z","_","ee","te","ae","re","ne","ie","se","le","de","_a","_b","last","array","wrapArray","startIndex","index","sleep","ms","resolve","isDom","getPlatform","agent","pt","isTouchDevice","isMac","isApple","isIos","LOCK_CLASSNAME","assignStyle","el","style","previousStyle","setCSSProperty","property","value","previousValue","getPaddingProperty","documentElement","documentLeft","removeScroll","_document","doc","win","body","noop","scrollbarWidth","setScrollbarWidthProperty","paddingProperty","scrollbarSidePadding","setStyle","setIOSStyle","scrollX","scrollY","visualViewport","offsetLeft","offsetTop","restoreStyle","cleanups","fn","handleFocus","args","prop","defaultEl","tick","returned","isFunction","isHTMLElement","candidateSelectors","candidateSelector","NoElement","matches","getRootNode","element","_element$getRootNode","_isInert","node","lookUp","_node$getAttribute","inertAtt","inert","result","isContentEditable","_node$getAttribute2","attValue","getCandidates","includeContainer","filter","candidates","_getCandidatesIteratively","elements","options","elementsToCheck","assigned","content","nestedCandidates","validCandidate","shadowRoot","validShadowRoot","_nestedCandidates","hasTabIndex","getTabIndex","getSortOrderTabIndex","isScope","tabIndex","sortOrderedTabbables","isInput","isHiddenInput","isDetailsWithSummary","child","getCheckedRadio","nodes","form","isTabbableRadio","radioScope","queryRadios","name","radioSet","err","checked","isRadio","isNonTabbableRadio","isNodeAttached","_nodeRoot","nodeRoot","nodeRootHost","attached","_nodeRootHost","_nodeRootHost$ownerDo","_node$ownerDocument","_nodeRoot2","_nodeRootHost2","_nodeRootHost2$ownerD","isZeroArea","_node$getBoundingClie","width","height","isHidden","_ref","displayCheck","getShadowRoot","visible","isDirectSummary","nodeUnderDetails","originalNode","parentElement","rootNode","isDisabledFromFieldset","parentNode","isNodeMatchingSelectorFocusable","isNodeMatchingSelectorTabbable","isShadowRootTabbable","shadowHostNode","_sortByOrder","regularTabbables","orderedTabbables","item","candidateTabindex","acc","sortable","tabbable","container","focusable","isTabbable","focusableCandidateSelector","isFocusable","_arrayLikeToArray","_arrayWithoutHoles","_defineProperty","_toPropertyKey","_iterableToArray","_nonIterableSpread","ownKeys","_objectSpread2","_toConsumableArray","_unsupportedIterableToArray","_toPrimitive","activeFocusTraps","trapStack","trap","activeTrap","trapIndex","isSelectableInput","isEscapeEvent","isTabEvent","isKeyForward","isKeyBackward","delay","valueOrHandler","_len","params","_key","getActualTarget","event","internalTrapStack","createFocusTrap","userOptions","config","state","getOption","configOverrideOptions","optionName","configOptionName","findContainerIndex","composedPath","tabbableNodes","getNodeForOption","_ref2","_ref2$hasFallback","hasFallback","_ref2$params","optionValue","getInitialFocusNode","firstTabbableGroup","firstTabbableNode","updateTabbableNodes","focusableNodes","lastTabbableNode","firstDomTabbableNode","lastDomTabbableNode","posTabIndexesFound","forward","nodeIdx","group","_getActiveElement","activeElement","_tryFocus","getReturnFocusNode","previousActiveElement","findNextNavNode","_ref3","target","_ref3$isBackward","isBackward","destinationNode","containerIndex","containerGroup","startOfGroupIndex","_ref4","destinationGroupIndex","destinationGroup","lastOfGroupIndex","_ref5","_destinationGroupIndex","_destinationGroup","checkPointerDown","checkFocusIn","targetContained","nextNode","navAcrossContainers","mruContainerIdx","mruTabIdx","checkKeyNav","checkTabKey","checkEscapeKey","checkClick","addListeners","removeListeners","checkDomRemoval","mutations","isFocusedNodeRemoved","mutation","removedNodes","mutationObserver","updateObservedNodes","activateOptions","onActivate","onPostActivate","checkCanFocusTrap","finishActivation","deactivateOptions","onDeactivate","onPostDeactivate","checkCanReturnFocus","returnFocus","finishDeactivation","pauseOptions","unpauseOptions","containerElements","elementsAsArray","paused","onPause","onPostPause","onUnpause","onPostUnpause","immediate","focusTrapOptions","hasFocus","writable","isPaused","activate","opts","deactivate","pause","unpause","_createFocusTrap","readonly","visibleModals","useModal","unsubInteractOutside","removeNodeFromVisibleModals","update","open","onClose","shouldCloseOnInteractOutside","closeOnInteractOutside","isLastModal","closeModal","onInteractOutsideStart","isElement","onInteractOutside","useInteractOutside","unsub","unsubClick","isPointerDown","isPointerDownInside","ignoreEmulatedMouseEvents","enabled","onPointerDown","isValidEvent","isOrContainsTarget","triggerInteractOutside","documentObj","getOwnerDocument","onPointerUp","handler","shouldTriggerInteractOutside","resetPointerState","addEventListener","executeCallbacks","onMouseUp","onTouchEnd","ownerDocument","createElHelpers","defaults","dialogIdParts","createDialog","props","withDefaults","toWritableStores","omit","preventScroll","closeOnEscape","closeOnOutsideClick","role","portal","forceVisible","openFocus","closeFocus","onOutsideClick","activeTrigger","withGet","ids","generateIds","openWritable","overridable","isVisible","derived","$open","$forceVisible","unsubScroll","handleOpen","triggerEl","handleClose","trigger","makeElement","addMeltEventListener","kbd","overlay","$isVisible","styleToString","unsubEscapeKeydown","escapeKeydown","useEscapeKeydown","$contentId","$descriptionId","$titleId","destroy","effect","$closeOnOutsideClick","$closeOnEscape","focusTrap","ac","portalled","$portal","portalAttr","unsubPortal","portalDestination","getPortalDestination","usePortal","title","description","close","$preventScroll","isBrowser","contentEl","getDialogData","setCtx","NAME","PARTS","getAttrs","createBitAttrs","dialog","removeUndefined","setContext","getOptionUpdater","getCtx","getContext","ctx","$$props","onOpenChange","localOpen","updateOption","next","$$invalidate","idValues","create_dynamic_element","svelte_element_levels","svelte_element","svelte_element_data","insert_hydration","anchor","get_spread_update","level","asChild","id","attrs","$$value","builder","$title","div_levels","div","transition","transitionConfig","inTransition","inTransitionConfig","outTransition","outTransitionConfig","$content","$overlay","$description","patchSource","source","line","reformatInputSource","dirty","codeblock_changes","pyNotebook","heuristics","items","sync","newItems","run","isPython","valid","indexURL","env.PUBLIC_PYODIDE_INDEX_URL","version","preloadPackages","setupWatcher","py","trackingDelegate","_handle","handle","change","path","oldpath","newpath","old_path","new_path","loader","div_transition","create_bidirectional_transition","fade","cubicOut","style___i","count","if_block","create_if_block","div2","append_hydration","div1","section","button","input","div2_transition","scale","message","callback","ref","click_handler","keydown_handler","key","nonce","tasks","prompt","initial","$tasks","task","getEnv","env","getMinimalPyodide","cacheSingleton","withToast","loadPyodide","toast","getSetupModule","setupModule","sources","moduleName","getPyodide","common","watchfiles","getPy","feature","console","chat","notebook","web","workspace","loadConsole","__vitePreload","loadNotebook","loadWeb","loadChat","loadWorkspace","onMount","$currentConsole","onDestroy"],"ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],"sources":["../../../../../../node_modules/@neodrag/svelte/dist/min/index.js","../../../../../../node_modules/@melt-ui/svelte/dist/internal/helpers/array.js","../../../../../../node_modules/@melt-ui/svelte/dist/internal/helpers/sleep.js","../../../../../../node_modules/@melt-ui/svelte/dist/internal/helpers/platform.js","../../../../../../node_modules/@melt-ui/svelte/dist/internal/helpers/scroll.js","../../../../../../node_modules/@melt-ui/svelte/dist/internal/helpers/focus.js","../../../../../../node_modules/tabbable/dist/index.esm.js","../../../../../../node_modules/focus-trap/dist/focus-trap.esm.js","../../../../../../node_modules/@melt-ui/svelte/dist/internal/actions/focus-trap/action.js","../../../../../../node_modules/@melt-ui/svelte/dist/internal/actions/modal/action.js","../../../../../../node_modules/@melt-ui/svelte/dist/internal/actions/interact-outside/action.js","../../../../../../node_modules/@melt-ui/svelte/dist/builders/dialog/create.js","../../../../../../node_modules/bits-ui/dist/bits/dialog/ctx.js","../../../../../../node_modules/bits-ui/dist/bits/dialog/components/dialog.svelte","../../../../../../node_modules/bits-ui/dist/bits/dialog/components/dialog-title.svelte","../../../../../../node_modules/bits-ui/dist/bits/dialog/components/dialog-content.svelte","../../../../../../node_modules/bits-ui/dist/bits/dialog/components/dialog-overlay.svelte","../../../../../../node_modules/bits-ui/dist/bits/dialog/components/dialog-description.svelte","../../../../../../src/lib/utils/formatSource.ts","../../../../../../src/lib/components/notebook/Code.svelte","../../../../../../src/lib/pyodide/common.ts","../../../../../../src/lib/pyodide/start/fs.ts","../../../../../../src/lib/pyodide/start/loader.py?raw","../../../../../../src/lib/components/Dialog.svelte","../../../../../../src/lib/components/Input.svelte","../../../../../../src/lib/utils/env.ts","../../../../../../src/lib/pyodide/start/init.ts","../../../../../../src/lib/pyodide/index.ts","../../../../../../src/lib/components/notebook/HeadlessNotebook.svelte"],"sourcesContent":["var e={dragStart:!0},t={delay:0,distance:3};var n=(e,t,n)=>Math.min(Math.max(e,t),n),r=e=>\"string\"==typeof e,o=([e,t],n,r)=>{const o=(e,t)=>0===t?0:Math.ceil(e/t)*t;return[o(n,e),o(r,t)]};var a=(e,t)=>e.some((e=>t.some((t=>e.contains(t)))));function i(e,t){if(void 0===e)return;if(l(e))return e.getBoundingClientRect();if(\"object\"==typeof e){const{top:t=0,left:n=0,right:r=0,bottom:o=0}=e;return{top:t,right:window.innerWidth-r,bottom:window.innerHeight-o,left:n}}if(\"parent\"===e)return t.parentNode.getBoundingClientRect();const n=document.querySelector(e);if(null===n)throw new Error(\"The selector provided for bound doesn't exists in the document.\");return n.getBoundingClientRect()}var s=(e,t,n)=>e.style.setProperty(t,n),l=e=>e instanceof HTMLElement,d=function(d,c={}){let u,f,{bounds:g,axis:h=\"both\",gpuAcceleration:p=!0,legacyTranslate:m=!1,transform:y,applyUserSelectHack:w=!0,disabled:b=!1,ignoreMultitouch:v=!1,recomputeBounds:x=e,grid:E,threshold:S=t,position:A,cancel:C,handle:D,defaultClass:N=\"neodrag\",defaultClassDragging:M=\"neodrag-dragging\",defaultClassDragged:B=\"neodrag-dragged\",defaultPosition:R={x:0,y:0},onDragStart:$,onDrag:X,onDragEnd:Y}=c,q=!1,H=!1,P=0,T=!1,k=!1,L=0,z=0,I=0,U=0,W=0,j=0,{x:F,y:G}=A?{x:A?.x??0,y:A?.y??0}:R;oe(F,G);let J,K,O,Q,V,Z=\"\",_=!!A;x={...e,...x},S={...t,...S??{}};let ee=new Set;function te(e){q&&!H&&k&&T&&V&&(H=!0,function(e){ae(\"neodrag:start\",$,e)}(e),re.add(M),w&&(Z=ne.userSelect,ne.userSelect=\"none\"))}const ne=document.body.style,re=d.classList;function oe(e=L,t=z){if(!y){if(m){let n=`${+e}px, ${+t}px`;return s(d,\"transform\",p?`translate3d(${n}, 0)`:`translate(${n})`)}return s(d,\"translate\",`${+e}px ${+t}px`)}const n=y({offsetX:e,offsetY:t,rootNode:d});r(n)&&s(d,\"transform\",n)}function ae(e,t,n){const r=function(e){return{offsetX:L,offsetY:z,rootNode:d,currentNode:V,event:e}}(n);d.dispatchEvent(new CustomEvent(e,{detail:r})),t?.(r)}const ie=addEventListener,se=new AbortController,le={signal:se.signal,capture:!1};function de(){let e=d.offsetWidth/K.width;return isNaN(e)&&(e=1),e}return s(d,\"touch-action\",\"none\"),ie(\"pointerdown\",(e=>{if(b)return;if(2===e.button)return;if(ee.add(e.pointerId),v&&ee.size>1)return e.preventDefault();if(x.dragStart&&(J=i(g,d)),r(D)&&r(C)&&D===C)throw new Error(\"`handle` selector can't be same as `cancel` selector\");if(re.add(N),O=function(e,t){if(!e)return[t];if(l(e))return[e];if(Array.isArray(e))return e;const n=t.querySelectorAll(e);if(null===n)throw new Error(\"Selector passed for `handle` option should be child of the element on which the action is applied\");return Array.from(n.values())}(D,d),Q=function(e,t){if(!e)return[];if(l(e))return[e];if(Array.isArray(e))return e;const n=t.querySelectorAll(e);if(null===n)throw new Error(\"Selector passed for `cancel` option should be child of the element on which the action is applied\");return Array.from(n.values())}(C,d),u=/(both|x)/.test(h),f=/(both|y)/.test(h),a(Q,O))throw new Error(\"Element being dragged can't be a child of the element on which `cancel` is applied\");const t=e.composedPath()[0];if(!O.some((e=>e.contains(t)||e.shadowRoot?.contains(t)))||a(Q,[t]))return;V=1===O.length?d:O.find((e=>e.contains(t))),q=!0,P=Date.now(),S.delay||(T=!0),K=d.getBoundingClientRect();const{clientX:n,clientY:o}=e,s=de();u&&(I=n-F/s),f&&(U=o-G/s),J&&(W=n-K.left,j=o-K.top)}),le),ie(\"pointermove\",(e=>{if(!q||v&&ee.size>1)return;if(!H){if(!T){Date.now()-P>=S.delay&&(T=!0,te(e))}if(!k){const t=e.clientX-I,n=e.clientY-U;Math.sqrt(t**2+n**2)>=S.distance&&(k=!0,te(e))}if(!H)return}x.drag&&(J=i(g,d)),e.preventDefault(),K=d.getBoundingClientRect();let t=e.clientX,r=e.clientY;const a=de();if(J){const e={left:J.left+W,top:J.top+j,right:J.right+W-K.width,bottom:J.bottom+j-K.height};t=n(t,e.left,e.right),r=n(r,e.top,e.bottom)}if(Array.isArray(E)){let[e,n]=E;if(isNaN(+e)||e<0)throw new Error(\"1st argument of `grid` must be a valid positive number\");if(isNaN(+n)||n<0)throw new Error(\"2nd argument of `grid` must be a valid positive number\");let i=t-I,s=r-U;[i,s]=o([e/a,n/a],i,s),t=I+i,r=U+s}u&&(L=Math.round((t-I)*a)),f&&(z=Math.round((r-U)*a)),F=L,G=z,ae(\"neodrag\",X,e),oe()}),le),ie(\"pointerup\",(e=>{(ee.delete(e.pointerId),q)&&(H&&(ie(\"click\",(e=>e.stopPropagation()),{once:!0,signal:se.signal,capture:!0}),x.dragEnd&&(J=i(g,d)),re.remove(M),re.add(B),w&&(ne.userSelect=Z),ae(\"neodrag:end\",Y,e),u&&(I=L),f&&(U=z)),q=!1,H=!1,T=!1,k=!1)}),le),{destroy:()=>se.abort(),update:n=>{h=n.axis||\"both\",b=n.disabled??!1,v=n.ignoreMultitouch??!1,D=n.handle,g=n.bounds,x=n.recomputeBounds??e,C=n.cancel,w=n.applyUserSelectHack??!0,E=n.grid,p=n.gpuAcceleration??!0,m=n.legacyTranslate??!1,y=n.transform,S={...t,...n.threshold??{}};const r=re.contains(B);re.remove(N,B),N=n.defaultClass??\"neodrag\",M=n.defaultClassDragging??\"neodrag-dragging\",B=n.defaultClassDragged??\"neodrag-dragged\",re.add(N),r&&re.add(B),_&&(F=L=n.position?.x??L,G=z=n.position?.y??z,oe())}}};\n//!THIS IS HACK, WE WANNA IMPORT THE TYPE WHEN THE ISSUE IS FIXED LATER\nexport{d as draggable};","import { dequal as deepEqual } from 'dequal';\n/**\n * Returns the element some number before the given index. If the target index is out of bounds:\n *   - If looping is disabled, the first element will be returned.\n *   - If looping is enabled, the last element will be returned.\n * @param array the array.\n * @param currentIndex the index of the current element.\n * @param increment the number of elements to move forward.\n * @param loop loop to the beginning of the array if the target index is out of bounds?\n */\nexport function back(array, index, increment, loop = true) {\n    const previousIndex = index - increment;\n    if (previousIndex <= 0) {\n        return loop ? array[array.length - 1] : array[0];\n    }\n    return array[previousIndex];\n}\n/**\n * Returns the element some number after the given index. If the target index is out of bounds:\n *   - If looping is disabled, the last element will be returned.\n *   - If looping is enabled, the first element will be returned.\n * @param array the array.\n * @param currentIndex the index of the current element.\n * @param increment the number of elements to move forward.\n * @param loop loop to the beginning of the array if the target index is out of bounds?\n */\nexport function forward(array, index, increment, loop = true) {\n    const nextIndex = index + increment;\n    if (nextIndex > array.length - 1) {\n        return loop ? array[0] : array[array.length - 1];\n    }\n    return array[nextIndex];\n}\n/**\n * Returns the array element after to the given index.\n * @param array the array.\n * @param currentIndex the index of the current element.\n * @param loop loop to the beginning of the array if the next index is out of bounds?\n */\nexport function next(array, index, loop = true) {\n    if (index === array.length - 1) {\n        return loop ? array[0] : array[index];\n    }\n    return array[index + 1];\n}\n/**\n * Returns the array element prior to the given index.\n * @param array the array.\n * @param currentIndex the index of the current element.\n * @param loop loop to the end of the array if the previous index is out of bounds?\n */\nexport function prev(array, currentIndex, loop = true) {\n    if (currentIndex <= 0) {\n        return loop ? array[array.length - 1] : array[0];\n    }\n    return array[currentIndex - 1];\n}\n/**\n * Returns the last element in an array.\n * @param array the array.\n */\nexport function last(array) {\n    return array[array.length - 1];\n}\n/**\n * Wraps an array around itself at a given starting index.\n * @example ```ts\n * wrapArray(['a', 'b', 'c', 'd'], 2);\n * // ['c', 'd', 'a', 'b']\n * ```\n * @see https://github.com/radix-ui/primitives\n */\nexport function wrapArray(array, startIndex) {\n    return array.map((_, index) => array[(startIndex + index) % array.length]);\n}\n/**\n * Toggles an item in an array. If the item is already in the array,\n * it is removed. Otherwise, it is added.\n * @param item The item to toggle.\n * @param array The array to toggle the item in.\n * @returns The updated array with the item toggled.\n * @template T The type of the items in the array.\n * @example ```typescript\n * const arr = [1, 2, 3];\n * const newArr = toggle(2, arr);\n * // newArr = [1, 3]\n * ```\n */\nexport function toggle(item, array, compare = deepEqual) {\n    const itemIdx = array.findIndex((innerItem) => compare(innerItem, item));\n    if (itemIdx !== -1) {\n        array.splice(itemIdx, 1);\n    }\n    else {\n        array.push(item);\n    }\n    return array;\n}\n/**\n * Splits an array into chunks of a given size.\n * @param arr The array to split.\n * @param size The size of each chunk.\n * @returns An array of arrays, where each sub-array has `size` elements from the original array.\n * @example ```ts\n * const arr = [1, 2, 3, 4, 5, 6, 7, 8];\n * const chunks = chunk(arr, 3);\n * // chunks = [[1, 2, 3], [4, 5, 6], [7, 8]]\n * ```\n */\nexport function chunk(arr, size) {\n    const result = [];\n    for (let i = 0; i < arr.length; i += size) {\n        result.push(arr.slice(i, i + size));\n    }\n    return result;\n}\n/**\n * Checks if the given index is valid for the given array.\n *\n * @param index - The index to check\n * @param arr - The array to check\n */\nexport function isValidIndex(index, arr) {\n    return index >= 0 && index < arr.length;\n}\n","export function sleep(ms) {\n    return new Promise((resolve) => setTimeout(resolve, ms));\n}\n","export const isDom = () => typeof window !== 'undefined';\nexport function getPlatform() {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const agent = navigator.userAgentData;\n    return (agent?.platform ?? navigator.platform);\n}\nconst pt = (v) => isDom() && v.test(getPlatform().toLowerCase());\nconst ua = (v) => isDom() && v.test(navigator.userAgent);\nconst vn = (v) => isDom() && v.test(navigator.vendor);\nexport const isTouchDevice = () => isDom() && !!navigator.maxTouchPoints;\nexport const isMac = () => pt(/^mac/) && !isTouchDevice();\nexport const isIPhone = () => pt(/^iphone/);\nexport const isSafari = () => isApple() && vn(/apple/i);\nexport const isFirefox = () => ua(/firefox\\//i);\nexport const isApple = () => pt(/mac|iphone|ipad|ipod/i);\nexport const isIos = () => isApple() && !isMac();\n","// Modified from @zag-js/remove-scroll v0.10.2 (2023-06-10)\n// Source: https://github.com/chakra-ui/zag\n// https://github.com/chakra-ui/zag/blob/main/packages/utilities/remove-scroll/src/index.ts\nimport { noop } from './callbacks.js';\nimport { isIos } from './platform.js';\nconst LOCK_CLASSNAME = 'data-melt-scroll-lock';\nfunction assignStyle(el, style) {\n    if (!el)\n        return;\n    const previousStyle = el.style.cssText;\n    Object.assign(el.style, style);\n    return () => {\n        el.style.cssText = previousStyle;\n    };\n}\nfunction setCSSProperty(el, property, value) {\n    if (!el)\n        return;\n    const previousValue = el.style.getPropertyValue(property);\n    el.style.setProperty(property, value);\n    return () => {\n        if (previousValue) {\n            el.style.setProperty(property, previousValue);\n        }\n        else {\n            el.style.removeProperty(property);\n        }\n    };\n}\nfunction getPaddingProperty(documentElement) {\n    // RTL <body> scrollbar\n    const documentLeft = documentElement.getBoundingClientRect().left;\n    const scrollbarX = Math.round(documentLeft) + documentElement.scrollLeft;\n    return scrollbarX ? 'paddingLeft' : 'paddingRight';\n}\nexport function removeScroll(_document) {\n    const doc = _document ?? document;\n    const win = doc.defaultView ?? window;\n    const { documentElement, body } = doc;\n    const locked = body.hasAttribute(LOCK_CLASSNAME);\n    if (locked)\n        return noop;\n    body.setAttribute(LOCK_CLASSNAME, '');\n    const scrollbarWidth = win.innerWidth - documentElement.clientWidth;\n    const setScrollbarWidthProperty = () => setCSSProperty(documentElement, '--scrollbar-width', `${scrollbarWidth}px`);\n    const paddingProperty = getPaddingProperty(documentElement);\n    const scrollbarSidePadding = win.getComputedStyle(body)[paddingProperty];\n    const setStyle = () => assignStyle(body, {\n        overflow: 'hidden',\n        [paddingProperty]: `calc(${scrollbarSidePadding} + ${scrollbarWidth}px)`,\n    });\n    // Only iOS doesn't respect `overflow: hidden` on document.body\n    const setIOSStyle = () => {\n        const { scrollX, scrollY, visualViewport } = win;\n        // iOS 12 does not support `visuaViewport`.\n        const offsetLeft = visualViewport?.offsetLeft ?? 0;\n        const offsetTop = visualViewport?.offsetTop ?? 0;\n        const restoreStyle = assignStyle(body, {\n            position: 'fixed',\n            overflow: 'hidden',\n            top: `${-(scrollY - Math.floor(offsetTop))}px`,\n            left: `${-(scrollX - Math.floor(offsetLeft))}px`,\n            right: '0',\n            [paddingProperty]: `calc(${scrollbarSidePadding} + ${scrollbarWidth}px)`,\n        });\n        return () => {\n            restoreStyle?.();\n            win.scrollTo(scrollX, scrollY);\n        };\n    };\n    const cleanups = [setScrollbarWidthProperty(), isIos() ? setIOSStyle() : setStyle()];\n    return () => {\n        cleanups.forEach((fn) => fn?.());\n        body.removeAttribute(LOCK_CLASSNAME);\n    };\n}\n","import { isFunction, isHTMLElement, sleep } from './index.js';\nimport { tick } from 'svelte';\nexport async function handleFocus(args) {\n    const { prop, defaultEl } = args;\n    await Promise.all([sleep(1), tick]);\n    if (prop === undefined) {\n        defaultEl?.focus();\n        return;\n    }\n    const returned = isFunction(prop) ? prop(defaultEl) : prop;\n    if (typeof returned === 'string') {\n        // Get el by selector, focus it\n        const el = document.querySelector(returned);\n        if (!isHTMLElement(el))\n            return;\n        el.focus();\n    }\n    else if (isHTMLElement(returned)) {\n        // Focus it\n        returned.focus();\n    }\n}\n","/*!\n* tabbable 6.3.0\n* @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE\n*/\n// NOTE: separate `:not()` selectors has broader browser support than the newer\n//  `:not([inert], [inert] *)` (Feb 2023)\n// CAREFUL: JSDom does not support `:not([inert] *)` as a selector; using it causes\n//  the entire query to fail, resulting in no nodes found, which will break a lot\n//  of things... so we have to rely on JS to identify nodes inside an inert container\nvar candidateSelectors = ['input:not([inert])', 'select:not([inert])', 'textarea:not([inert])', 'a[href]:not([inert])', 'button:not([inert])', '[tabindex]:not(slot):not([inert])', 'audio[controls]:not([inert])', 'video[controls]:not([inert])', '[contenteditable]:not([contenteditable=\"false\"]):not([inert])', 'details>summary:first-of-type:not([inert])', 'details:not([inert])'];\nvar candidateSelector = /* #__PURE__ */candidateSelectors.join(',');\nvar NoElement = typeof Element === 'undefined';\nvar matches = NoElement ? function () {} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;\nvar getRootNode = !NoElement && Element.prototype.getRootNode ? function (element) {\n  var _element$getRootNode;\n  return element === null || element === void 0 ? void 0 : (_element$getRootNode = element.getRootNode) === null || _element$getRootNode === void 0 ? void 0 : _element$getRootNode.call(element);\n} : function (element) {\n  return element === null || element === void 0 ? void 0 : element.ownerDocument;\n};\n\n/**\n * Determines if a node is inert or in an inert ancestor.\n * @param {Element} [node]\n * @param {boolean} [lookUp] If true and `node` is not inert, looks up at ancestors to\n *  see if any of them are inert. If false, only `node` itself is considered.\n * @returns {boolean} True if inert itself or by way of being in an inert ancestor.\n *  False if `node` is falsy.\n */\nvar _isInert = function isInert(node, lookUp) {\n  var _node$getAttribute;\n  if (lookUp === void 0) {\n    lookUp = true;\n  }\n  // CAREFUL: JSDom does not support inert at all, so we can't use the `HTMLElement.inert`\n  //  JS API property; we have to check the attribute, which can either be empty or 'true';\n  //  if it's `null` (not specified) or 'false', it's an active element\n  var inertAtt = node === null || node === void 0 ? void 0 : (_node$getAttribute = node.getAttribute) === null || _node$getAttribute === void 0 ? void 0 : _node$getAttribute.call(node, 'inert');\n  var inert = inertAtt === '' || inertAtt === 'true';\n\n  // NOTE: this could also be handled with `node.matches('[inert], :is([inert] *)')`\n  //  if it weren't for `matches()` not being a function on shadow roots; the following\n  //  code works for any kind of node\n  // CAREFUL: JSDom does not appear to support certain selectors like `:not([inert] *)`\n  //  so it likely would not support `:is([inert] *)` either...\n  var result = inert || lookUp && node && _isInert(node.parentNode); // recursive\n\n  return result;\n};\n\n/**\n * Determines if a node's content is editable.\n * @param {Element} [node]\n * @returns True if it's content-editable; false if it's not or `node` is falsy.\n */\nvar isContentEditable = function isContentEditable(node) {\n  var _node$getAttribute2;\n  // CAREFUL: JSDom does not support the `HTMLElement.isContentEditable` API so we have\n  //  to use the attribute directly to check for this, which can either be empty or 'true';\n  //  if it's `null` (not specified) or 'false', it's a non-editable element\n  var attValue = node === null || node === void 0 ? void 0 : (_node$getAttribute2 = node.getAttribute) === null || _node$getAttribute2 === void 0 ? void 0 : _node$getAttribute2.call(node, 'contenteditable');\n  return attValue === '' || attValue === 'true';\n};\n\n/**\n * @param {Element} el container to check in\n * @param {boolean} includeContainer add container to check\n * @param {(node: Element) => boolean} filter filter candidates\n * @returns {Element[]}\n */\nvar getCandidates = function getCandidates(el, includeContainer, filter) {\n  // even if `includeContainer=false`, we still have to check it for inertness because\n  //  if it's inert, all its children are inert\n  if (_isInert(el)) {\n    return [];\n  }\n  var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));\n  if (includeContainer && matches.call(el, candidateSelector)) {\n    candidates.unshift(el);\n  }\n  candidates = candidates.filter(filter);\n  return candidates;\n};\n\n/**\n * @callback GetShadowRoot\n * @param {Element} element to check for shadow root\n * @returns {ShadowRoot|boolean} ShadowRoot if available or boolean indicating if a shadowRoot is attached but not available.\n */\n\n/**\n * @callback ShadowRootFilter\n * @param {Element} shadowHostNode the element which contains shadow content\n * @returns {boolean} true if a shadow root could potentially contain valid candidates.\n */\n\n/**\n * @typedef {Object} CandidateScope\n * @property {Element} scopeParent contains inner candidates\n * @property {Element[]} candidates list of candidates found in the scope parent\n */\n\n/**\n * @typedef {Object} IterativeOptions\n * @property {GetShadowRoot|boolean} getShadowRoot true if shadow support is enabled; falsy if not;\n *  if a function, implies shadow support is enabled and either returns the shadow root of an element\n *  or a boolean stating if it has an undisclosed shadow root\n * @property {(node: Element) => boolean} filter filter candidates\n * @property {boolean} flatten if true then result will flatten any CandidateScope into the returned list\n * @property {ShadowRootFilter} shadowRootFilter filter shadow roots;\n */\n\n/**\n * @param {Element[]} elements list of element containers to match candidates from\n * @param {boolean} includeContainer add container list to check\n * @param {IterativeOptions} options\n * @returns {Array.<Element|CandidateScope>}\n */\nvar _getCandidatesIteratively = function getCandidatesIteratively(elements, includeContainer, options) {\n  var candidates = [];\n  var elementsToCheck = Array.from(elements);\n  while (elementsToCheck.length) {\n    var element = elementsToCheck.shift();\n    if (_isInert(element, false)) {\n      // no need to look up since we're drilling down\n      // anything inside this container will also be inert\n      continue;\n    }\n    if (element.tagName === 'SLOT') {\n      // add shadow dom slot scope (slot itself cannot be focusable)\n      var assigned = element.assignedElements();\n      var content = assigned.length ? assigned : element.children;\n      var nestedCandidates = _getCandidatesIteratively(content, true, options);\n      if (options.flatten) {\n        candidates.push.apply(candidates, nestedCandidates);\n      } else {\n        candidates.push({\n          scopeParent: element,\n          candidates: nestedCandidates\n        });\n      }\n    } else {\n      // check candidate element\n      var validCandidate = matches.call(element, candidateSelector);\n      if (validCandidate && options.filter(element) && (includeContainer || !elements.includes(element))) {\n        candidates.push(element);\n      }\n\n      // iterate over shadow content if possible\n      var shadowRoot = element.shadowRoot ||\n      // check for an undisclosed shadow\n      typeof options.getShadowRoot === 'function' && options.getShadowRoot(element);\n\n      // no inert look up because we're already drilling down and checking for inertness\n      //  on the way down, so all containers to this root node should have already been\n      //  vetted as non-inert\n      var validShadowRoot = !_isInert(shadowRoot, false) && (!options.shadowRootFilter || options.shadowRootFilter(element));\n      if (shadowRoot && validShadowRoot) {\n        // add shadow dom scope IIF a shadow root node was given; otherwise, an undisclosed\n        //  shadow exists, so look at light dom children as fallback BUT create a scope for any\n        //  child candidates found because they're likely slotted elements (elements that are\n        //  children of the web component element (which has the shadow), in the light dom, but\n        //  slotted somewhere _inside_ the undisclosed shadow) -- the scope is created below,\n        //  _after_ we return from this recursive call\n        var _nestedCandidates = _getCandidatesIteratively(shadowRoot === true ? element.children : shadowRoot.children, true, options);\n        if (options.flatten) {\n          candidates.push.apply(candidates, _nestedCandidates);\n        } else {\n          candidates.push({\n            scopeParent: element,\n            candidates: _nestedCandidates\n          });\n        }\n      } else {\n        // there's not shadow so just dig into the element's (light dom) children\n        //  __without__ giving the element special scope treatment\n        elementsToCheck.unshift.apply(elementsToCheck, element.children);\n      }\n    }\n  }\n  return candidates;\n};\n\n/**\n * @private\n * Determines if the node has an explicitly specified `tabindex` attribute.\n * @param {HTMLElement} node\n * @returns {boolean} True if so; false if not.\n */\nvar hasTabIndex = function hasTabIndex(node) {\n  return !isNaN(parseInt(node.getAttribute('tabindex'), 10));\n};\n\n/**\n * Determine the tab index of a given node.\n * @param {HTMLElement} node\n * @returns {number} Tab order (negative, 0, or positive number).\n * @throws {Error} If `node` is falsy.\n */\nvar getTabIndex = function getTabIndex(node) {\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (node.tabIndex < 0) {\n    // in Chrome, <details/>, <audio controls/> and <video controls/> elements get a default\n    // `tabIndex` of -1 when the 'tabindex' attribute isn't specified in the DOM,\n    // yet they are still part of the regular tab order; in FF, they get a default\n    // `tabIndex` of 0; since Chrome still puts those elements in the regular tab\n    // order, consider their tab index to be 0.\n    // Also browsers do not return `tabIndex` correctly for contentEditable nodes;\n    // so if they don't have a tabindex attribute specifically set, assume it's 0.\n    if ((/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) || isContentEditable(node)) && !hasTabIndex(node)) {\n      return 0;\n    }\n  }\n  return node.tabIndex;\n};\n\n/**\n * Determine the tab index of a given node __for sort order purposes__.\n * @param {HTMLElement} node\n * @param {boolean} [isScope] True for a custom element with shadow root or slot that, by default,\n *  has tabIndex -1, but needs to be sorted by document order in order for its content to be\n *  inserted into the correct sort position.\n * @returns {number} Tab order (negative, 0, or positive number).\n */\nvar getSortOrderTabIndex = function getSortOrderTabIndex(node, isScope) {\n  var tabIndex = getTabIndex(node);\n  if (tabIndex < 0 && isScope && !hasTabIndex(node)) {\n    return 0;\n  }\n  return tabIndex;\n};\nvar sortOrderedTabbables = function sortOrderedTabbables(a, b) {\n  return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;\n};\nvar isInput = function isInput(node) {\n  return node.tagName === 'INPUT';\n};\nvar isHiddenInput = function isHiddenInput(node) {\n  return isInput(node) && node.type === 'hidden';\n};\nvar isDetailsWithSummary = function isDetailsWithSummary(node) {\n  var r = node.tagName === 'DETAILS' && Array.prototype.slice.apply(node.children).some(function (child) {\n    return child.tagName === 'SUMMARY';\n  });\n  return r;\n};\nvar getCheckedRadio = function getCheckedRadio(nodes, form) {\n  for (var i = 0; i < nodes.length; i++) {\n    if (nodes[i].checked && nodes[i].form === form) {\n      return nodes[i];\n    }\n  }\n};\nvar isTabbableRadio = function isTabbableRadio(node) {\n  if (!node.name) {\n    return true;\n  }\n  var radioScope = node.form || getRootNode(node);\n  var queryRadios = function queryRadios(name) {\n    return radioScope.querySelectorAll('input[type=\"radio\"][name=\"' + name + '\"]');\n  };\n  var radioSet;\n  if (typeof window !== 'undefined' && typeof window.CSS !== 'undefined' && typeof window.CSS.escape === 'function') {\n    radioSet = queryRadios(window.CSS.escape(node.name));\n  } else {\n    try {\n      radioSet = queryRadios(node.name);\n    } catch (err) {\n      // eslint-disable-next-line no-console\n      console.error('Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s', err.message);\n      return false;\n    }\n  }\n  var checked = getCheckedRadio(radioSet, node.form);\n  return !checked || checked === node;\n};\nvar isRadio = function isRadio(node) {\n  return isInput(node) && node.type === 'radio';\n};\nvar isNonTabbableRadio = function isNonTabbableRadio(node) {\n  return isRadio(node) && !isTabbableRadio(node);\n};\n\n// determines if a node is ultimately attached to the window's document\nvar isNodeAttached = function isNodeAttached(node) {\n  var _nodeRoot;\n  // The root node is the shadow root if the node is in a shadow DOM; some document otherwise\n  //  (but NOT _the_ document; see second 'If' comment below for more).\n  // If rootNode is shadow root, it'll have a host, which is the element to which the shadow\n  //  is attached, and the one we need to check if it's in the document or not (because the\n  //  shadow, and all nodes it contains, is never considered in the document since shadows\n  //  behave like self-contained DOMs; but if the shadow's HOST, which is part of the document,\n  //  is hidden, or is not in the document itself but is detached, it will affect the shadow's\n  //  visibility, including all the nodes it contains). The host could be any normal node,\n  //  or a custom element (i.e. web component). Either way, that's the one that is considered\n  //  part of the document, not the shadow root, nor any of its children (i.e. the node being\n  //  tested).\n  // To further complicate things, we have to look all the way up until we find a shadow HOST\n  //  that is attached (or find none) because the node might be in nested shadows...\n  // If rootNode is not a shadow root, it won't have a host, and so rootNode should be the\n  //  document (per the docs) and while it's a Document-type object, that document does not\n  //  appear to be the same as the node's `ownerDocument` for some reason, so it's safer\n  //  to ignore the rootNode at this point, and use `node.ownerDocument`. Otherwise,\n  //  using `rootNode.contains(node)` will _always_ be true we'll get false-positives when\n  //  node is actually detached.\n  // NOTE: If `nodeRootHost` or `node` happens to be the `document` itself (which is possible\n  //  if a tabbable/focusable node was quickly added to the DOM, focused, and then removed\n  //  from the DOM as in https://github.com/focus-trap/focus-trap-react/issues/905), then\n  //  `ownerDocument` will be `null`, hence the optional chaining on it.\n  var nodeRoot = node && getRootNode(node);\n  var nodeRootHost = (_nodeRoot = nodeRoot) === null || _nodeRoot === void 0 ? void 0 : _nodeRoot.host;\n\n  // in some cases, a detached node will return itself as the root instead of a document or\n  //  shadow root object, in which case, we shouldn't try to look further up the host chain\n  var attached = false;\n  if (nodeRoot && nodeRoot !== node) {\n    var _nodeRootHost, _nodeRootHost$ownerDo, _node$ownerDocument;\n    attached = !!((_nodeRootHost = nodeRootHost) !== null && _nodeRootHost !== void 0 && (_nodeRootHost$ownerDo = _nodeRootHost.ownerDocument) !== null && _nodeRootHost$ownerDo !== void 0 && _nodeRootHost$ownerDo.contains(nodeRootHost) || node !== null && node !== void 0 && (_node$ownerDocument = node.ownerDocument) !== null && _node$ownerDocument !== void 0 && _node$ownerDocument.contains(node));\n    while (!attached && nodeRootHost) {\n      var _nodeRoot2, _nodeRootHost2, _nodeRootHost2$ownerD;\n      // since it's not attached and we have a root host, the node MUST be in a nested shadow DOM,\n      //  which means we need to get the host's host and check if that parent host is contained\n      //  in (i.e. attached to) the document\n      nodeRoot = getRootNode(nodeRootHost);\n      nodeRootHost = (_nodeRoot2 = nodeRoot) === null || _nodeRoot2 === void 0 ? void 0 : _nodeRoot2.host;\n      attached = !!((_nodeRootHost2 = nodeRootHost) !== null && _nodeRootHost2 !== void 0 && (_nodeRootHost2$ownerD = _nodeRootHost2.ownerDocument) !== null && _nodeRootHost2$ownerD !== void 0 && _nodeRootHost2$ownerD.contains(nodeRootHost));\n    }\n  }\n  return attached;\n};\nvar isZeroArea = function isZeroArea(node) {\n  var _node$getBoundingClie = node.getBoundingClientRect(),\n    width = _node$getBoundingClie.width,\n    height = _node$getBoundingClie.height;\n  return width === 0 && height === 0;\n};\nvar isHidden = function isHidden(node, _ref) {\n  var displayCheck = _ref.displayCheck,\n    getShadowRoot = _ref.getShadowRoot;\n  if (displayCheck === 'full-native') {\n    if ('checkVisibility' in node) {\n      // Chrome >= 105, Edge >= 105, Firefox >= 106, Safari >= 17.4\n      // @see https://developer.mozilla.org/en-US/docs/Web/API/Element/checkVisibility#browser_compatibility\n      var visible = node.checkVisibility({\n        // Checking opacity might be desirable for some use cases, but natively,\n        // opacity zero elements _are_ focusable and tabbable.\n        checkOpacity: false,\n        opacityProperty: false,\n        contentVisibilityAuto: true,\n        visibilityProperty: true,\n        // This is an alias for `visibilityProperty`. Contemporary browsers\n        // support both. However, this alias has wider browser support (Chrome\n        // >= 105 and Firefox >= 106, vs. Chrome >= 121 and Firefox >= 122), so\n        // we include it anyway.\n        checkVisibilityCSS: true\n      });\n      return !visible;\n    }\n    // Fall through to manual visibility checks\n  }\n\n  // NOTE: visibility will be `undefined` if node is detached from the document\n  //  (see notes about this further down), which means we will consider it visible\n  //  (this is legacy behavior from a very long way back)\n  // NOTE: we check this regardless of `displayCheck=\"none\"` because this is a\n  //  _visibility_ check, not a _display_ check\n  if (getComputedStyle(node).visibility === 'hidden') {\n    return true;\n  }\n  var isDirectSummary = matches.call(node, 'details>summary:first-of-type');\n  var nodeUnderDetails = isDirectSummary ? node.parentElement : node;\n  if (matches.call(nodeUnderDetails, 'details:not([open]) *')) {\n    return true;\n  }\n  if (!displayCheck || displayCheck === 'full' ||\n  // full-native can run this branch when it falls through in case\n  // Element#checkVisibility is unsupported\n  displayCheck === 'full-native' || displayCheck === 'legacy-full') {\n    if (typeof getShadowRoot === 'function') {\n      // figure out if we should consider the node to be in an undisclosed shadow and use the\n      //  'non-zero-area' fallback\n      var originalNode = node;\n      while (node) {\n        var parentElement = node.parentElement;\n        var rootNode = getRootNode(node);\n        if (parentElement && !parentElement.shadowRoot && getShadowRoot(parentElement) === true // check if there's an undisclosed shadow\n        ) {\n          // node has an undisclosed shadow which means we can only treat it as a black box, so we\n          //  fall back to a non-zero-area test\n          return isZeroArea(node);\n        } else if (node.assignedSlot) {\n          // iterate up slot\n          node = node.assignedSlot;\n        } else if (!parentElement && rootNode !== node.ownerDocument) {\n          // cross shadow boundary\n          node = rootNode.host;\n        } else {\n          // iterate up normal dom\n          node = parentElement;\n        }\n      }\n      node = originalNode;\n    }\n    // else, `getShadowRoot` might be true, but all that does is enable shadow DOM support\n    //  (i.e. it does not also presume that all nodes might have undisclosed shadows); or\n    //  it might be a falsy value, which means shadow DOM support is disabled\n\n    // Since we didn't find it sitting in an undisclosed shadow (or shadows are disabled)\n    //  now we can just test to see if it would normally be visible or not, provided it's\n    //  attached to the main document.\n    // NOTE: We must consider case where node is inside a shadow DOM and given directly to\n    //  `isTabbable()` or `isFocusable()` -- regardless of `getShadowRoot` option setting.\n\n    if (isNodeAttached(node)) {\n      // this works wherever the node is: if there's at least one client rect, it's\n      //  somehow displayed; it also covers the CSS 'display: contents' case where the\n      //  node itself is hidden in place of its contents; and there's no need to search\n      //  up the hierarchy either\n      return !node.getClientRects().length;\n    }\n\n    // Else, the node isn't attached to the document, which means the `getClientRects()`\n    //  API will __always__ return zero rects (this can happen, for example, if React\n    //  is used to render nodes onto a detached tree, as confirmed in this thread:\n    //  https://github.com/facebook/react/issues/9117#issuecomment-284228870)\n    //\n    // It also means that even window.getComputedStyle(node).display will return `undefined`\n    //  because styles are only computed for nodes that are in the document.\n    //\n    // NOTE: THIS HAS BEEN THE CASE FOR YEARS. It is not new, nor is it caused by tabbable\n    //  somehow. Though it was never stated officially, anyone who has ever used tabbable\n    //  APIs on nodes in detached containers has actually implicitly used tabbable in what\n    //  was later (as of v5.2.0 on Apr 9, 2021) called `displayCheck=\"none\"` mode -- essentially\n    //  considering __everything__ to be visible because of the innability to determine styles.\n    //\n    // v6.0.0: As of this major release, the default 'full' option __no longer treats detached\n    //  nodes as visible with the 'none' fallback.__\n    if (displayCheck !== 'legacy-full') {\n      return true; // hidden\n    }\n    // else, fallback to 'none' mode and consider the node visible\n  } else if (displayCheck === 'non-zero-area') {\n    // NOTE: Even though this tests that the node's client rect is non-zero to determine\n    //  whether it's displayed, and that a detached node will __always__ have a zero-area\n    //  client rect, we don't special-case for whether the node is attached or not. In\n    //  this mode, we do want to consider nodes that have a zero area to be hidden at all\n    //  times, and that includes attached or not.\n    return isZeroArea(node);\n  }\n\n  // visible, as far as we can tell, or per current `displayCheck=none` mode, we assume\n  //  it's visible\n  return false;\n};\n\n// form fields (nested) inside a disabled fieldset are not focusable/tabbable\n//  unless they are in the _first_ <legend> element of the top-most disabled\n//  fieldset\nvar isDisabledFromFieldset = function isDisabledFromFieldset(node) {\n  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {\n    var parentNode = node.parentElement;\n    // check if `node` is contained in a disabled <fieldset>\n    while (parentNode) {\n      if (parentNode.tagName === 'FIELDSET' && parentNode.disabled) {\n        // look for the first <legend> among the children of the disabled <fieldset>\n        for (var i = 0; i < parentNode.children.length; i++) {\n          var child = parentNode.children.item(i);\n          // when the first <legend> (in document order) is found\n          if (child.tagName === 'LEGEND') {\n            // if its parent <fieldset> is not nested in another disabled <fieldset>,\n            // return whether `node` is a descendant of its first <legend>\n            return matches.call(parentNode, 'fieldset[disabled] *') ? true : !child.contains(node);\n          }\n        }\n        // the disabled <fieldset> containing `node` has no <legend>\n        return true;\n      }\n      parentNode = parentNode.parentElement;\n    }\n  }\n\n  // else, node's tabbable/focusable state should not be affected by a fieldset's\n  //  enabled/disabled state\n  return false;\n};\nvar isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable(options, node) {\n  if (node.disabled ||\n  // we must do an inert look up to filter out any elements inside an inert ancestor\n  //  because we're limited in the type of selectors we can use in JSDom (see related\n  //  note related to `candidateSelectors`)\n  _isInert(node) || isHiddenInput(node) || isHidden(node, options) ||\n  // For a details element with a summary, the summary element gets the focus\n  isDetailsWithSummary(node) || isDisabledFromFieldset(node)) {\n    return false;\n  }\n  return true;\n};\nvar isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable(options, node) {\n  if (isNonTabbableRadio(node) || getTabIndex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) {\n    return false;\n  }\n  return true;\n};\nvar isShadowRootTabbable = function isShadowRootTabbable(shadowHostNode) {\n  var tabIndex = parseInt(shadowHostNode.getAttribute('tabindex'), 10);\n  if (isNaN(tabIndex) || tabIndex >= 0) {\n    return true;\n  }\n  // If a custom element has an explicit negative tabindex,\n  // browsers will not allow tab targeting said element's children.\n  return false;\n};\n\n/**\n * @param {Array.<Element|CandidateScope>} candidates\n * @returns Element[]\n */\nvar _sortByOrder = function sortByOrder(candidates) {\n  var regularTabbables = [];\n  var orderedTabbables = [];\n  candidates.forEach(function (item, i) {\n    var isScope = !!item.scopeParent;\n    var element = isScope ? item.scopeParent : item;\n    var candidateTabindex = getSortOrderTabIndex(element, isScope);\n    var elements = isScope ? _sortByOrder(item.candidates) : element;\n    if (candidateTabindex === 0) {\n      isScope ? regularTabbables.push.apply(regularTabbables, elements) : regularTabbables.push(element);\n    } else {\n      orderedTabbables.push({\n        documentOrder: i,\n        tabIndex: candidateTabindex,\n        item: item,\n        isScope: isScope,\n        content: elements\n      });\n    }\n  });\n  return orderedTabbables.sort(sortOrderedTabbables).reduce(function (acc, sortable) {\n    sortable.isScope ? acc.push.apply(acc, sortable.content) : acc.push(sortable.content);\n    return acc;\n  }, []).concat(regularTabbables);\n};\nvar tabbable = function tabbable(container, options) {\n  options = options || {};\n  var candidates;\n  if (options.getShadowRoot) {\n    candidates = _getCandidatesIteratively([container], options.includeContainer, {\n      filter: isNodeMatchingSelectorTabbable.bind(null, options),\n      flatten: false,\n      getShadowRoot: options.getShadowRoot,\n      shadowRootFilter: isShadowRootTabbable\n    });\n  } else {\n    candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));\n  }\n  return _sortByOrder(candidates);\n};\nvar focusable = function focusable(container, options) {\n  options = options || {};\n  var candidates;\n  if (options.getShadowRoot) {\n    candidates = _getCandidatesIteratively([container], options.includeContainer, {\n      filter: isNodeMatchingSelectorFocusable.bind(null, options),\n      flatten: true,\n      getShadowRoot: options.getShadowRoot\n    });\n  } else {\n    candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorFocusable.bind(null, options));\n  }\n  return candidates;\n};\nvar isTabbable = function isTabbable(node, options) {\n  options = options || {};\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (matches.call(node, candidateSelector) === false) {\n    return false;\n  }\n  return isNodeMatchingSelectorTabbable(options, node);\n};\nvar focusableCandidateSelector = /* #__PURE__ */candidateSelectors.concat('iframe').join(',');\nvar isFocusable = function isFocusable(node, options) {\n  options = options || {};\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (matches.call(node, focusableCandidateSelector) === false) {\n    return false;\n  }\n  return isNodeMatchingSelectorFocusable(options, node);\n};\n\nexport { focusable, getTabIndex, isFocusable, isTabbable, tabbable };\n//# sourceMappingURL=index.esm.js.map\n","/*!\n* focus-trap 7.6.6\n* @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE\n*/\nimport { tabbable, focusable, isTabbable, getTabIndex, isFocusable } from 'tabbable';\n\nfunction _arrayLikeToArray(r, a) {\n  (null == a || a > r.length) && (a = r.length);\n  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];\n  return n;\n}\nfunction _arrayWithoutHoles(r) {\n  if (Array.isArray(r)) return _arrayLikeToArray(r);\n}\nfunction _defineProperty(e, r, t) {\n  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {\n    value: t,\n    enumerable: true,\n    configurable: true,\n    writable: true\n  }) : e[r] = t, e;\n}\nfunction _iterableToArray(r) {\n  if (\"undefined\" != typeof Symbol && null != r[Symbol.iterator] || null != r[\"@@iterator\"]) return Array.from(r);\n}\nfunction _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nfunction ownKeys(e, r) {\n  var t = Object.keys(e);\n  if (Object.getOwnPropertySymbols) {\n    var o = Object.getOwnPropertySymbols(e);\n    r && (o = o.filter(function (r) {\n      return Object.getOwnPropertyDescriptor(e, r).enumerable;\n    })), t.push.apply(t, o);\n  }\n  return t;\n}\nfunction _objectSpread2(e) {\n  for (var r = 1; r < arguments.length; r++) {\n    var t = null != arguments[r] ? arguments[r] : {};\n    r % 2 ? ownKeys(Object(t), true).forEach(function (r) {\n      _defineProperty(e, r, t[r]);\n    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {\n      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));\n    });\n  }\n  return e;\n}\nfunction _toConsumableArray(r) {\n  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();\n}\nfunction _toPrimitive(t, r) {\n  if (\"object\" != typeof t || !t) return t;\n  var e = t[Symbol.toPrimitive];\n  if (void 0 !== e) {\n    var i = e.call(t, r);\n    if (\"object\" != typeof i) return i;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (\"string\" === r ? String : Number)(t);\n}\nfunction _toPropertyKey(t) {\n  var i = _toPrimitive(t, \"string\");\n  return \"symbol\" == typeof i ? i : i + \"\";\n}\nfunction _unsupportedIterableToArray(r, a) {\n  if (r) {\n    if (\"string\" == typeof r) return _arrayLikeToArray(r, a);\n    var t = {}.toString.call(r).slice(8, -1);\n    return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;\n  }\n}\n\nvar activeFocusTraps = {\n  activateTrap: function activateTrap(trapStack, trap) {\n    if (trapStack.length > 0) {\n      var activeTrap = trapStack[trapStack.length - 1];\n      if (activeTrap !== trap) {\n        activeTrap._setPausedState(true);\n      }\n    }\n    var trapIndex = trapStack.indexOf(trap);\n    if (trapIndex === -1) {\n      trapStack.push(trap);\n    } else {\n      // move this existing trap to the front of the queue\n      trapStack.splice(trapIndex, 1);\n      trapStack.push(trap);\n    }\n  },\n  deactivateTrap: function deactivateTrap(trapStack, trap) {\n    var trapIndex = trapStack.indexOf(trap);\n    if (trapIndex !== -1) {\n      trapStack.splice(trapIndex, 1);\n    }\n    if (trapStack.length > 0 && !trapStack[trapStack.length - 1]._isManuallyPaused()) {\n      trapStack[trapStack.length - 1]._setPausedState(false);\n    }\n  }\n};\nvar isSelectableInput = function isSelectableInput(node) {\n  return node.tagName && node.tagName.toLowerCase() === 'input' && typeof node.select === 'function';\n};\nvar isEscapeEvent = function isEscapeEvent(e) {\n  return (e === null || e === void 0 ? void 0 : e.key) === 'Escape' || (e === null || e === void 0 ? void 0 : e.key) === 'Esc' || (e === null || e === void 0 ? void 0 : e.keyCode) === 27;\n};\nvar isTabEvent = function isTabEvent(e) {\n  return (e === null || e === void 0 ? void 0 : e.key) === 'Tab' || (e === null || e === void 0 ? void 0 : e.keyCode) === 9;\n};\n\n// checks for TAB by default\nvar isKeyForward = function isKeyForward(e) {\n  return isTabEvent(e) && !e.shiftKey;\n};\n\n// checks for SHIFT+TAB by default\nvar isKeyBackward = function isKeyBackward(e) {\n  return isTabEvent(e) && e.shiftKey;\n};\nvar delay = function delay(fn) {\n  return setTimeout(fn, 0);\n};\n\n/**\n * Get an option's value when it could be a plain value, or a handler that provides\n *  the value.\n * @param {*} value Option's value to check.\n * @param {...*} [params] Any parameters to pass to the handler, if `value` is a function.\n * @returns {*} The `value`, or the handler's returned value.\n */\nvar valueOrHandler = function valueOrHandler(value) {\n  for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    params[_key - 1] = arguments[_key];\n  }\n  return typeof value === 'function' ? value.apply(void 0, params) : value;\n};\nvar getActualTarget = function getActualTarget(event) {\n  // NOTE: If the trap is _inside_ a shadow DOM, event.target will always be the\n  //  shadow host. However, event.target.composedPath() will be an array of\n  //  nodes \"clicked\" from inner-most (the actual element inside the shadow) to\n  //  outer-most (the host HTML document). If we have access to composedPath(),\n  //  then use its first element; otherwise, fall back to event.target (and\n  //  this only works for an _open_ shadow DOM; otherwise,\n  //  composedPath()[0] === event.target always).\n  return event.target.shadowRoot && typeof event.composedPath === 'function' ? event.composedPath()[0] : event.target;\n};\n\n// NOTE: this must be _outside_ `createFocusTrap()` to make sure all traps in this\n//  current instance use the same stack if `userOptions.trapStack` isn't specified\nvar internalTrapStack = [];\nvar createFocusTrap = function createFocusTrap(elements, userOptions) {\n  // SSR: a live trap shouldn't be created in this type of environment so this\n  //  should be safe code to execute if the `document` option isn't specified\n  var doc = (userOptions === null || userOptions === void 0 ? void 0 : userOptions.document) || document;\n  var trapStack = (userOptions === null || userOptions === void 0 ? void 0 : userOptions.trapStack) || internalTrapStack;\n  var config = _objectSpread2({\n    returnFocusOnDeactivate: true,\n    escapeDeactivates: true,\n    delayInitialFocus: true,\n    isKeyForward: isKeyForward,\n    isKeyBackward: isKeyBackward\n  }, userOptions);\n  var state = {\n    // containers given to createFocusTrap()\n    // @type {Array<HTMLElement>}\n    containers: [],\n    // list of objects identifying tabbable nodes in `containers` in the trap\n    // NOTE: it's possible that a group has no tabbable nodes if nodes get removed while the trap\n    //  is active, but the trap should never get to a state where there isn't at least one group\n    //  with at least one tabbable node in it (that would lead to an error condition that would\n    //  result in an error being thrown)\n    // @type {Array<{\n    //   container: HTMLElement,\n    //   tabbableNodes: Array<HTMLElement>, // empty if none\n    //   focusableNodes: Array<HTMLElement>, // empty if none\n    //   posTabIndexesFound: boolean,\n    //   firstTabbableNode: HTMLElement|undefined,\n    //   lastTabbableNode: HTMLElement|undefined,\n    //   firstDomTabbableNode: HTMLElement|undefined,\n    //   lastDomTabbableNode: HTMLElement|undefined,\n    //   nextTabbableNode: (node: HTMLElement, forward: boolean) => HTMLElement|undefined\n    // }>}\n    containerGroups: [],\n    // same order/length as `containers` list\n\n    // references to objects in `containerGroups`, but only those that actually have\n    //  tabbable nodes in them\n    // NOTE: same order as `containers` and `containerGroups`, but __not necessarily__\n    //  the same length\n    tabbableGroups: [],\n    nodeFocusedBeforeActivation: null,\n    mostRecentlyFocusedNode: null,\n    active: false,\n    paused: false,\n    manuallyPaused: false,\n    // timer ID for when delayInitialFocus is true and initial focus in this trap\n    //  has been delayed during activation\n    delayInitialFocusTimer: undefined,\n    // the most recent KeyboardEvent for the configured nav key (typically [SHIFT+]TAB), if any\n    recentNavEvent: undefined\n  };\n  var trap; // eslint-disable-line prefer-const -- some private functions reference it, and its methods reference private functions, so we must declare here and define later\n\n  /**\n   * Gets a configuration option value.\n   * @param {Object|undefined} configOverrideOptions If true, and option is defined in this set,\n   *  value will be taken from this object. Otherwise, value will be taken from base configuration.\n   * @param {string} optionName Name of the option whose value is sought.\n   * @param {string|undefined} [configOptionName] Name of option to use __instead of__ `optionName`\n   *  IIF `configOverrideOptions` is not defined. Otherwise, `optionName` is used.\n   */\n  var getOption = function getOption(configOverrideOptions, optionName, configOptionName) {\n    return configOverrideOptions && configOverrideOptions[optionName] !== undefined ? configOverrideOptions[optionName] : config[configOptionName || optionName];\n  };\n\n  /**\n   * Finds the index of the container that contains the element.\n   * @param {HTMLElement} element\n   * @param {Event} [event] If available, and `element` isn't directly found in any container,\n   *  the event's composed path is used to see if includes any known trap containers in the\n   *  case where the element is inside a Shadow DOM.\n   * @returns {number} Index of the container in either `state.containers` or\n   *  `state.containerGroups` (the order/length of these lists are the same); -1\n   *  if the element isn't found.\n   */\n  var findContainerIndex = function findContainerIndex(element, event) {\n    var composedPath = typeof (event === null || event === void 0 ? void 0 : event.composedPath) === 'function' ? event.composedPath() : undefined;\n    // NOTE: search `containerGroups` because it's possible a group contains no tabbable\n    //  nodes, but still contains focusable nodes (e.g. if they all have `tabindex=-1`)\n    //  and we still need to find the element in there\n    return state.containerGroups.findIndex(function (_ref) {\n      var container = _ref.container,\n        tabbableNodes = _ref.tabbableNodes;\n      return container.contains(element) || (// fall back to explicit tabbable search which will take into consideration any\n      //  web components if the `tabbableOptions.getShadowRoot` option was used for\n      //  the trap, enabling shadow DOM support in tabbable (`Node.contains()` doesn't\n      //  look inside web components even if open)\n      composedPath === null || composedPath === void 0 ? void 0 : composedPath.includes(container)) || tabbableNodes.find(function (node) {\n        return node === element;\n      });\n    });\n  };\n\n  /**\n   * Gets the node for the given option, which is expected to be an option that\n   *  can be either a DOM node, a string that is a selector to get a node, `false`\n   *  (if a node is explicitly NOT given), or a function that returns any of these\n   *  values.\n   * @param {string} optionName\n   * @param {Object} options\n   * @param {boolean} [options.hasFallback] True if the option could be a selector string\n   *  and the option allows for a fallback scenario in the case where the selector is\n   *  valid but does not match a node (i.e. the queried node doesn't exist in the DOM).\n   * @param {Array} [options.params] Params to pass to the option if it's a function.\n   * @returns {undefined | null | false | HTMLElement | SVGElement} Returns\n   *  `undefined` if the option is not specified; `null` if the option didn't resolve\n   *  to a node but `options.hasFallback=true`, `false` if the option resolved to `false`\n   *  (node explicitly not given); otherwise, the resolved DOM node.\n   * @throws {Error} If the option is set, not `false`, and is not, or does not\n   *  resolve to a node, unless the option is a selector string and `options.hasFallback=true`.\n   */\n  var getNodeForOption = function getNodeForOption(optionName) {\n    var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n      _ref2$hasFallback = _ref2.hasFallback,\n      hasFallback = _ref2$hasFallback === void 0 ? false : _ref2$hasFallback,\n      _ref2$params = _ref2.params,\n      params = _ref2$params === void 0 ? [] : _ref2$params;\n    var optionValue = config[optionName];\n    if (typeof optionValue === 'function') {\n      optionValue = optionValue.apply(void 0, _toConsumableArray(params));\n    }\n    if (optionValue === true) {\n      optionValue = undefined; // use default value\n    }\n    if (!optionValue) {\n      if (optionValue === undefined || optionValue === false) {\n        return optionValue;\n      }\n      // else, empty string (invalid), null (invalid), 0 (invalid)\n\n      throw new Error(\"`\".concat(optionName, \"` was specified but was not a node, or did not return a node\"));\n    }\n    var node = optionValue; // could be HTMLElement, SVGElement, or non-empty string at this point\n\n    if (typeof optionValue === 'string') {\n      try {\n        node = doc.querySelector(optionValue); // resolve to node, or null if fails\n      } catch (err) {\n        throw new Error(\"`\".concat(optionName, \"` appears to be an invalid selector; error=\\\"\").concat(err.message, \"\\\"\"));\n      }\n      if (!node) {\n        if (!hasFallback) {\n          throw new Error(\"`\".concat(optionName, \"` as selector refers to no known node\"));\n        }\n        // else, `node` MUST be `null` because that's what `Document.querySelector()` returns\n        //  if the selector is valid but doesn't match anything\n      }\n    }\n    return node;\n  };\n  var getInitialFocusNode = function getInitialFocusNode() {\n    var node = getNodeForOption('initialFocus', {\n      hasFallback: true\n    });\n\n    // false explicitly indicates we want no initialFocus at all\n    if (node === false) {\n      return false;\n    }\n    if (node === undefined || node && !isFocusable(node, config.tabbableOptions)) {\n      // option not specified nor focusable: use fallback options\n      if (findContainerIndex(doc.activeElement) >= 0) {\n        node = doc.activeElement;\n      } else {\n        var firstTabbableGroup = state.tabbableGroups[0];\n        var firstTabbableNode = firstTabbableGroup && firstTabbableGroup.firstTabbableNode;\n\n        // NOTE: `fallbackFocus` option function cannot return `false` (not supported)\n        node = firstTabbableNode || getNodeForOption('fallbackFocus');\n      }\n    } else if (node === null) {\n      // option is a VALID selector string that doesn't yield a node: use the `fallbackFocus`\n      //  option instead of the default behavior when the option isn't specified at all\n      node = getNodeForOption('fallbackFocus');\n    }\n    if (!node) {\n      throw new Error('Your focus-trap needs to have at least one focusable element');\n    }\n    return node;\n  };\n  var updateTabbableNodes = function updateTabbableNodes() {\n    state.containerGroups = state.containers.map(function (container) {\n      var tabbableNodes = tabbable(container, config.tabbableOptions);\n\n      // NOTE: if we have tabbable nodes, we must have focusable nodes; focusable nodes\n      //  are a superset of tabbable nodes since nodes with negative `tabindex` attributes\n      //  are focusable but not tabbable\n      var focusableNodes = focusable(container, config.tabbableOptions);\n      var firstTabbableNode = tabbableNodes.length > 0 ? tabbableNodes[0] : undefined;\n      var lastTabbableNode = tabbableNodes.length > 0 ? tabbableNodes[tabbableNodes.length - 1] : undefined;\n      var firstDomTabbableNode = focusableNodes.find(function (node) {\n        return isTabbable(node);\n      });\n      var lastDomTabbableNode = focusableNodes.slice().reverse().find(function (node) {\n        return isTabbable(node);\n      });\n      var posTabIndexesFound = !!tabbableNodes.find(function (node) {\n        return getTabIndex(node) > 0;\n      });\n      return {\n        container: container,\n        tabbableNodes: tabbableNodes,\n        focusableNodes: focusableNodes,\n        /** True if at least one node with positive `tabindex` was found in this container. */\n        posTabIndexesFound: posTabIndexesFound,\n        /** First tabbable node in container, __tabindex__ order; `undefined` if none. */\n        firstTabbableNode: firstTabbableNode,\n        /** Last tabbable node in container, __tabindex__ order; `undefined` if none. */\n        lastTabbableNode: lastTabbableNode,\n        // NOTE: DOM order is NOT NECESSARILY \"document position\" order, but figuring that out\n        //  would require more than just https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition\n        //  because that API doesn't work with Shadow DOM as well as it should (@see\n        //  https://github.com/whatwg/dom/issues/320) and since this first/last is only needed, so far,\n        //  to address an edge case related to positive tabindex support, this seems like a much easier,\n        //  \"close enough most of the time\" alternative for positive tabindexes which should generally\n        //  be avoided anyway...\n        /** First tabbable node in container, __DOM__ order; `undefined` if none. */\n        firstDomTabbableNode: firstDomTabbableNode,\n        /** Last tabbable node in container, __DOM__ order; `undefined` if none. */\n        lastDomTabbableNode: lastDomTabbableNode,\n        /**\n         * Finds the __tabbable__ node that follows the given node in the specified direction,\n         *  in this container, if any.\n         * @param {HTMLElement} node\n         * @param {boolean} [forward] True if going in forward tab order; false if going\n         *  in reverse.\n         * @returns {HTMLElement|undefined} The next tabbable node, if any.\n         */\n        nextTabbableNode: function nextTabbableNode(node) {\n          var forward = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n          var nodeIdx = tabbableNodes.indexOf(node);\n          if (nodeIdx < 0) {\n            // either not tabbable nor focusable, or was focused but not tabbable (negative tabindex):\n            //  since `node` should at least have been focusable, we assume that's the case and mimic\n            //  what browsers do, which is set focus to the next node in __document position order__,\n            //  regardless of positive tabindexes, if any -- and for reasons explained in the NOTE\n            //  above related to `firstDomTabbable` and `lastDomTabbable` properties, we fall back to\n            //  basic DOM order\n            if (forward) {\n              return focusableNodes.slice(focusableNodes.indexOf(node) + 1).find(function (el) {\n                return isTabbable(el);\n              });\n            }\n            return focusableNodes.slice(0, focusableNodes.indexOf(node)).reverse().find(function (el) {\n              return isTabbable(el);\n            });\n          }\n          return tabbableNodes[nodeIdx + (forward ? 1 : -1)];\n        }\n      };\n    });\n    state.tabbableGroups = state.containerGroups.filter(function (group) {\n      return group.tabbableNodes.length > 0;\n    });\n\n    // throw if no groups have tabbable nodes and we don't have a fallback focus node either\n    if (state.tabbableGroups.length <= 0 && !getNodeForOption('fallbackFocus') // returning false not supported for this option\n    ) {\n      throw new Error('Your focus-trap must have at least one container with at least one tabbable node in it at all times');\n    }\n\n    // NOTE: Positive tabindexes are only properly supported in single-container traps because\n    //  doing it across multiple containers where tabindexes could be all over the place\n    //  would require Tabbable to support multiple containers, would require additional\n    //  specialized Shadow DOM support, and would require Tabbable's multi-container support\n    //  to look at those containers in document position order rather than user-provided\n    //  order (as they are treated in Focus-trap, for legacy reasons). See discussion on\n    //  https://github.com/focus-trap/focus-trap/issues/375 for more details.\n    if (state.containerGroups.find(function (g) {\n      return g.posTabIndexesFound;\n    }) && state.containerGroups.length > 1) {\n      throw new Error(\"At least one node with a positive tabindex was found in one of your focus-trap's multiple containers. Positive tabindexes are only supported in single-container focus-traps.\");\n    }\n  };\n\n  /**\n   * Gets the current activeElement. If it's a web-component and has open shadow-root\n   * it will recursively search inside shadow roots for the \"true\" activeElement.\n   *\n   * @param {Document | ShadowRoot} el\n   *\n   * @returns {HTMLElement} The element that currently has the focus\n   **/\n  var _getActiveElement = function getActiveElement(el) {\n    var activeElement = el.activeElement;\n    if (!activeElement) {\n      return;\n    }\n    if (activeElement.shadowRoot && activeElement.shadowRoot.activeElement !== null) {\n      return _getActiveElement(activeElement.shadowRoot);\n    }\n    return activeElement;\n  };\n  var _tryFocus = function tryFocus(node) {\n    if (node === false) {\n      return;\n    }\n    if (node === _getActiveElement(document)) {\n      return;\n    }\n    if (!node || !node.focus) {\n      _tryFocus(getInitialFocusNode());\n      return;\n    }\n    node.focus({\n      preventScroll: !!config.preventScroll\n    });\n    // NOTE: focus() API does not trigger focusIn event so set MRU node manually\n    state.mostRecentlyFocusedNode = node;\n    if (isSelectableInput(node)) {\n      node.select();\n    }\n  };\n  var getReturnFocusNode = function getReturnFocusNode(previousActiveElement) {\n    var node = getNodeForOption('setReturnFocus', {\n      params: [previousActiveElement]\n    });\n    return node ? node : node === false ? false : previousActiveElement;\n  };\n\n  /**\n   * Finds the next node (in either direction) where focus should move according to a\n   *  keyboard focus-in event.\n   * @param {Object} params\n   * @param {Node} [params.target] Known target __from which__ to navigate, if any.\n   * @param {KeyboardEvent|FocusEvent} [params.event] Event to use if `target` isn't known (event\n   *  will be used to determine the `target`). Ignored if `target` is specified.\n   * @param {boolean} [params.isBackward] True if focus should move backward.\n   * @returns {Node|undefined} The next node, or `undefined` if a next node couldn't be\n   *  determined given the current state of the trap.\n   */\n  var findNextNavNode = function findNextNavNode(_ref3) {\n    var target = _ref3.target,\n      event = _ref3.event,\n      _ref3$isBackward = _ref3.isBackward,\n      isBackward = _ref3$isBackward === void 0 ? false : _ref3$isBackward;\n    target = target || getActualTarget(event);\n    updateTabbableNodes();\n    var destinationNode = null;\n    if (state.tabbableGroups.length > 0) {\n      // make sure the target is actually contained in a group\n      // NOTE: the target may also be the container itself if it's focusable\n      //  with tabIndex='-1' and was given initial focus\n      var containerIndex = findContainerIndex(target, event);\n      var containerGroup = containerIndex >= 0 ? state.containerGroups[containerIndex] : undefined;\n      if (containerIndex < 0) {\n        // target not found in any group: quite possible focus has escaped the trap,\n        //  so bring it back into...\n        if (isBackward) {\n          // ...the last node in the last group\n          destinationNode = state.tabbableGroups[state.tabbableGroups.length - 1].lastTabbableNode;\n        } else {\n          // ...the first node in the first group\n          destinationNode = state.tabbableGroups[0].firstTabbableNode;\n        }\n      } else if (isBackward) {\n        // REVERSE\n\n        // is the target the first tabbable node in a group?\n        var startOfGroupIndex = state.tabbableGroups.findIndex(function (_ref4) {\n          var firstTabbableNode = _ref4.firstTabbableNode;\n          return target === firstTabbableNode;\n        });\n        if (startOfGroupIndex < 0 && (containerGroup.container === target || isFocusable(target, config.tabbableOptions) && !isTabbable(target, config.tabbableOptions) && !containerGroup.nextTabbableNode(target, false))) {\n          // an exception case where the target is either the container itself, or\n          //  a non-tabbable node that was given focus (i.e. tabindex is negative\n          //  and user clicked on it or node was programmatically given focus)\n          //  and is not followed by any other tabbable node, in which\n          //  case, we should handle shift+tab as if focus were on the container's\n          //  first tabbable node, and go to the last tabbable node of the LAST group\n          startOfGroupIndex = containerIndex;\n        }\n        if (startOfGroupIndex >= 0) {\n          // YES: then shift+tab should go to the last tabbable node in the\n          //  previous group (and wrap around to the last tabbable node of\n          //  the LAST group if it's the first tabbable node of the FIRST group)\n          var destinationGroupIndex = startOfGroupIndex === 0 ? state.tabbableGroups.length - 1 : startOfGroupIndex - 1;\n          var destinationGroup = state.tabbableGroups[destinationGroupIndex];\n          destinationNode = getTabIndex(target) >= 0 ? destinationGroup.lastTabbableNode : destinationGroup.lastDomTabbableNode;\n        } else if (!isTabEvent(event)) {\n          // user must have customized the nav keys so we have to move focus manually _within_\n          //  the active group: do this based on the order determined by tabbable()\n          destinationNode = containerGroup.nextTabbableNode(target, false);\n        }\n      } else {\n        // FORWARD\n\n        // is the target the last tabbable node in a group?\n        var lastOfGroupIndex = state.tabbableGroups.findIndex(function (_ref5) {\n          var lastTabbableNode = _ref5.lastTabbableNode;\n          return target === lastTabbableNode;\n        });\n        if (lastOfGroupIndex < 0 && (containerGroup.container === target || isFocusable(target, config.tabbableOptions) && !isTabbable(target, config.tabbableOptions) && !containerGroup.nextTabbableNode(target))) {\n          // an exception case where the target is the container itself, or\n          //  a non-tabbable node that was given focus (i.e. tabindex is negative\n          //  and user clicked on it or node was programmatically given focus)\n          //  and is not followed by any other tabbable node, in which\n          //  case, we should handle tab as if focus were on the container's\n          //  last tabbable node, and go to the first tabbable node of the FIRST group\n          lastOfGroupIndex = containerIndex;\n        }\n        if (lastOfGroupIndex >= 0) {\n          // YES: then tab should go to the first tabbable node in the next\n          //  group (and wrap around to the first tabbable node of the FIRST\n          //  group if it's the last tabbable node of the LAST group)\n          var _destinationGroupIndex = lastOfGroupIndex === state.tabbableGroups.length - 1 ? 0 : lastOfGroupIndex + 1;\n          var _destinationGroup = state.tabbableGroups[_destinationGroupIndex];\n          destinationNode = getTabIndex(target) >= 0 ? _destinationGroup.firstTabbableNode : _destinationGroup.firstDomTabbableNode;\n        } else if (!isTabEvent(event)) {\n          // user must have customized the nav keys so we have to move focus manually _within_\n          //  the active group: do this based on the order determined by tabbable()\n          destinationNode = containerGroup.nextTabbableNode(target);\n        }\n      }\n    } else {\n      // no groups available\n      // NOTE: the fallbackFocus option does not support returning false to opt-out\n      destinationNode = getNodeForOption('fallbackFocus');\n    }\n    return destinationNode;\n  };\n\n  // This needs to be done on mousedown and touchstart instead of click\n  // so that it precedes the focus event.\n  var checkPointerDown = function checkPointerDown(e) {\n    var target = getActualTarget(e);\n    if (findContainerIndex(target, e) >= 0) {\n      // allow the click since it ocurred inside the trap\n      return;\n    }\n    if (valueOrHandler(config.clickOutsideDeactivates, e)) {\n      // immediately deactivate the trap\n      trap.deactivate({\n        // NOTE: by setting `returnFocus: false`, deactivate() will do nothing,\n        //  which will result in the outside click setting focus to the node\n        //  that was clicked (and if not focusable, to \"nothing\"); by setting\n        //  `returnFocus: true`, we'll attempt to re-focus the node originally-focused\n        //  on activation (or the configured `setReturnFocus` node), whether the\n        //  outside click was on a focusable node or not\n        returnFocus: config.returnFocusOnDeactivate\n      });\n      return;\n    }\n\n    // This is needed for mobile devices.\n    // (If we'll only let `click` events through,\n    // then on mobile they will be blocked anyways if `touchstart` is blocked.)\n    if (valueOrHandler(config.allowOutsideClick, e)) {\n      // allow the click outside the trap to take place\n      return;\n    }\n\n    // otherwise, prevent the click\n    e.preventDefault();\n  };\n\n  // In case focus escapes the trap for some strange reason, pull it back in.\n  // NOTE: the focusIn event is NOT cancelable, so if focus escapes, it may cause unexpected\n  //  scrolling if the node that got focused was out of view; there's nothing we can do to\n  //  prevent that from happening by the time we discover that focus escaped\n  var checkFocusIn = function checkFocusIn(event) {\n    var target = getActualTarget(event);\n    var targetContained = findContainerIndex(target, event) >= 0;\n\n    // In Firefox when you Tab out of an iframe the Document is briefly focused.\n    if (targetContained || target instanceof Document) {\n      if (targetContained) {\n        state.mostRecentlyFocusedNode = target;\n      }\n    } else {\n      // escaped! pull it back in to where it just left\n      event.stopImmediatePropagation();\n\n      // focus will escape if the MRU node had a positive tab index and user tried to nav forward;\n      //  it will also escape if the MRU node had a 0 tab index and user tried to nav backward\n      //  toward a node with a positive tab index\n      var nextNode; // next node to focus, if we find one\n      var navAcrossContainers = true;\n      if (state.mostRecentlyFocusedNode) {\n        if (getTabIndex(state.mostRecentlyFocusedNode) > 0) {\n          // MRU container index must be >=0 otherwise we wouldn't have it as an MRU node...\n          var mruContainerIdx = findContainerIndex(state.mostRecentlyFocusedNode);\n          // there MAY not be any tabbable nodes in the container if there are at least 2 containers\n          //  and the MRU node is focusable but not tabbable (focus-trap requires at least 1 container\n          //  with at least one tabbable node in order to function, so this could be the other container\n          //  with nothing tabbable in it)\n          var tabbableNodes = state.containerGroups[mruContainerIdx].tabbableNodes;\n          if (tabbableNodes.length > 0) {\n            // MRU tab index MAY not be found if the MRU node is focusable but not tabbable\n            var mruTabIdx = tabbableNodes.findIndex(function (node) {\n              return node === state.mostRecentlyFocusedNode;\n            });\n            if (mruTabIdx >= 0) {\n              if (config.isKeyForward(state.recentNavEvent)) {\n                if (mruTabIdx + 1 < tabbableNodes.length) {\n                  nextNode = tabbableNodes[mruTabIdx + 1];\n                  navAcrossContainers = false;\n                }\n                // else, don't wrap within the container as focus should move to next/previous\n                //  container\n              } else {\n                if (mruTabIdx - 1 >= 0) {\n                  nextNode = tabbableNodes[mruTabIdx - 1];\n                  navAcrossContainers = false;\n                }\n                // else, don't wrap within the container as focus should move to next/previous\n                //  container\n              }\n              // else, don't find in container order without considering direction too\n            }\n          }\n          // else, no tabbable nodes in that container (which means we must have at least one other\n          //  container with at least one tabbable node in it, otherwise focus-trap would've thrown\n          //  an error the last time updateTabbableNodes() was run): find next node among all known\n          //  containers\n        } else {\n          // check to see if there's at least one tabbable node with a positive tab index inside\n          //  the trap because focus seems to escape when navigating backward from a tabbable node\n          //  with tabindex=0 when this is the case (instead of wrapping to the tabbable node with\n          //  the greatest positive tab index like it should)\n          if (!state.containerGroups.some(function (g) {\n            return g.tabbableNodes.some(function (n) {\n              return getTabIndex(n) > 0;\n            });\n          })) {\n            // no containers with tabbable nodes with positive tab indexes which means the focus\n            //  escaped for some other reason and we should just execute the fallback to the\n            //  MRU node or initial focus node, if any\n            navAcrossContainers = false;\n          }\n        }\n      } else {\n        // no MRU node means we're likely in some initial condition when the trap has just\n        //  been activated and initial focus hasn't been given yet, in which case we should\n        //  fall through to trying to focus the initial focus node, which is what should\n        //  happen below at this point in the logic\n        navAcrossContainers = false;\n      }\n      if (navAcrossContainers) {\n        nextNode = findNextNavNode({\n          // move FROM the MRU node, not event-related node (which will be the node that is\n          //  outside the trap causing the focus escape we're trying to fix)\n          target: state.mostRecentlyFocusedNode,\n          isBackward: config.isKeyBackward(state.recentNavEvent)\n        });\n      }\n      if (nextNode) {\n        _tryFocus(nextNode);\n      } else {\n        _tryFocus(state.mostRecentlyFocusedNode || getInitialFocusNode());\n      }\n    }\n    state.recentNavEvent = undefined; // clear\n  };\n\n  // Hijack key nav events on the first and last focusable nodes of the trap,\n  // in order to prevent focus from escaping. If it escapes for even a\n  // moment it can end up scrolling the page and causing confusion so we\n  // kind of need to capture the action at the keydown phase.\n  var checkKeyNav = function checkKeyNav(event) {\n    var isBackward = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n    state.recentNavEvent = event;\n    var destinationNode = findNextNavNode({\n      event: event,\n      isBackward: isBackward\n    });\n    if (destinationNode) {\n      if (isTabEvent(event)) {\n        // since tab natively moves focus, we wouldn't have a destination node unless we\n        //  were on the edge of a container and had to move to the next/previous edge, in\n        //  which case we want to prevent default to keep the browser from moving focus\n        //  to where it normally would\n        event.preventDefault();\n      }\n      _tryFocus(destinationNode);\n    }\n    // else, let the browser take care of [shift+]tab and move the focus\n  };\n  var checkTabKey = function checkTabKey(event) {\n    if (config.isKeyForward(event) || config.isKeyBackward(event)) {\n      checkKeyNav(event, config.isKeyBackward(event));\n    }\n  };\n\n  // we use a different event phase for the Escape key to allow canceling the event and checking for this in escapeDeactivates\n  var checkEscapeKey = function checkEscapeKey(event) {\n    if (isEscapeEvent(event) && valueOrHandler(config.escapeDeactivates, event) !== false) {\n      event.preventDefault();\n      trap.deactivate();\n    }\n  };\n  var checkClick = function checkClick(e) {\n    var target = getActualTarget(e);\n    if (findContainerIndex(target, e) >= 0) {\n      return;\n    }\n    if (valueOrHandler(config.clickOutsideDeactivates, e)) {\n      return;\n    }\n    if (valueOrHandler(config.allowOutsideClick, e)) {\n      return;\n    }\n    e.preventDefault();\n    e.stopImmediatePropagation();\n  };\n\n  //\n  // EVENT LISTENERS\n  //\n\n  var addListeners = function addListeners() {\n    if (!state.active) {\n      return;\n    }\n\n    // There can be only one listening focus trap at a time\n    activeFocusTraps.activateTrap(trapStack, trap);\n\n    // Delay ensures that the focused element doesn't capture the event\n    // that caused the focus trap activation.\n    state.delayInitialFocusTimer = config.delayInitialFocus ? delay(function () {\n      _tryFocus(getInitialFocusNode());\n    }) : _tryFocus(getInitialFocusNode());\n    doc.addEventListener('focusin', checkFocusIn, true);\n    doc.addEventListener('mousedown', checkPointerDown, {\n      capture: true,\n      passive: false\n    });\n    doc.addEventListener('touchstart', checkPointerDown, {\n      capture: true,\n      passive: false\n    });\n    doc.addEventListener('click', checkClick, {\n      capture: true,\n      passive: false\n    });\n    doc.addEventListener('keydown', checkTabKey, {\n      capture: true,\n      passive: false\n    });\n    doc.addEventListener('keydown', checkEscapeKey);\n    return trap;\n  };\n  var removeListeners = function removeListeners() {\n    if (!state.active) {\n      return;\n    }\n    doc.removeEventListener('focusin', checkFocusIn, true);\n    doc.removeEventListener('mousedown', checkPointerDown, true);\n    doc.removeEventListener('touchstart', checkPointerDown, true);\n    doc.removeEventListener('click', checkClick, true);\n    doc.removeEventListener('keydown', checkTabKey, true);\n    doc.removeEventListener('keydown', checkEscapeKey);\n    return trap;\n  };\n\n  //\n  // MUTATION OBSERVER\n  //\n\n  var checkDomRemoval = function checkDomRemoval(mutations) {\n    var isFocusedNodeRemoved = mutations.some(function (mutation) {\n      var removedNodes = Array.from(mutation.removedNodes);\n      return removedNodes.some(function (node) {\n        return node === state.mostRecentlyFocusedNode;\n      });\n    });\n\n    // If the currently focused is removed then browsers will move focus to the\n    // <body> element. If this happens, try to move focus back into the trap.\n    if (isFocusedNodeRemoved) {\n      _tryFocus(getInitialFocusNode());\n    }\n  };\n\n  // Use MutationObserver - if supported - to detect if focused node is removed\n  // from the DOM.\n  var mutationObserver = typeof window !== 'undefined' && 'MutationObserver' in window ? new MutationObserver(checkDomRemoval) : undefined;\n  var updateObservedNodes = function updateObservedNodes() {\n    if (!mutationObserver) {\n      return;\n    }\n    mutationObserver.disconnect();\n    if (state.active && !state.paused) {\n      state.containers.map(function (container) {\n        mutationObserver.observe(container, {\n          subtree: true,\n          childList: true\n        });\n      });\n    }\n  };\n\n  //\n  // TRAP DEFINITION\n  //\n\n  trap = {\n    get active() {\n      return state.active;\n    },\n    get paused() {\n      return state.paused;\n    },\n    activate: function activate(activateOptions) {\n      if (state.active) {\n        return this;\n      }\n      var onActivate = getOption(activateOptions, 'onActivate');\n      var onPostActivate = getOption(activateOptions, 'onPostActivate');\n      var checkCanFocusTrap = getOption(activateOptions, 'checkCanFocusTrap');\n      if (!checkCanFocusTrap) {\n        updateTabbableNodes();\n      }\n      state.active = true;\n      state.paused = false;\n      state.nodeFocusedBeforeActivation = _getActiveElement(doc);\n      onActivate === null || onActivate === void 0 || onActivate();\n      var finishActivation = function finishActivation() {\n        if (checkCanFocusTrap) {\n          updateTabbableNodes();\n        }\n        addListeners();\n        updateObservedNodes();\n        onPostActivate === null || onPostActivate === void 0 || onPostActivate();\n      };\n      if (checkCanFocusTrap) {\n        checkCanFocusTrap(state.containers.concat()).then(finishActivation, finishActivation);\n        return this;\n      }\n      finishActivation();\n      return this;\n    },\n    deactivate: function deactivate(deactivateOptions) {\n      if (!state.active) {\n        return this;\n      }\n      var options = _objectSpread2({\n        onDeactivate: config.onDeactivate,\n        onPostDeactivate: config.onPostDeactivate,\n        checkCanReturnFocus: config.checkCanReturnFocus\n      }, deactivateOptions);\n      clearTimeout(state.delayInitialFocusTimer); // noop if undefined\n      state.delayInitialFocusTimer = undefined;\n      removeListeners();\n      state.active = false;\n      state.paused = false;\n      updateObservedNodes();\n      activeFocusTraps.deactivateTrap(trapStack, trap);\n      var onDeactivate = getOption(options, 'onDeactivate');\n      var onPostDeactivate = getOption(options, 'onPostDeactivate');\n      var checkCanReturnFocus = getOption(options, 'checkCanReturnFocus');\n      var returnFocus = getOption(options, 'returnFocus', 'returnFocusOnDeactivate');\n      onDeactivate === null || onDeactivate === void 0 || onDeactivate();\n      var finishDeactivation = function finishDeactivation() {\n        delay(function () {\n          if (returnFocus) {\n            _tryFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation));\n          }\n          onPostDeactivate === null || onPostDeactivate === void 0 || onPostDeactivate();\n        });\n      };\n      if (returnFocus && checkCanReturnFocus) {\n        checkCanReturnFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation)).then(finishDeactivation, finishDeactivation);\n        return this;\n      }\n      finishDeactivation();\n      return this;\n    },\n    pause: function pause(pauseOptions) {\n      if (!state.active) {\n        return this;\n      }\n      state.manuallyPaused = true;\n      return this._setPausedState(true, pauseOptions);\n    },\n    unpause: function unpause(unpauseOptions) {\n      if (!state.active) {\n        return this;\n      }\n      state.manuallyPaused = false;\n      if (trapStack[trapStack.length - 1] !== this) {\n        return this;\n      }\n      return this._setPausedState(false, unpauseOptions);\n    },\n    updateContainerElements: function updateContainerElements(containerElements) {\n      var elementsAsArray = [].concat(containerElements).filter(Boolean);\n      state.containers = elementsAsArray.map(function (element) {\n        return typeof element === 'string' ? doc.querySelector(element) : element;\n      });\n      if (state.active) {\n        updateTabbableNodes();\n      }\n      updateObservedNodes();\n      return this;\n    }\n  };\n  Object.defineProperties(trap, {\n    _isManuallyPaused: {\n      value: function value() {\n        return state.manuallyPaused;\n      }\n    },\n    _setPausedState: {\n      value: function value(paused, options) {\n        if (state.paused === paused) {\n          return this;\n        }\n        state.paused = paused;\n        if (paused) {\n          var onPause = getOption(options, 'onPause');\n          var onPostPause = getOption(options, 'onPostPause');\n          onPause === null || onPause === void 0 || onPause();\n          removeListeners();\n          updateObservedNodes();\n          onPostPause === null || onPostPause === void 0 || onPostPause();\n        } else {\n          var onUnpause = getOption(options, 'onUnpause');\n          var onPostUnpause = getOption(options, 'onPostUnpause');\n          onUnpause === null || onUnpause === void 0 || onUnpause();\n          updateTabbableNodes();\n          addListeners();\n          updateObservedNodes();\n          onPostUnpause === null || onPostUnpause === void 0 || onPostUnpause();\n        }\n        return this;\n      }\n    }\n  });\n\n  // initialize container elements\n  trap.updateContainerElements(elements);\n  return trap;\n};\n\nexport { createFocusTrap };\n//# sourceMappingURL=focus-trap.esm.js.map\n","// Modified from Grail UI v0.9.6 (2023-06-10)\n// Source: https://github.com/grail-ui/grail-ui\n// https://github.com/grail-ui/grail-ui/tree/master/packages/grail-ui/src/focusTrap/focusTrap.ts\nimport { writable, readonly } from 'svelte/store';\nimport { createFocusTrap as _createFocusTrap } from 'focus-trap';\nexport function createFocusTrap(config = {}) {\n    let trap;\n    const { immediate, ...focusTrapOptions } = config;\n    const hasFocus = writable(false);\n    const isPaused = writable(false);\n    const activate = (opts) => trap?.activate(opts);\n    const deactivate = (opts) => {\n        trap?.deactivate(opts);\n    };\n    const pause = () => {\n        if (trap) {\n            trap.pause();\n            isPaused.set(true);\n        }\n    };\n    const unpause = () => {\n        if (trap) {\n            trap.unpause();\n            isPaused.set(false);\n        }\n    };\n    const useFocusTrap = (node) => {\n        trap = _createFocusTrap(node, {\n            ...focusTrapOptions,\n            onActivate() {\n                hasFocus.set(true);\n                config.onActivate?.();\n            },\n            onDeactivate() {\n                hasFocus.set(false);\n                config.onDeactivate?.();\n            },\n        });\n        if (immediate) {\n            activate();\n        }\n        return {\n            destroy() {\n                deactivate();\n                trap = undefined;\n            },\n        };\n    };\n    return {\n        useFocusTrap,\n        hasFocus: readonly(hasFocus),\n        isPaused: readonly(isPaused),\n        activate,\n        deactivate,\n        pause,\n        unpause,\n    };\n}\n","import { isElement, last, noop, sleep } from '../../helpers/index.js';\nimport { useInteractOutside } from '../index.js';\nconst visibleModals = [];\nexport const useModal = ((node, config) => {\n    let unsubInteractOutside = noop;\n    function removeNodeFromVisibleModals() {\n        const index = visibleModals.indexOf(node);\n        if (index >= 0) {\n            visibleModals.splice(index, 1);\n        }\n    }\n    function update(config) {\n        unsubInteractOutside();\n        const { open, onClose, shouldCloseOnInteractOutside, closeOnInteractOutside } = config;\n        sleep(100).then(() => {\n            if (open) {\n                visibleModals.push(node);\n            }\n            else {\n                removeNodeFromVisibleModals();\n            }\n        });\n        function isLastModal() {\n            return last(visibleModals) === node;\n        }\n        function closeModal() {\n            // we only want to call onClose if this is the topmost modal\n            if (isLastModal() && onClose) {\n                onClose();\n                removeNodeFromVisibleModals();\n            }\n        }\n        function onInteractOutsideStart(e) {\n            const target = e.target;\n            if (!isElement(target))\n                return;\n            if (target && isLastModal()) {\n                e.preventDefault();\n                e.stopPropagation();\n                e.stopImmediatePropagation();\n            }\n        }\n        function onInteractOutside(e) {\n            if (shouldCloseOnInteractOutside?.(e) && isLastModal()) {\n                e.preventDefault();\n                e.stopPropagation();\n                e.stopImmediatePropagation();\n                closeModal();\n            }\n        }\n        unsubInteractOutside = useInteractOutside(node, {\n            onInteractOutsideStart,\n            onInteractOutside: closeOnInteractOutside ? onInteractOutside : undefined,\n            enabled: open,\n        }).destroy;\n    }\n    update(config);\n    return {\n        update,\n        destroy() {\n            removeNodeFromVisibleModals();\n            unsubInteractOutside();\n        },\n    };\n});\n","import { addEventListener, isElement, executeCallbacks, noop, } from '../../helpers/index.js';\nexport const useInteractOutside = ((node, config) => {\n    let unsub = noop;\n    let unsubClick = noop;\n    let isPointerDown = false;\n    let isPointerDownInside = false;\n    let ignoreEmulatedMouseEvents = false;\n    function update(config) {\n        unsub();\n        unsubClick();\n        const { onInteractOutside, onInteractOutsideStart, enabled } = config;\n        if (!enabled)\n            return;\n        function onPointerDown(e) {\n            if (onInteractOutside && isValidEvent(e, node)) {\n                onInteractOutsideStart?.(e);\n            }\n            const target = e.target;\n            if (isElement(target) && isOrContainsTarget(node, target)) {\n                isPointerDownInside = true;\n            }\n            isPointerDown = true;\n        }\n        function triggerInteractOutside(e) {\n            onInteractOutside?.(e);\n        }\n        const documentObj = getOwnerDocument(node);\n        // Use pointer events if available, otherwise use mouse/touch events\n        if (typeof PointerEvent !== 'undefined') {\n            const onPointerUp = (e) => {\n                unsubClick();\n                const handler = (e) => {\n                    if (shouldTriggerInteractOutside(e)) {\n                        triggerInteractOutside(e);\n                    }\n                    resetPointerState();\n                };\n                /**\n                 * On touch devices, we need to wait for a click event because browsers implement\n                 * a delay between the time the user stops touching the display and when the\n                 * browser executes the click event. Without waiting for the click event, the\n                 * browser may execute events on other elements that should have been prevented.\n                 */\n                if (e.pointerType === 'touch') {\n                    unsubClick = addEventListener(documentObj, 'click', handler, {\n                        capture: true,\n                        once: true,\n                    });\n                    return;\n                }\n                handler(e);\n            };\n            unsub = executeCallbacks(addEventListener(documentObj, 'pointerdown', onPointerDown, true), addEventListener(documentObj, 'pointerup', onPointerUp, true));\n        }\n        else {\n            const onMouseUp = (e) => {\n                if (ignoreEmulatedMouseEvents) {\n                    ignoreEmulatedMouseEvents = false;\n                }\n                else if (shouldTriggerInteractOutside(e)) {\n                    triggerInteractOutside(e);\n                }\n                resetPointerState();\n            };\n            const onTouchEnd = (e) => {\n                ignoreEmulatedMouseEvents = true;\n                if (shouldTriggerInteractOutside(e)) {\n                    triggerInteractOutside(e);\n                }\n                resetPointerState();\n            };\n            unsub = executeCallbacks(addEventListener(documentObj, 'mousedown', onPointerDown, true), addEventListener(documentObj, 'mouseup', onMouseUp, true), addEventListener(documentObj, 'touchstart', onPointerDown, true), addEventListener(documentObj, 'touchend', onTouchEnd, true));\n        }\n    }\n    function shouldTriggerInteractOutside(e) {\n        if (isPointerDown && !isPointerDownInside && isValidEvent(e, node)) {\n            return true;\n        }\n        return false;\n    }\n    function resetPointerState() {\n        isPointerDown = false;\n        isPointerDownInside = false;\n    }\n    update(config);\n    return {\n        update,\n        destroy() {\n            unsub();\n            unsubClick();\n        },\n    };\n});\nfunction isValidEvent(e, node) {\n    if ('button' in e && e.button > 0)\n        return false;\n    const target = e.target;\n    if (!isElement(target))\n        return false;\n    // if the target is no longer in the document (e.g. it was removed) ignore it\n    const ownerDocument = target.ownerDocument;\n    if (!ownerDocument || !ownerDocument.documentElement.contains(target)) {\n        return false;\n    }\n    return node && !isOrContainsTarget(node, target);\n}\nfunction isOrContainsTarget(node, target) {\n    return node === target || node.contains(target);\n}\nfunction getOwnerDocument(el) {\n    return el?.ownerDocument ?? document;\n}\n","import { createFocusTrap, useEscapeKeydown, usePortal } from '../../internal/actions/index.js';\nimport { addMeltEventListener, makeElement, createElHelpers, effect, executeCallbacks, generateIds, getPortalDestination, handleFocus, isBrowser, isHTMLElement, kbd, noop, omit, overridable, removeScroll, styleToString, toWritableStores, portalAttr, } from '../../internal/helpers/index.js';\nimport { withGet } from '../../internal/helpers/withGet.js';\nimport { tick } from 'svelte';\nimport { derived, writable } from 'svelte/store';\nimport { useModal } from '../../internal/actions/modal/action.js';\nconst { name } = createElHelpers('dialog');\nconst defaults = {\n    preventScroll: true,\n    closeOnEscape: true,\n    closeOnOutsideClick: true,\n    role: 'dialog',\n    defaultOpen: false,\n    portal: undefined,\n    forceVisible: false,\n    openFocus: undefined,\n    closeFocus: undefined,\n    onOutsideClick: undefined,\n};\nexport const dialogIdParts = ['content', 'title', 'description'];\nexport function createDialog(props) {\n    const withDefaults = { ...defaults, ...props };\n    const options = toWritableStores(omit(withDefaults, 'ids'));\n    const { preventScroll, closeOnEscape, closeOnOutsideClick, role, portal, forceVisible, openFocus, closeFocus, onOutsideClick, } = options;\n    const activeTrigger = withGet.writable(null);\n    const ids = toWritableStores({\n        ...generateIds(dialogIdParts),\n        ...withDefaults.ids,\n    });\n    const openWritable = withDefaults.open ?? writable(withDefaults.defaultOpen);\n    const open = overridable(openWritable, withDefaults?.onOpenChange);\n    const isVisible = derived([open, forceVisible], ([$open, $forceVisible]) => {\n        return $open || $forceVisible;\n    });\n    let unsubScroll = noop;\n    function handleOpen(e) {\n        const el = e.currentTarget;\n        const triggerEl = e.currentTarget;\n        if (!isHTMLElement(el) || !isHTMLElement(triggerEl))\n            return;\n        open.set(true);\n        activeTrigger.set(triggerEl);\n    }\n    function handleClose() {\n        open.set(false);\n        handleFocus({\n            prop: closeFocus.get(),\n            defaultEl: activeTrigger.get(),\n        });\n    }\n    const trigger = makeElement(name('trigger'), {\n        stores: [open],\n        returned: ([$open]) => {\n            return {\n                'aria-haspopup': 'dialog',\n                'aria-expanded': $open,\n                type: 'button',\n            };\n        },\n        action: (node) => {\n            const unsub = executeCallbacks(addMeltEventListener(node, 'click', (e) => {\n                handleOpen(e);\n            }), addMeltEventListener(node, 'keydown', (e) => {\n                if (e.key !== kbd.ENTER && e.key !== kbd.SPACE)\n                    return;\n                e.preventDefault();\n                handleOpen(e);\n            }));\n            return {\n                destroy: unsub,\n            };\n        },\n    });\n    const overlay = makeElement(name('overlay'), {\n        stores: [isVisible, open],\n        returned: ([$isVisible, $open]) => {\n            return {\n                hidden: $isVisible ? undefined : true,\n                tabindex: -1,\n                style: styleToString({\n                    display: $isVisible ? undefined : 'none',\n                }),\n                'aria-hidden': true,\n                'data-state': $open ? 'open' : 'closed',\n            };\n        },\n        action: (node) => {\n            let unsubEscapeKeydown = noop;\n            if (closeOnEscape.get()) {\n                const escapeKeydown = useEscapeKeydown(node, {\n                    handler: () => {\n                        handleClose();\n                    },\n                });\n                if (escapeKeydown && escapeKeydown.destroy) {\n                    unsubEscapeKeydown = escapeKeydown.destroy;\n                }\n            }\n            return {\n                destroy() {\n                    unsubEscapeKeydown();\n                },\n            };\n        },\n    });\n    const content = makeElement(name('content'), {\n        stores: [isVisible, ids.content, ids.description, ids.title, open],\n        returned: ([$isVisible, $contentId, $descriptionId, $titleId, $open]) => {\n            return {\n                id: $contentId,\n                role: role.get(),\n                'aria-describedby': $descriptionId,\n                'aria-labelledby': $titleId,\n                'aria-modal': $isVisible ? 'true' : undefined,\n                'data-state': $open ? 'open' : 'closed',\n                tabindex: -1,\n                hidden: $isVisible ? undefined : true,\n                style: styleToString({\n                    display: $isVisible ? undefined : 'none',\n                }),\n            };\n        },\n        action: (node) => {\n            let activate = noop;\n            let deactivate = noop;\n            const destroy = executeCallbacks(effect([open, closeOnOutsideClick, closeOnEscape], ([$open, $closeOnOutsideClick, $closeOnEscape]) => {\n                if (!$open)\n                    return;\n                const focusTrap = createFocusTrap({\n                    immediate: false,\n                    escapeDeactivates: $closeOnEscape,\n                    clickOutsideDeactivates: $closeOnOutsideClick,\n                    allowOutsideClick: true,\n                    returnFocusOnDeactivate: false,\n                    fallbackFocus: node,\n                });\n                activate = focusTrap.activate;\n                deactivate = focusTrap.deactivate;\n                const ac = focusTrap.useFocusTrap(node);\n                if (ac && ac.destroy) {\n                    return ac.destroy;\n                }\n                else {\n                    return focusTrap.deactivate;\n                }\n            }), effect([closeOnOutsideClick, open], ([$closeOnOutsideClick, $open]) => {\n                return useModal(node, {\n                    open: $open,\n                    closeOnInteractOutside: $closeOnOutsideClick,\n                    onClose() {\n                        handleClose();\n                    },\n                    shouldCloseOnInteractOutside(e) {\n                        onOutsideClick.get()?.(e);\n                        if (e.defaultPrevented)\n                            return false;\n                        return true;\n                    },\n                }).destroy;\n            }), effect([closeOnEscape], ([$closeOnEscape]) => {\n                if (!$closeOnEscape)\n                    return noop;\n                return useEscapeKeydown(node, { handler: handleClose }).destroy;\n            }), effect([isVisible], ([$isVisible]) => {\n                tick().then(() => {\n                    if (!$isVisible) {\n                        deactivate();\n                    }\n                    else {\n                        activate();\n                    }\n                });\n            }));\n            return {\n                destroy: () => {\n                    unsubScroll();\n                    destroy();\n                },\n            };\n        },\n    });\n    const portalled = makeElement(name('portalled'), {\n        stores: portal,\n        returned: ($portal) => ({\n            'data-portal': portalAttr($portal),\n        }),\n        action: (node) => {\n            const unsubPortal = effect([portal], ([$portal]) => {\n                if ($portal === null)\n                    return noop;\n                const portalDestination = getPortalDestination(node, $portal);\n                if (portalDestination === null)\n                    return noop;\n                return usePortal(node, portalDestination).destroy;\n            });\n            return {\n                destroy() {\n                    unsubPortal();\n                },\n            };\n        },\n    });\n    const title = makeElement(name('title'), {\n        stores: [ids.title],\n        returned: ([$titleId]) => ({\n            id: $titleId,\n        }),\n    });\n    const description = makeElement(name('description'), {\n        stores: [ids.description],\n        returned: ([$descriptionId]) => ({\n            id: $descriptionId,\n        }),\n    });\n    const close = makeElement(name('close'), {\n        returned: () => ({\n            type: 'button',\n        }),\n        action: (node) => {\n            const unsub = executeCallbacks(addMeltEventListener(node, 'click', () => {\n                handleClose();\n            }), addMeltEventListener(node, 'keydown', (e) => {\n                if (e.key !== kbd.SPACE && e.key !== kbd.ENTER)\n                    return;\n                e.preventDefault();\n                handleClose();\n            }));\n            return {\n                destroy: unsub,\n            };\n        },\n    });\n    effect([open, preventScroll], ([$open, $preventScroll]) => {\n        if (!isBrowser)\n            return;\n        if ($preventScroll && $open)\n            unsubScroll = removeScroll();\n        if ($open) {\n            const contentEl = document.getElementById(ids.content.get());\n            handleFocus({ prop: openFocus.get(), defaultEl: contentEl });\n        }\n        return () => {\n            // we only want to remove the scroll lock if the dialog is not forced visible\n            // otherwise the scroll removal is handled in the `destroy` of the `content` builder\n            if (!forceVisible.get()) {\n                unsubScroll();\n            }\n        };\n    });\n    return {\n        ids,\n        elements: {\n            content,\n            trigger,\n            title,\n            description,\n            overlay,\n            close,\n            portalled,\n        },\n        states: {\n            open,\n        },\n        options,\n    };\n}\n","import { createDialog } from \"@melt-ui/svelte\";\nimport { getContext, setContext } from \"svelte\";\nimport { createBitAttrs, getOptionUpdater, removeUndefined } from \"../../internal/index.js\";\nexport function getDialogData() {\n    const NAME = \"dialog\";\n    const PARTS = [\n        \"close\",\n        \"content\",\n        \"description\",\n        \"overlay\",\n        \"portal\",\n        \"title\",\n        \"trigger\",\n    ];\n    return {\n        NAME,\n        PARTS,\n    };\n}\nexport function setCtx(props) {\n    const { NAME, PARTS } = getDialogData();\n    const getAttrs = createBitAttrs(NAME, PARTS);\n    const dialog = {\n        ...createDialog({ ...removeUndefined(props), role: \"dialog\", forceVisible: true }),\n        getAttrs,\n    };\n    setContext(NAME, dialog);\n    return {\n        ...dialog,\n        updateOption: getOptionUpdater(dialog.options),\n    };\n}\nexport function getCtx() {\n    const { NAME } = getDialogData();\n    return getContext(NAME);\n}\n","<script>import { derived } from \"svelte/store\";\nimport { setCtx } from \"../ctx.js\";\nexport let preventScroll = void 0;\nexport let closeOnEscape = void 0;\nexport let closeOnOutsideClick = void 0;\nexport let portal = void 0;\nexport let open = void 0;\nexport let onOpenChange = void 0;\nexport let openFocus = void 0;\nexport let closeFocus = void 0;\nexport let onOutsideClick = void 0;\nconst {\n  states: { open: localOpen },\n  updateOption,\n  ids\n} = setCtx({\n  closeOnEscape,\n  preventScroll,\n  closeOnOutsideClick,\n  portal,\n  forceVisible: true,\n  defaultOpen: open,\n  openFocus,\n  closeFocus,\n  onOutsideClick,\n  onOpenChange: ({ next }) => {\n    if (open !== next) {\n      onOpenChange?.(next);\n      open = next;\n    }\n    return next;\n  }\n});\nconst idValues = derived(\n  [ids.content, ids.description, ids.title],\n  ([$contentId, $descriptionId, $titleId]) => ({\n    content: $contentId,\n    description: $descriptionId,\n    title: $titleId\n  })\n);\n$: open !== void 0 && localOpen.set(open);\n$: updateOption(\"preventScroll\", preventScroll);\n$: updateOption(\"closeOnEscape\", closeOnEscape);\n$: updateOption(\"closeOnOutsideClick\", closeOnOutsideClick);\n$: updateOption(\"portal\", portal);\n$: updateOption(\"openFocus\", openFocus);\n$: updateOption(\"closeFocus\", closeFocus);\n$: updateOption(\"onOutsideClick\", onOutsideClick);\n</script>\n\n<slot ids={$idValues} />\n","<script>import { melt } from \"@melt-ui/svelte\";\nimport { getCtx } from \"../ctx.js\";\nexport let level = \"h2\";\nexport let asChild = false;\nexport let id = void 0;\nexport let el = void 0;\nconst {\n  elements: { title },\n  ids,\n  getAttrs\n} = getCtx();\nconst attrs = getAttrs(\"title\");\n$: if (id) {\n  ids.title.set(id);\n}\n$: builder = $title;\n$: Object.assign(builder, attrs);\n</script>\n\n{#if asChild}\n\t<slot {builder} />\n{:else}\n\t<svelte:element this={level} bind:this={el} {...builder} use:builder.action {...$$restProps}>\n\t\t<slot {builder} />\n\t</svelte:element>\n{/if}\n","<script>import { melt } from \"@melt-ui/svelte\";\nimport { getCtx } from \"../ctx.js\";\nexport let transition = void 0;\nexport let transitionConfig = void 0;\nexport let inTransition = void 0;\nexport let inTransitionConfig = void 0;\nexport let outTransition = void 0;\nexport let outTransitionConfig = void 0;\nexport let asChild = false;\nexport let id = void 0;\nexport let el = void 0;\nconst {\n  elements: { content },\n  states: { open },\n  ids,\n  getAttrs\n} = getCtx();\nconst attrs = getAttrs(\"content\");\n$: if (id) {\n  ids.content.set(id);\n}\n$: builder = $content;\n$: Object.assign(builder, attrs);\n</script>\n\n{#if asChild && $open}\n\t<slot {builder} />\n{:else if transition && $open}\n\t<div\n\t\tbind:this={el}\n\t\ttransition:transition={transitionConfig}\n\t\t{...builder} use:builder.action\n\t\t{...$$restProps}\n\t\ton:pointerdown\n\t\ton:pointermove\n\t\ton:pointerup\n\t\ton:touchcancel\n\t\ton:touchend\n\t\ton:touchmove|nonpassive\n\t\ton:touchstart|nonpassive\n\t>\n\t\t<slot {builder} />\n\t</div>\n{:else if inTransition && outTransition && $open}\n\t<div\n\t\tbind:this={el}\n\t\tin:inTransition={inTransitionConfig}\n\t\tout:outTransition={outTransitionConfig}\n\t\t{...builder} use:builder.action\n\t\ton:pointerdown\n\t\ton:pointermove\n\t\ton:pointerup\n\t\ton:touchcancel\n\t\ton:touchend\n\t\ton:touchmove|nonpassive\n\t\ton:touchstart|nonpassive\n\t\t{...$$restProps}\n\t>\n\t\t<slot {builder} />\n\t</div>\n{:else if inTransition && $open}\n\t<div\n\t\tbind:this={el}\n\t\tin:inTransition={inTransitionConfig}\n\t\t{...builder} use:builder.action\n\t\ton:pointerdown\n\t\ton:pointermove\n\t\ton:pointerup\n\t\ton:touchcancel\n\t\ton:touchend\n\t\ton:touchmove|nonpassive\n\t\ton:touchstart|nonpassive\n\t\t{...$$restProps}\n\t>\n\t\t<slot {builder} />\n\t</div>\n{:else if outTransition && $open}\n\t<div\n\t\tbind:this={el}\n\t\tout:outTransition={outTransitionConfig}\n\t\t{...builder} use:builder.action\n\t\ton:pointerdown\n\t\ton:pointermove\n\t\ton:pointerup\n\t\ton:touchcancel\n\t\ton:touchend\n\t\ton:touchmove|nonpassive\n\t\ton:touchstart|nonpassive\n\t\t{...$$restProps}\n\t>\n\t\t<slot {builder} />\n\t</div>\n{:else if $open}\n\t<div\n\t\tbind:this={el}\n\t\t{...builder} use:builder.action\n\t\ton:pointerdown\n\t\ton:pointermove\n\t\ton:pointerup\n\t\ton:touchcancel\n\t\ton:touchend\n\t\ton:touchmove|nonpassive\n\t\ton:touchstart|nonpassive\n\t\t{...$$restProps}\n\t>\n\t\t<slot {builder} />\n\t</div>\n{/if}\n","<script>import { melt } from \"@melt-ui/svelte\";\nimport { getCtx } from \"../ctx.js\";\nexport let transition = void 0;\nexport let transitionConfig = void 0;\nexport let inTransition = void 0;\nexport let inTransitionConfig = void 0;\nexport let outTransition = void 0;\nexport let outTransitionConfig = void 0;\nexport let asChild = false;\nexport let el = void 0;\nconst {\n  elements: { overlay },\n  states: { open },\n  getAttrs\n} = getCtx();\nconst attrs = getAttrs(\"overlay\");\n$: builder = $overlay;\n$: Object.assign(builder, attrs);\n</script>\n\n{#if asChild && $open}\n\t<slot {builder} />\n{:else if transition && $open}\n\t<!-- svelte-ignore a11y-no-static-element-interactions a11y_no_static_element_interactions -->\n\t<div\n\t\ton:mouseup\n\t\tbind:this={el}\n\t\ttransition:transition={transitionConfig}\n\t\t{...builder} use:builder.action\n\t\t{...$$restProps}\n\t></div>\n{:else if inTransition && outTransition && $open}\n\t<!-- svelte-ignore a11y-no-static-element-interactions a11y_no_static_element_interactions -->\n\t<div\n\t\tbind:this={el}\n\t\tin:inTransition={inTransitionConfig}\n\t\tout:outTransition={outTransitionConfig}\n\t\t{...builder} use:builder.action\n\t\ton:mouseup\n\t\t{...$$restProps}\n\t></div>\n{:else if inTransition && $open}\n\t<!-- svelte-ignore a11y-no-static-element-interactions a11y_no_static_element_interactions -->\n\t<div\n\t\tbind:this={el}\n\t\tin:inTransition={inTransitionConfig}\n\t\t{...builder} use:builder.action\n\t\ton:mouseup\n\t\t{...$$restProps}\n\t></div>\n{:else if outTransition && $open}\n\t<!-- svelte-ignore a11y-no-static-element-interactions a11y_no_static_element_interactions -->\n\t<div\n\t\tbind:this={el}\n\t\tout:outTransition={outTransitionConfig}\n\t\t{...builder} use:builder.action\n\t\ton:mouseup\n\t\t{...$$restProps}\n\t></div>\n{:else if $open}\n\t<!-- svelte-ignore a11y-no-static-element-interactions a11y_no_static_element_interactions -->\n\t<div bind:this={el} {...builder} use:builder.action on:mouseup {...$$restProps}></div>\n{/if}\n","<script>import { melt } from \"@melt-ui/svelte\";\nimport { getCtx } from \"../ctx.js\";\nexport let asChild = false;\nexport let id = void 0;\nexport let el = void 0;\nconst {\n  elements: { description },\n  ids,\n  getAttrs\n} = getCtx();\nconst attrs = getAttrs(\"description\");\n$: if (id) {\n  ids.description.set(id);\n}\n$: builder = $description;\n$: Object.assign(builder, attrs);\n</script>\n\n{#if asChild}\n\t<slot {builder} />\n{:else}\n\t<div bind:this={el} {...builder} use:builder.action {...$$restProps}>\n\t\t<slot {builder} />\n\t</div>\n{/if}\n","export function patchSource(source: string) {\n  return (\n    source.includes(\">>> \")\n      ? source.split(\"\\n\").filter(line => line.startsWith(\">>>\") || line.startsWith(\"...\") || !line.trim()).map(line => line.slice(4)).join(\"\\n\")\n      : source\n  );\n}\n\nexport function reformatInputSource(source: string) {\n  return source.split(\"\\n\").map((value, index) => (index ? \"... \" : \">>> \") + value).join(\"\\n\");\n}\n","<script lang=\"ts\">\n  import type { Item, NotebookAPI } from \"$py/notebook/notebook\";\n  import type { Code, Node } from \"mdast\";\n\n  import WithCodeActions from \"../reusable/WithCodeActions.svelte\";\n  import CodeBlock from \"$lib/components/CodeBlock.svelte\";\n  import { patchSource } from \"$lib/utils/formatSource\";\n\n  export let node: Node;\n  export let pyNotebook: NotebookAPI;\n  export let heuristics = false;\n\n  let items: Item[] = [];\n\n  function sync(newItems: Item[]) {\n    items = newItems;\n  }\n\n  async function run(source: string) {\n    if (source.startsWith(\">>>\")) {\n      pyNotebook.run(patchSource(source), sync, true);\n    }\n    else {\n      pyNotebook.run(source, sync);\n    }\n  }\n\n  function isPython(pyNotebook: NotebookAPI, source: string) {\n    if (!heuristics)\n      return false;\n    if (source.startsWith(\">>>\"))\n      return true;\n    if (pyNotebook?.is_python(source))\n      return true;\n    return false;\n  }\n\n  $: valid = isPython(pyNotebook, (node as Code).value);\n</script>\n\n<WithCodeActions {node} {run} runnable={valid} let:code>\n  <CodeBlock lang={code.lang ?? valid ? \"python\" : \"text\"} code={code.value} {items} />\n</WithCodeActions>\n","import * as env from \"$env/static/public\";\nimport { version } from \"pyodide/package.json\";\n\n// eslint-disable-next-line ts/ban-ts-comment\n// @ts-ignore\nexport const indexURL = (env.PUBLIC_PYODIDE_INDEX_URL ?? (import.meta.env.PROD ? \"/pyodide/v{}/\" : \"https://cdn.jsdelivr.net/pyodide/v{}/full/\")).replace(\"{}\", version);\n\nexport const preloadPackages = [\"micropip\", \"pure-eval\"];\n","import type { FS } from \"./emscripten_fs\";\nimport type { PyodideInterface } from \"pyodide\";\n\nimport { dev } from \"$app/environment\";\n\nexport function setupWatcher(py: PyodideInterface) {\n  const { trackingDelegate } = py.FS as unknown as FS;\n\n  const _handle: (change: 1 | 2 | 3, path: string) => void = py.pyimport(\"watchfiles.handle_fs_event\");\n  // 1. added: A new file or directory was added.\n  // 2. modified: A file or directory was modified, can be either a metadata or data change.\n  // 3. deleted: A file or directory was deleted.\n  const handle = (change: 1 | 2 | 3, path: string) => {\n    if (!path.startsWith(\"/dev\")) {\n      setTimeout(() => {\n        _handle(change, path);\n      }, 0);\n    }\n  };\n\n  trackingDelegate.onWriteToFile = (path: string) => {\n    handle(2, path); // modified\n  };\n\n  trackingDelegate.onMakeDirectory = (path: string) => {\n    dev && console.warn(\"make-directory\", path);\n    handle(1, path); // added\n  };\n\n  trackingDelegate.onMakeSymlink = (oldpath: string, newpath: string) => {\n    dev && console.warn(\"make-symlink\", oldpath, newpath);\n    handle(1, newpath); // added\n  };\n\n  trackingDelegate.onMovePath = (old_path: string, new_path: string) => {\n    dev && console.warn(\"move-path\", old_path, new_path);\n    handle(3, old_path); // deleted\n    handle(1, new_path); // added\n  };\n\n  trackingDelegate.onDeletePath = (path: string) => {\n    dev && console.warn(\"delete-path\", path);\n    handle(3, path); // deleted\n  };\n};\n","export default \"from pathlib import Path\\nfrom sys import modules\\nfrom sys import path as sys_path\\n\\nfrom js import console\\n\\nroot = Path(\\\"/runtime_sources/\\\")\\n\\nsys_path.insert(0, root.as_posix())\\n\\n\\ndef setup_module(sources: dict[str, str], module_name=\\\"\\\", base_path=root):\\n    console.groupCollapsed(module_name or base_path.name)\\n\\n    for path, source in sources.items():\\n        file = base_path / module_name / path\\n        if not file.parent.is_dir():\\n            file.parent.mkdir(parents=True)\\n        file.write_text(source, \\\"utf-8\\\")\\n\\n        console.groupCollapsed(path)\\n        console.log(source)\\n        console.groupEnd()\\n\\n    console.groupEnd()\\n\\n    if __debug__:\\n        for mod in list(modules):\\n            if module_name and mod.startswith(module_name):\\n                del modules[mod]  # reload module at dev time\\n\\n\\nsetup_module\\n\"","<script context=\"module\">\n  let count = 0;\n</script>\n\n<script lang=\"ts\">\n  import { draggable } from \"@neodrag/svelte\";\n  import { Dialog } from \"bits-ui\";\n  import { cubicOut } from \"svelte/easing\";\n  import { fade, scale } from \"svelte/transition\";\n\n  export let open: boolean;\n  export let title: string;\n  export let message: string;\n  export let callback: (value: string | undefined) => any;\n\n  export let value: string | undefined = \"\";\n\n  let ref: HTMLInputElement;\n\n  $: if (!open) {\n    callback(value);\n    count--;\n  }\n</script>\n\n<Dialog.Root openFocus={() => ref} bind:open portal={null} closeOnEscape={false} closeOnOutsideClick={false} preventScroll={false}>\n  <div style:z-index={++count} class=\"pointer-events-none fixed left-0 right-0 top-30vh grid place-items-center text-neutral-2 [&>*]:pointer-events-auto\">\n\n    <Dialog.Overlay asChild let:builder>\n      <div transition:fade|global={{ duration: 400, easing: cubicOut }} class=\"fixed inset-0 bg-black/10 duration-250\" {...builder} use:builder.action />\n    </Dialog.Overlay>\n\n    <Dialog.Content asChild let:builder>\n      <div class=\"max-w-[calc(100vw-40px)] w-sm translate-x-$i translate-y-$i\" style:--i=\"{count * 1.7}em\" transition:scale|global={{ start: 0.98, duration: 250 }} {...builder} use:builder.action>\n        <div class=\"flex flex-col items-center gap-2.5 rounded-lg bg-neutral-8/70 p-4 outline-none ring-0.9 ring-white/20 backdrop-blur-md lg:ring-1.3 sm:ring-1.1\" use:draggable={{ cancel: \":not(section,h2)\", bounds: { left: 20, top: 20, right: 20, bottom: 20 }, applyUserSelectHack: false }}>\n          <section class=\"w-full flex flex-row cursor-grab items-center justify-between\">\n\n            <Dialog.Title class=\"select-none\">\n              {title}\n            </Dialog.Title>\n\n            <button on:click={() => [(value = undefined), (open = false)]} title=\"取消\" class=\"rounded-md border-none p-1.5 transition ease-out -m-1.5 active:scale-90 focus-visible:(bg-red-3/10 text-red-3 outline-none ring-1.3 ring-red-3/50) hover:(bg-red-3/10 text-red-3/80)\">\n              <div class=\"i-material-symbols-close-rounded\" />\n            </button>\n\n          </section>\n\n          {#if message !== undefined}\n            <Dialog.Description class=\"<sm:text-sm\">\n              {message}\n            </Dialog.Description>\n          {/if}\n\n          <!-- svelte-ignore a11y-positive-tabindex -->\n          <input tabindex=\"1\" bind:this={ref} on:keydown={({ key }) => key === \"Enter\" && (open = false)} placeholder={message} class=\"mt-1 w-full rounded-sm bg-transparent px-2 py-1.5 text-sky-50 outline-none ring-1.3 ring-white/10 <sm:text-sm focus:ring-white/40 placeholder-neutral-5\" bind:value type=\"text\">\n\n        </div>\n      </div>\n    </Dialog.Content>\n\n  </div>\n</Dialog.Root>\n","<script context=\"module\" lang=\"ts\">\n  import Dialog from \"./Dialog.svelte\";\n  import { writable } from \"svelte/store\";\n\n  let nonce = 0;\n\n  interface Task {\n    id: number;\n    prompt: string;\n    initial: string;\n    resolve: (value: string | undefined) => any;\n  }\n\n  const tasks = writable<Task[]>([]);\n\n  export function input(prompt: any, initial = \"\") {\n    return new Promise<string | undefined>((resolve) => {\n      tasks.update(($tasks) => {\n        $tasks.push({ prompt, initial, resolve, id: nonce++ });\n        return $tasks;\n      });\n    });\n  }\n</script>\n\n{#each $tasks as { prompt, initial, resolve, id } (id)}\n  <Dialog open message={prompt} value={initial} title=\"输入\" callback={(value) => {\n    resolve(value);\n    $tasks = $tasks.filter(task => task.id !== id);\n  }} />\n{/each}\n","import * as env from \"$env/static/public\";\n\nexport function getEnv() {\n  return Object.fromEntries(Object.entries(env as Record<string, string>).map(([k, v]) => [k.replace(\"PUBLIC_\", \"\"), v]));\n}\n","import type { PyProxy } from \"pyodide/ffi\";\n\nimport common from \"../../../python/common\";\nimport watchfiles from \"../../../python/watchfiles\";\nimport { indexURL, preloadPackages } from \"../common\";\nimport { setupWatcher } from \"./fs\";\nimport loader from \"./loader.py?raw\";\nimport { dev } from \"$app/environment\";\nimport { input } from \"$lib/components/Input.svelte\";\nimport { cacheSingleton } from \"$lib/utils/cache\";\nimport { getEnv } from \"$lib/utils/env\";\nimport { withToast } from \"$lib/utils/toast\";\nimport { toast } from \"svelte-sonner\";\n\nconst getMinimalPyodide = cacheSingleton(withToast({ loading: \"加载 Pyodide 运行时\" })(async () => {\n  const { loadPyodide } = await import(\"pyodide\");\n  const py = await loadPyodide({ indexURL, env: getEnv(), packages: preloadPackages, args: dev ? [] : [\"-O\"] });\n  py.globals.set(\"toast\", toast);\n  py.globals.set(\"async_input\", (prompt: string) => input(prompt) ?? \"\");\n  return py;\n}));\n\nconst getSetupModule = cacheSingleton(async () => {\n  const py = await getMinimalPyodide();\n  return py.runPython(loader) as (sources: Record<string, string>, moduleName: string) => PyProxy;\n});\n\nexport async function setupModule(sources: Record<string, string>, moduleName: string) {\n  const setupModule = await getSetupModule();\n  const py = await getMinimalPyodide();\n  setupModule(py.toPy(sources), moduleName);\n}\n\nexport const getPyodide = cacheSingleton(async () => {\n  const py = await getMinimalPyodide();\n  await setupModule(common, \"common\");\n  await setupModule(watchfiles, \"watchfiles\");\n  py.pyimport(\"common.patches\");\n  setupWatcher(py);\n  return py;\n});\n","import { getPyodide } from \"./start/init\";\n\nexport default async function getPy(feature: { console?: boolean; chat?: boolean; notebook?: boolean; web?: boolean; workspace?: boolean } = {}) {\n  const { console = false, chat = false, notebook = false, web = false, workspace = false } = feature;\n\n  if (console) {\n    const { loadConsole } = await import(\"./start/console\");\n    await loadConsole();\n  }\n  if (notebook) {\n    const { loadNotebook } = await import(\"./start/notebook\");\n    await loadNotebook();\n  }\n  if (web) {\n    const { loadWeb } = await import(\"./start/web\");\n    await loadWeb();\n  }\n  if (chat) {\n    const { loadChat } = await import(\"./start/chat\");\n    await loadChat();\n  }\n  if (workspace) {\n    const { loadWorkspace } = await import(\"./start/workspace\");\n    await loadWorkspace();\n  }\n\n  return await getPyodide();\n}\n","<script lang=\"ts\">\n  import type { NotebookAPI } from \"$py/notebook/notebook\";\n\n  import { currentConsole } from \"../console/store\";\n  import getPy from \"$lib/pyodide\";\n  import { onDestroy, onMount } from \"svelte\";\n\n  let pyNotebook: NotebookAPI;\n\n  onMount(async () => {\n    const py = await getPy({ notebook: true });\n    pyNotebook = py.pyimport(\"notebook.NotebookAPI\")() as NotebookAPI;\n    $currentConsole && pyNotebook.inject_globals($currentConsole.context);\n  });\n\n  onDestroy(() => pyNotebook?.destroy());\n</script>\n\n<slot {pyNotebook} />\n"],"file":"_app/immutable/chunks/C9RBdTfC.mjs"}