@vueuse_core.js 128 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434443544364437443844394440444144424443444444454446
  1. import {
  2. and,
  3. assert,
  4. biSyncRef,
  5. bypassFilter,
  6. clamp,
  7. containsProp,
  8. controlledComputed,
  9. controlledRef,
  10. createEventHook,
  11. createFilterWrapper,
  12. createGlobalState,
  13. createSharedComposable,
  14. createSingletonPromise,
  15. debounceFilter,
  16. debouncedWatch,
  17. eagerComputed,
  18. extendRef,
  19. get,
  20. identity,
  21. ignorableWatch,
  22. increaseWithUnit,
  23. invoke,
  24. isBoolean,
  25. isClient,
  26. isDef,
  27. isDefined,
  28. isFunction,
  29. isNumber,
  30. isObject,
  31. isString,
  32. isWindow,
  33. makeDestructurable,
  34. noop,
  35. not,
  36. now,
  37. objectPick,
  38. or,
  39. pausableFilter,
  40. pausableWatch,
  41. promiseTimeout,
  42. rand,
  43. reactify,
  44. reactifyObject,
  45. reactivePick,
  46. refDefault,
  47. set,
  48. syncRef,
  49. throttleFilter,
  50. throttledWatch,
  51. timestamp,
  52. toReactive,
  53. toRefs,
  54. tryOnBeforeUnmount,
  55. tryOnMounted,
  56. tryOnScopeDispose,
  57. tryOnUnmounted,
  58. until,
  59. useCounter,
  60. useDebounce,
  61. useDebounceFn,
  62. useInterval,
  63. useIntervalFn,
  64. useLastChanged,
  65. useThrottle,
  66. useThrottleFn,
  67. useTimeout,
  68. useTimeoutFn,
  69. useToggle,
  70. watchAtMost,
  71. watchOnce,
  72. watchWithFilter,
  73. whenever
  74. } from "./chunk-22ATY35G.js";
  75. import {
  76. __async,
  77. init_define_APP_INFO
  78. } from "./chunk-XY75H3MP.js";
  79. // dep:@vueuse_core
  80. init_define_APP_INFO();
  81. // node_modules/@vueuse/core/index.mjs
  82. init_define_APP_INFO();
  83. import { isRef, ref, watchEffect, computed, customRef, unref, inject, watch, getCurrentInstance, onMounted, onUpdated, shallowRef, markRaw, getCurrentScope, reactive, readonly, onBeforeUpdate, isVue2 } from "vue-demi";
  84. function asyncComputed(evaluationCallback, initialState, optionsOrRef) {
  85. let options;
  86. if (isRef(optionsOrRef)) {
  87. options = {
  88. evaluating: optionsOrRef
  89. };
  90. } else {
  91. options = optionsOrRef || {};
  92. }
  93. const {
  94. lazy = false,
  95. evaluating = void 0,
  96. onError = noop
  97. } = options;
  98. const started = ref(!lazy);
  99. const current = ref(initialState);
  100. let counter = 0;
  101. watchEffect((onInvalidate) => __async(this, null, function* () {
  102. if (!started.value)
  103. return;
  104. counter++;
  105. const counterAtBeginning = counter;
  106. let hasFinished = false;
  107. try {
  108. if (evaluating) {
  109. Promise.resolve().then(() => {
  110. evaluating.value = true;
  111. });
  112. }
  113. const result = yield evaluationCallback((cancelCallback) => {
  114. onInvalidate(() => {
  115. if (evaluating)
  116. evaluating.value = false;
  117. if (!hasFinished)
  118. cancelCallback();
  119. });
  120. });
  121. if (counterAtBeginning === counter)
  122. current.value = result;
  123. } catch (e) {
  124. onError(e);
  125. } finally {
  126. if (evaluating)
  127. evaluating.value = false;
  128. hasFinished = true;
  129. }
  130. }));
  131. if (lazy) {
  132. return computed(() => {
  133. started.value = true;
  134. return current.value;
  135. });
  136. } else {
  137. return current;
  138. }
  139. }
  140. function autoResetRef(defaultValue, afterMs = 1e4) {
  141. return customRef((track, trigger) => {
  142. let value = defaultValue;
  143. let timer;
  144. const resetAfter = () => setTimeout(() => {
  145. value = defaultValue;
  146. trigger();
  147. }, unref(afterMs));
  148. return {
  149. get() {
  150. track();
  151. return value;
  152. },
  153. set(newValue) {
  154. value = newValue;
  155. trigger();
  156. clearTimeout(timer);
  157. timer = resetAfter();
  158. }
  159. };
  160. });
  161. }
  162. function computedInject(key, options, defaultSource, treatDefaultAsFactory) {
  163. let source = inject(key);
  164. if (defaultSource)
  165. source = inject(key, defaultSource);
  166. if (treatDefaultAsFactory)
  167. source = inject(key, defaultSource, treatDefaultAsFactory);
  168. if (typeof options === "function") {
  169. return computed((ctx) => options(source, ctx));
  170. } else {
  171. return computed({
  172. get: (ctx) => options.get(source, ctx),
  173. set: options.set
  174. });
  175. }
  176. }
  177. var createUnrefFn = (fn) => {
  178. return function(...args) {
  179. return fn.apply(this, args.map((i) => unref(i)));
  180. };
  181. };
  182. function unrefElement(elRef) {
  183. var _a;
  184. const plain = unref(elRef);
  185. return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
  186. }
  187. var defaultWindow = isClient ? window : void 0;
  188. var defaultDocument = isClient ? window.document : void 0;
  189. var defaultNavigator = isClient ? window.navigator : void 0;
  190. function useEventListener(...args) {
  191. let target;
  192. let event;
  193. let listener;
  194. let options;
  195. if (isString(args[0])) {
  196. [event, listener, options] = args;
  197. target = defaultWindow;
  198. } else {
  199. [target, event, listener, options] = args;
  200. }
  201. if (!target)
  202. return noop;
  203. let cleanup = noop;
  204. const stopWatch = watch(() => unref(target), (el) => {
  205. cleanup();
  206. if (!el)
  207. return;
  208. el.addEventListener(event, listener, options);
  209. cleanup = () => {
  210. el.removeEventListener(event, listener, options);
  211. cleanup = noop;
  212. };
  213. }, { immediate: true, flush: "post" });
  214. const stop = () => {
  215. stopWatch();
  216. cleanup();
  217. };
  218. tryOnScopeDispose(stop);
  219. return stop;
  220. }
  221. function onClickOutside(target, handler, options = {}) {
  222. const { window: window2 = defaultWindow, event = "pointerdown" } = options;
  223. if (!window2)
  224. return;
  225. const listener = (event2) => {
  226. const el = unrefElement(target);
  227. if (!el)
  228. return;
  229. if (el === event2.target || event2.composedPath().includes(el))
  230. return;
  231. handler(event2);
  232. };
  233. return useEventListener(window2, event, listener, { passive: true });
  234. }
  235. var __defProp$c = Object.defineProperty;
  236. var __defProps$6 = Object.defineProperties;
  237. var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
  238. var __getOwnPropSymbols$e = Object.getOwnPropertySymbols;
  239. var __hasOwnProp$e = Object.prototype.hasOwnProperty;
  240. var __propIsEnum$e = Object.prototype.propertyIsEnumerable;
  241. var __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  242. var __spreadValues$c = (a, b) => {
  243. for (var prop in b || (b = {}))
  244. if (__hasOwnProp$e.call(b, prop))
  245. __defNormalProp$c(a, prop, b[prop]);
  246. if (__getOwnPropSymbols$e)
  247. for (var prop of __getOwnPropSymbols$e(b)) {
  248. if (__propIsEnum$e.call(b, prop))
  249. __defNormalProp$c(a, prop, b[prop]);
  250. }
  251. return a;
  252. };
  253. var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
  254. var createKeyPredicate = (keyFilter) => {
  255. if (typeof keyFilter === "function")
  256. return keyFilter;
  257. else if (typeof keyFilter === "string")
  258. return (event) => event.key === keyFilter;
  259. else if (Array.isArray(keyFilter))
  260. return (event) => keyFilter.includes(event.key);
  261. else if (keyFilter)
  262. return () => true;
  263. else
  264. return () => false;
  265. };
  266. function onKeyStroke(key, handler, options = {}) {
  267. const { target = defaultWindow, eventName = "keydown", passive = false } = options;
  268. const predicate = createKeyPredicate(key);
  269. const listener = (e) => {
  270. if (predicate(e))
  271. handler(e);
  272. };
  273. return useEventListener(target, eventName, listener, passive);
  274. }
  275. function onKeyDown(key, handler, options = {}) {
  276. return onKeyStroke(key, handler, __spreadProps$6(__spreadValues$c({}, options), { eventName: "keydown" }));
  277. }
  278. function onKeyPressed(key, handler, options = {}) {
  279. return onKeyStroke(key, handler, __spreadProps$6(__spreadValues$c({}, options), { eventName: "keypress" }));
  280. }
  281. function onKeyUp(key, handler, options = {}) {
  282. return onKeyStroke(key, handler, __spreadProps$6(__spreadValues$c({}, options), { eventName: "keyup" }));
  283. }
  284. var isFocusedElementEditable = () => {
  285. const { activeElement, body } = document;
  286. if (!activeElement)
  287. return false;
  288. if (activeElement === body)
  289. return false;
  290. switch (activeElement.tagName) {
  291. case "INPUT":
  292. case "TEXTAREA":
  293. return true;
  294. }
  295. return activeElement.hasAttribute("contenteditable");
  296. };
  297. var isTypedCharValid = ({
  298. keyCode,
  299. metaKey,
  300. ctrlKey,
  301. altKey
  302. }) => {
  303. if (metaKey || ctrlKey || altKey)
  304. return false;
  305. if (keyCode >= 48 && keyCode <= 57 || keyCode >= 96 && keyCode <= 105)
  306. return true;
  307. if (keyCode >= 65 && keyCode <= 90)
  308. return true;
  309. return false;
  310. };
  311. function onStartTyping(callback, options = {}) {
  312. const { document: document2 = defaultDocument } = options;
  313. const keydown = (event) => {
  314. !isFocusedElementEditable() && isTypedCharValid(event) && callback(event);
  315. };
  316. if (document2)
  317. useEventListener(document2, "keydown", keydown, { passive: true });
  318. }
  319. function templateRef(key, initialValue = null) {
  320. const instance = getCurrentInstance();
  321. let _trigger = () => {
  322. };
  323. const element = customRef((track, trigger) => {
  324. _trigger = trigger;
  325. return {
  326. get() {
  327. var _a, _b;
  328. track();
  329. return (_b = (_a = instance == null ? void 0 : instance.proxy) == null ? void 0 : _a.$refs[key]) != null ? _b : initialValue;
  330. },
  331. set() {
  332. }
  333. };
  334. });
  335. onMounted(_trigger);
  336. onUpdated(_trigger);
  337. return element;
  338. }
  339. function useActiveElement(options = {}) {
  340. const { window: window2 = defaultWindow } = options;
  341. const counter = ref(0);
  342. if (window2) {
  343. useEventListener(window2, "blur", () => counter.value += 1, true);
  344. useEventListener(window2, "focus", () => counter.value += 1, true);
  345. }
  346. return computed(() => {
  347. counter.value;
  348. return window2 == null ? void 0 : window2.document.activeElement;
  349. });
  350. }
  351. function useAsyncState(promise, initialState, options = {}) {
  352. const {
  353. immediate = true,
  354. delay = 0,
  355. onError = noop,
  356. resetOnExecute = true
  357. } = options;
  358. const state = shallowRef(initialState);
  359. const isReady = ref(false);
  360. const error = ref(void 0);
  361. function execute(delay2 = 0, ...args) {
  362. return __async(this, null, function* () {
  363. if (resetOnExecute)
  364. state.value = initialState;
  365. error.value = void 0;
  366. isReady.value = false;
  367. if (delay2 > 0)
  368. yield promiseTimeout(delay2);
  369. const _promise = typeof promise === "function" ? promise(...args) : promise;
  370. try {
  371. const data = yield _promise;
  372. state.value = data;
  373. isReady.value = true;
  374. } catch (e) {
  375. error.value = e;
  376. onError(e);
  377. }
  378. return state.value;
  379. });
  380. }
  381. if (immediate)
  382. execute(delay);
  383. return {
  384. state,
  385. isReady,
  386. error,
  387. execute
  388. };
  389. }
  390. function useBase64(target, options) {
  391. const base64 = ref("");
  392. const promise = ref();
  393. function execute() {
  394. promise.value = new Promise((resolve, reject) => {
  395. try {
  396. const _target = unref(target);
  397. if (_target === void 0 || _target === null) {
  398. resolve("");
  399. } else if (typeof _target === "string") {
  400. resolve(blobToBase64(new Blob([_target], { type: "text/plain" })));
  401. } else if (_target instanceof Blob) {
  402. resolve(blobToBase64(_target));
  403. } else if (_target instanceof ArrayBuffer) {
  404. resolve(window.btoa(String.fromCharCode(...new Uint8Array(_target))));
  405. } else if (_target instanceof HTMLCanvasElement) {
  406. resolve(_target.toDataURL(options == null ? void 0 : options.type, options == null ? void 0 : options.quality));
  407. } else if (_target instanceof HTMLImageElement) {
  408. const img = _target.cloneNode(false);
  409. img.crossOrigin = "Anonymous";
  410. imgLoaded(img).then(() => {
  411. const canvas = document.createElement("canvas");
  412. const ctx = canvas.getContext("2d");
  413. canvas.width = img.width;
  414. canvas.height = img.height;
  415. ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
  416. resolve(canvas.toDataURL(options == null ? void 0 : options.type, options == null ? void 0 : options.quality));
  417. }).catch(reject);
  418. } else {
  419. reject(new Error("target is unsupported types"));
  420. }
  421. } catch (error) {
  422. reject(error);
  423. }
  424. });
  425. promise.value.then((res) => base64.value = res);
  426. return promise.value;
  427. }
  428. watch(target, execute, { immediate: true });
  429. return {
  430. base64,
  431. promise,
  432. execute
  433. };
  434. }
  435. function imgLoaded(img) {
  436. return new Promise((resolve, reject) => {
  437. if (!img.complete) {
  438. img.onload = () => {
  439. resolve();
  440. };
  441. img.onerror = reject;
  442. } else {
  443. resolve();
  444. }
  445. });
  446. }
  447. function blobToBase64(blob) {
  448. return new Promise((resolve, reject) => {
  449. const fr = new FileReader();
  450. fr.onload = (e) => {
  451. resolve(e.target.result);
  452. };
  453. fr.onerror = reject;
  454. fr.readAsDataURL(blob);
  455. });
  456. }
  457. function useBattery({ navigator = defaultNavigator } = {}) {
  458. const events2 = ["chargingchange", "chargingtimechange", "dischargingtimechange", "levelchange"];
  459. const isSupported = navigator && "getBattery" in navigator;
  460. const charging = ref(false);
  461. const chargingTime = ref(0);
  462. const dischargingTime = ref(0);
  463. const level = ref(1);
  464. let battery;
  465. function updateBatteryInfo() {
  466. charging.value = this.charging;
  467. chargingTime.value = this.chargingTime || 0;
  468. dischargingTime.value = this.dischargingTime || 0;
  469. level.value = this.level;
  470. }
  471. if (isSupported) {
  472. navigator.getBattery().then((_battery) => {
  473. battery = _battery;
  474. updateBatteryInfo.call(battery);
  475. for (const event of events2)
  476. useEventListener(battery, event, updateBatteryInfo, { passive: true });
  477. });
  478. }
  479. return {
  480. isSupported,
  481. charging,
  482. chargingTime,
  483. dischargingTime,
  484. level
  485. };
  486. }
  487. function useMediaQuery(query, options = {}) {
  488. const { window: window2 = defaultWindow } = options;
  489. if (!window2)
  490. return ref(false);
  491. const mediaQuery = window2.matchMedia(query);
  492. const matches = ref(mediaQuery.matches);
  493. const handler = (event) => {
  494. matches.value = event.matches;
  495. };
  496. if ("addEventListener" in mediaQuery)
  497. mediaQuery.addEventListener("change", handler);
  498. else
  499. mediaQuery.addListener(handler);
  500. tryOnScopeDispose(() => {
  501. if ("removeEventListener" in mediaQuery)
  502. mediaQuery.removeEventListener("change", handler);
  503. else
  504. mediaQuery.removeListener(handler);
  505. });
  506. return matches;
  507. }
  508. var breakpointsTailwind = {
  509. "sm": 640,
  510. "md": 768,
  511. "lg": 1024,
  512. "xl": 1280,
  513. "2xl": 1536
  514. };
  515. var breakpointsBootstrapV5 = {
  516. sm: 576,
  517. md: 768,
  518. lg: 992,
  519. xl: 1200,
  520. xxl: 1400
  521. };
  522. var breakpointsVuetify = {
  523. xs: 600,
  524. sm: 960,
  525. md: 1264,
  526. lg: 1904
  527. };
  528. var breakpointsAntDesign = {
  529. xs: 480,
  530. sm: 576,
  531. md: 768,
  532. lg: 992,
  533. xl: 1200,
  534. xxl: 1600
  535. };
  536. var breakpointsQuasar = {
  537. xs: 600,
  538. sm: 1024,
  539. md: 1440,
  540. lg: 1920
  541. };
  542. var breakpointsSematic = {
  543. mobileS: 320,
  544. mobileM: 375,
  545. mobileL: 425,
  546. tablet: 768,
  547. laptop: 1024,
  548. laptopL: 1440,
  549. desktop4K: 2560
  550. };
  551. var __defProp$b = Object.defineProperty;
  552. var __getOwnPropSymbols$d = Object.getOwnPropertySymbols;
  553. var __hasOwnProp$d = Object.prototype.hasOwnProperty;
  554. var __propIsEnum$d = Object.prototype.propertyIsEnumerable;
  555. var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  556. var __spreadValues$b = (a, b) => {
  557. for (var prop in b || (b = {}))
  558. if (__hasOwnProp$d.call(b, prop))
  559. __defNormalProp$b(a, prop, b[prop]);
  560. if (__getOwnPropSymbols$d)
  561. for (var prop of __getOwnPropSymbols$d(b)) {
  562. if (__propIsEnum$d.call(b, prop))
  563. __defNormalProp$b(a, prop, b[prop]);
  564. }
  565. return a;
  566. };
  567. function useBreakpoints(breakpoints, options = {}) {
  568. function getValue(k, delta) {
  569. let v = breakpoints[k];
  570. if (delta != null)
  571. v = increaseWithUnit(v, delta);
  572. if (typeof v === "number")
  573. v = `${v}px`;
  574. return v;
  575. }
  576. const { window: window2 = defaultWindow } = options;
  577. function match(query) {
  578. if (!window2)
  579. return false;
  580. return window2.matchMedia(query).matches;
  581. }
  582. const greater = (k) => {
  583. return useMediaQuery(`(min-width: ${getValue(k)})`, options);
  584. };
  585. const shortcutMethods = Object.keys(breakpoints).reduce((shortcuts, k) => {
  586. Object.defineProperty(shortcuts, k, {
  587. get: () => greater(k),
  588. enumerable: true,
  589. configurable: true
  590. });
  591. return shortcuts;
  592. }, {});
  593. return __spreadValues$b({
  594. greater,
  595. smaller(k) {
  596. return useMediaQuery(`(max-width: ${getValue(k, -0.1)})`, options);
  597. },
  598. between(a, b) {
  599. return useMediaQuery(`(min-width: ${getValue(a)}) and (max-width: ${getValue(b, -0.1)})`, options);
  600. },
  601. isGreater(k) {
  602. return match(`(min-width: ${getValue(k)})`);
  603. },
  604. isSmaller(k) {
  605. return match(`(max-width: ${getValue(k, -0.1)})`);
  606. },
  607. isInBetween(a, b) {
  608. return match(`(min-width: ${getValue(a)}) and (max-width: ${getValue(b, -0.1)})`);
  609. }
  610. }, shortcutMethods);
  611. }
  612. function useBrowserLocation({ window: window2 = defaultWindow } = {}) {
  613. const buildState = (trigger) => {
  614. const { state: state2, length } = (window2 == null ? void 0 : window2.history) || {};
  615. const { hash, host, hostname, href, origin, pathname, port, protocol, search } = (window2 == null ? void 0 : window2.location) || {};
  616. return {
  617. trigger,
  618. state: state2,
  619. length,
  620. hash,
  621. host,
  622. hostname,
  623. href,
  624. origin,
  625. pathname,
  626. port,
  627. protocol,
  628. search
  629. };
  630. };
  631. const state = ref(buildState("load"));
  632. if (window2) {
  633. useEventListener(window2, "popstate", () => state.value = buildState("popstate"), { passive: true });
  634. useEventListener(window2, "hashchange", () => state.value = buildState("hashchange"), { passive: true });
  635. }
  636. return state;
  637. }
  638. function useClipboard(options = {}) {
  639. const {
  640. navigator = defaultNavigator,
  641. read = true,
  642. source,
  643. copiedDuring = 1500
  644. } = options;
  645. const events2 = ["copy", "cut"];
  646. const isSupported = Boolean(navigator && "clipboard" in navigator);
  647. const text = ref("");
  648. const copied = ref(false);
  649. const timeout = useTimeoutFn(() => copied.value = false, copiedDuring);
  650. function updateText() {
  651. navigator.clipboard.readText().then((value) => {
  652. text.value = value;
  653. });
  654. }
  655. if (isSupported && read) {
  656. for (const event of events2)
  657. useEventListener(event, updateText);
  658. }
  659. function copy() {
  660. return __async(this, arguments, function* (value = unref(source)) {
  661. if (isSupported && value != null) {
  662. yield navigator.clipboard.writeText(value);
  663. text.value = value;
  664. copied.value = true;
  665. timeout.start();
  666. }
  667. });
  668. }
  669. return {
  670. isSupported,
  671. text,
  672. copied,
  673. copy
  674. };
  675. }
  676. function useConfirmDialog(revealed = ref(false)) {
  677. const confirmHook = createEventHook();
  678. const cancelHook = createEventHook();
  679. const revealHook = createEventHook();
  680. let _resolve = noop;
  681. const reveal = (data) => {
  682. revealHook.trigger(data);
  683. revealed.value = true;
  684. return new Promise((resolve) => {
  685. _resolve = resolve;
  686. });
  687. };
  688. const confirm = (data) => {
  689. revealed.value = false;
  690. confirmHook.trigger(data);
  691. _resolve({ data, isCanceled: false });
  692. };
  693. const cancel = (data) => {
  694. revealed.value = false;
  695. cancelHook.trigger(data);
  696. _resolve({ data, isCanceled: true });
  697. };
  698. return {
  699. isRevealed: computed(() => revealed.value),
  700. reveal,
  701. confirm,
  702. cancel,
  703. onReveal: revealHook.on,
  704. onConfirm: confirmHook.on,
  705. onCancel: cancelHook.on
  706. };
  707. }
  708. function useCssVar(prop, target, { window: window2 = defaultWindow } = {}) {
  709. const variable = ref("");
  710. const elRef = computed(() => {
  711. var _a;
  712. return unrefElement(target) || ((_a = window2 == null ? void 0 : window2.document) == null ? void 0 : _a.documentElement);
  713. });
  714. watch(elRef, (el) => {
  715. if (el && window2)
  716. variable.value = window2.getComputedStyle(el).getPropertyValue(prop);
  717. }, { immediate: true });
  718. watch(variable, (val) => {
  719. var _a;
  720. if ((_a = elRef.value) == null ? void 0 : _a.style)
  721. elRef.value.style.setProperty(prop, val);
  722. });
  723. return variable;
  724. }
  725. var StorageSerializers = {
  726. boolean: {
  727. read: (v) => v === "true",
  728. write: (v) => String(v)
  729. },
  730. object: {
  731. read: (v) => JSON.parse(v),
  732. write: (v) => JSON.stringify(v)
  733. },
  734. number: {
  735. read: (v) => Number.parseFloat(v),
  736. write: (v) => String(v)
  737. },
  738. any: {
  739. read: (v) => v,
  740. write: (v) => String(v)
  741. },
  742. string: {
  743. read: (v) => v,
  744. write: (v) => String(v)
  745. },
  746. map: {
  747. read: (v) => new Map(JSON.parse(v)),
  748. write: (v) => JSON.stringify(Array.from(v.entries()))
  749. },
  750. set: {
  751. read: (v) => new Set(JSON.parse(v)),
  752. write: (v) => JSON.stringify(Array.from(v.entries()))
  753. }
  754. };
  755. function useStorage(key, initialValue, storage = ((_a) => (_a = defaultWindow) == null ? void 0 : _a.localStorage)(), options = {}) {
  756. var _a2;
  757. const {
  758. flush = "pre",
  759. deep = true,
  760. listenToStorageChanges = true,
  761. writeDefaults = true,
  762. shallow,
  763. window: window2 = defaultWindow,
  764. eventFilter,
  765. onError = (e) => {
  766. console.error(e);
  767. }
  768. } = options;
  769. const rawInit = unref(initialValue);
  770. const type = rawInit == null ? "any" : rawInit instanceof Set ? "set" : rawInit instanceof Map ? "map" : typeof rawInit === "boolean" ? "boolean" : typeof rawInit === "string" ? "string" : typeof rawInit === "object" ? "object" : Array.isArray(rawInit) ? "object" : !Number.isNaN(rawInit) ? "number" : "any";
  771. const data = (shallow ? shallowRef : ref)(initialValue);
  772. const serializer = (_a2 = options.serializer) != null ? _a2 : StorageSerializers[type];
  773. function read(event) {
  774. if (!storage || event && event.key !== key)
  775. return;
  776. try {
  777. const rawValue = event ? event.newValue : storage.getItem(key);
  778. if (rawValue == null) {
  779. data.value = rawInit;
  780. if (writeDefaults && rawInit !== null)
  781. storage.setItem(key, serializer.write(rawInit));
  782. } else {
  783. data.value = serializer.read(rawValue);
  784. }
  785. } catch (e) {
  786. onError(e);
  787. }
  788. }
  789. read();
  790. if (window2 && listenToStorageChanges)
  791. useEventListener(window2, "storage", (e) => setTimeout(() => read(e), 0));
  792. if (storage) {
  793. watchWithFilter(data, () => {
  794. try {
  795. if (data.value == null)
  796. storage.removeItem(key);
  797. else
  798. storage.setItem(key, serializer.write(data.value));
  799. } catch (e) {
  800. onError(e);
  801. }
  802. }, {
  803. flush,
  804. deep,
  805. eventFilter
  806. });
  807. }
  808. return data;
  809. }
  810. function usePreferredDark(options) {
  811. return useMediaQuery("(prefers-color-scheme: dark)", options);
  812. }
  813. function useDark(options = {}) {
  814. var _a;
  815. const {
  816. selector = "html",
  817. attribute = "class",
  818. valueDark = "dark",
  819. valueLight = "",
  820. window: window2 = defaultWindow,
  821. storage = (_a = defaultWindow) == null ? void 0 : _a.localStorage,
  822. storageKey = "vueuse-color-scheme",
  823. listenToStorageChanges = true
  824. } = options;
  825. const preferredDark = usePreferredDark({ window: window2 });
  826. const store = storageKey == null ? ref("auto") : useStorage(storageKey, "auto", storage, { window: window2, listenToStorageChanges });
  827. const isDark = computed({
  828. get() {
  829. return store.value === "auto" ? preferredDark.value : store.value === "dark";
  830. },
  831. set(v) {
  832. if (v === preferredDark.value)
  833. store.value = "auto";
  834. else
  835. store.value = v ? "dark" : "light";
  836. }
  837. });
  838. const onChanged = options.onChanged || ((v) => {
  839. const el = window2 == null ? void 0 : window2.document.querySelector(selector);
  840. if (attribute === "class") {
  841. el == null ? void 0 : el.classList.toggle(valueDark, v);
  842. if (valueLight)
  843. el == null ? void 0 : el.classList.toggle(valueLight, !v);
  844. } else {
  845. el == null ? void 0 : el.setAttribute(attribute, v ? valueDark : valueLight);
  846. }
  847. });
  848. watch(isDark, onChanged, { flush: "post" });
  849. tryOnMounted(() => onChanged(isDark.value));
  850. return isDark;
  851. }
  852. var fnClone = (v) => JSON.parse(JSON.stringify(v));
  853. var fnBypass = (v) => v;
  854. var fnSetSource = (source, value) => source.value = value;
  855. function defaultDump(clone) {
  856. return clone ? isFunction(clone) ? clone : fnClone : fnBypass;
  857. }
  858. function defaultParse(clone) {
  859. return clone ? isFunction(clone) ? clone : fnClone : fnBypass;
  860. }
  861. function useManualRefHistory(source, options = {}) {
  862. const {
  863. clone = false,
  864. dump = defaultDump(clone),
  865. parse = defaultParse(clone),
  866. setSource = fnSetSource
  867. } = options;
  868. function _createHistoryRecord() {
  869. return markRaw({
  870. snapshot: dump(source.value),
  871. timestamp: timestamp()
  872. });
  873. }
  874. const last = ref(_createHistoryRecord());
  875. const undoStack = ref([]);
  876. const redoStack = ref([]);
  877. const _setSource = (record) => {
  878. setSource(source, parse(record.snapshot));
  879. last.value = record;
  880. };
  881. const commit = () => {
  882. undoStack.value.unshift(last.value);
  883. last.value = _createHistoryRecord();
  884. if (options.capacity && undoStack.value.length > options.capacity)
  885. undoStack.value.splice(options.capacity, Infinity);
  886. if (redoStack.value.length)
  887. redoStack.value.splice(0, redoStack.value.length);
  888. };
  889. const clear = () => {
  890. undoStack.value.splice(0, undoStack.value.length);
  891. redoStack.value.splice(0, redoStack.value.length);
  892. };
  893. const undo = () => {
  894. const state = undoStack.value.shift();
  895. if (state) {
  896. redoStack.value.unshift(last.value);
  897. _setSource(state);
  898. }
  899. };
  900. const redo = () => {
  901. const state = redoStack.value.shift();
  902. if (state) {
  903. undoStack.value.unshift(last.value);
  904. _setSource(state);
  905. }
  906. };
  907. const reset = () => {
  908. _setSource(last.value);
  909. };
  910. const history = computed(() => [last.value, ...undoStack.value]);
  911. const canUndo = computed(() => undoStack.value.length > 0);
  912. const canRedo = computed(() => redoStack.value.length > 0);
  913. return {
  914. source,
  915. undoStack,
  916. redoStack,
  917. last,
  918. history,
  919. canUndo,
  920. canRedo,
  921. clear,
  922. commit,
  923. reset,
  924. undo,
  925. redo
  926. };
  927. }
  928. var __defProp$a = Object.defineProperty;
  929. var __defProps$5 = Object.defineProperties;
  930. var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
  931. var __getOwnPropSymbols$c = Object.getOwnPropertySymbols;
  932. var __hasOwnProp$c = Object.prototype.hasOwnProperty;
  933. var __propIsEnum$c = Object.prototype.propertyIsEnumerable;
  934. var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  935. var __spreadValues$a = (a, b) => {
  936. for (var prop in b || (b = {}))
  937. if (__hasOwnProp$c.call(b, prop))
  938. __defNormalProp$a(a, prop, b[prop]);
  939. if (__getOwnPropSymbols$c)
  940. for (var prop of __getOwnPropSymbols$c(b)) {
  941. if (__propIsEnum$c.call(b, prop))
  942. __defNormalProp$a(a, prop, b[prop]);
  943. }
  944. return a;
  945. };
  946. var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
  947. function useRefHistory(source, options = {}) {
  948. const {
  949. deep = false,
  950. flush = "pre",
  951. eventFilter
  952. } = options;
  953. const {
  954. eventFilter: composedFilter,
  955. pause,
  956. resume: resumeTracking,
  957. isActive: isTracking
  958. } = pausableFilter(eventFilter);
  959. const {
  960. ignoreUpdates,
  961. ignorePrevAsyncUpdates,
  962. stop
  963. } = ignorableWatch(source, commit, { deep, flush, eventFilter: composedFilter });
  964. function setSource(source2, value) {
  965. ignorePrevAsyncUpdates();
  966. ignoreUpdates(() => {
  967. source2.value = value;
  968. });
  969. }
  970. const manualHistory = useManualRefHistory(source, __spreadProps$5(__spreadValues$a({}, options), { clone: options.clone || deep, setSource }));
  971. const { clear, commit: manualCommit } = manualHistory;
  972. function commit() {
  973. ignorePrevAsyncUpdates();
  974. manualCommit();
  975. }
  976. function resume(commitNow) {
  977. resumeTracking();
  978. if (commitNow)
  979. commit();
  980. }
  981. function batch(fn) {
  982. let canceled = false;
  983. const cancel = () => canceled = true;
  984. ignoreUpdates(() => {
  985. fn(cancel);
  986. });
  987. if (!canceled)
  988. commit();
  989. }
  990. function dispose() {
  991. stop();
  992. clear();
  993. }
  994. return __spreadProps$5(__spreadValues$a({}, manualHistory), {
  995. isTracking,
  996. pause,
  997. resume,
  998. commit,
  999. batch,
  1000. dispose
  1001. });
  1002. }
  1003. var __defProp$9 = Object.defineProperty;
  1004. var __defProps$4 = Object.defineProperties;
  1005. var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
  1006. var __getOwnPropSymbols$b = Object.getOwnPropertySymbols;
  1007. var __hasOwnProp$b = Object.prototype.hasOwnProperty;
  1008. var __propIsEnum$b = Object.prototype.propertyIsEnumerable;
  1009. var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  1010. var __spreadValues$9 = (a, b) => {
  1011. for (var prop in b || (b = {}))
  1012. if (__hasOwnProp$b.call(b, prop))
  1013. __defNormalProp$9(a, prop, b[prop]);
  1014. if (__getOwnPropSymbols$b)
  1015. for (var prop of __getOwnPropSymbols$b(b)) {
  1016. if (__propIsEnum$b.call(b, prop))
  1017. __defNormalProp$9(a, prop, b[prop]);
  1018. }
  1019. return a;
  1020. };
  1021. var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
  1022. function useDebouncedRefHistory(source, options = {}) {
  1023. const filter = options.debounce ? debounceFilter(options.debounce) : void 0;
  1024. const history = useRefHistory(source, __spreadProps$4(__spreadValues$9({}, options), { eventFilter: filter }));
  1025. return __spreadValues$9({}, history);
  1026. }
  1027. function useDeviceMotion(options = {}) {
  1028. const {
  1029. window: window2 = defaultWindow,
  1030. eventFilter = bypassFilter
  1031. } = options;
  1032. const acceleration = ref({ x: null, y: null, z: null });
  1033. const rotationRate = ref({ alpha: null, beta: null, gamma: null });
  1034. const interval = ref(0);
  1035. const accelerationIncludingGravity = ref({
  1036. x: null,
  1037. y: null,
  1038. z: null
  1039. });
  1040. if (window2) {
  1041. const onDeviceMotion = createFilterWrapper(eventFilter, (event) => {
  1042. acceleration.value = event.acceleration;
  1043. accelerationIncludingGravity.value = event.accelerationIncludingGravity;
  1044. rotationRate.value = event.rotationRate;
  1045. interval.value = event.interval;
  1046. });
  1047. useEventListener(window2, "devicemotion", onDeviceMotion);
  1048. }
  1049. return {
  1050. acceleration,
  1051. accelerationIncludingGravity,
  1052. rotationRate,
  1053. interval
  1054. };
  1055. }
  1056. function useDeviceOrientation(options = {}) {
  1057. const { window: window2 = defaultWindow } = options;
  1058. const isSupported = Boolean(window2 && "DeviceOrientationEvent" in window2);
  1059. const isAbsolute = ref(false);
  1060. const alpha = ref(null);
  1061. const beta = ref(null);
  1062. const gamma = ref(null);
  1063. if (window2 && isSupported) {
  1064. useEventListener(window2, "deviceorientation", (event) => {
  1065. isAbsolute.value = event.absolute;
  1066. alpha.value = event.alpha;
  1067. beta.value = event.beta;
  1068. gamma.value = event.gamma;
  1069. });
  1070. }
  1071. return {
  1072. isSupported,
  1073. isAbsolute,
  1074. alpha,
  1075. beta,
  1076. gamma
  1077. };
  1078. }
  1079. var DEVICE_PIXEL_RATIO_SCALES = [
  1080. 1,
  1081. 1.325,
  1082. 1.4,
  1083. 1.5,
  1084. 1.8,
  1085. 2,
  1086. 2.4,
  1087. 2.5,
  1088. 2.75,
  1089. 3,
  1090. 3.5,
  1091. 4
  1092. ];
  1093. function useDevicePixelRatio({
  1094. window: window2 = defaultWindow
  1095. } = {}) {
  1096. if (!window2) {
  1097. return {
  1098. pixelRatio: ref(1)
  1099. };
  1100. }
  1101. const pixelRatio = ref(window2.devicePixelRatio);
  1102. const handleDevicePixelRatio = () => {
  1103. pixelRatio.value = window2.devicePixelRatio;
  1104. };
  1105. useEventListener(window2, "resize", handleDevicePixelRatio, { passive: true });
  1106. DEVICE_PIXEL_RATIO_SCALES.forEach((dppx) => {
  1107. const mqlMin = useMediaQuery(`screen and (min-resolution: ${dppx}dppx)`);
  1108. const mqlMax = useMediaQuery(`screen and (max-resolution: ${dppx}dppx)`);
  1109. watch([mqlMin, mqlMax], handleDevicePixelRatio);
  1110. });
  1111. return { pixelRatio };
  1112. }
  1113. function usePermission(permissionDesc, options = {}) {
  1114. const {
  1115. controls = false,
  1116. navigator = defaultNavigator
  1117. } = options;
  1118. const isSupported = Boolean(navigator && "permissions" in navigator);
  1119. let permissionStatus;
  1120. const desc = typeof permissionDesc === "string" ? { name: permissionDesc } : permissionDesc;
  1121. const state = ref();
  1122. const onChange = () => {
  1123. if (permissionStatus)
  1124. state.value = permissionStatus.state;
  1125. };
  1126. const query = createSingletonPromise(() => __async(this, null, function* () {
  1127. if (!isSupported)
  1128. return;
  1129. if (!permissionStatus) {
  1130. try {
  1131. permissionStatus = yield navigator.permissions.query(desc);
  1132. useEventListener(permissionStatus, "change", onChange);
  1133. onChange();
  1134. } catch (e) {
  1135. state.value = "prompt";
  1136. }
  1137. }
  1138. return permissionStatus;
  1139. }));
  1140. query();
  1141. if (controls) {
  1142. return {
  1143. state,
  1144. isSupported,
  1145. query
  1146. };
  1147. } else {
  1148. return state;
  1149. }
  1150. }
  1151. function useDevicesList(options = {}) {
  1152. const {
  1153. navigator = defaultNavigator,
  1154. requestPermissions = false,
  1155. onUpdated: onUpdated2
  1156. } = options;
  1157. const devices = ref([]);
  1158. const videoInputs = computed(() => devices.value.filter((i) => i.kind === "videoinput"));
  1159. const audioInputs = computed(() => devices.value.filter((i) => i.kind === "audioinput"));
  1160. const audioOutputs = computed(() => devices.value.filter((i) => i.kind === "audiooutput"));
  1161. let isSupported = false;
  1162. const permissionGranted = ref(false);
  1163. function update() {
  1164. return __async(this, null, function* () {
  1165. if (!isSupported)
  1166. return;
  1167. devices.value = yield navigator.mediaDevices.enumerateDevices();
  1168. onUpdated2 == null ? void 0 : onUpdated2(devices.value);
  1169. });
  1170. }
  1171. function ensurePermissions() {
  1172. return __async(this, null, function* () {
  1173. if (!isSupported)
  1174. return false;
  1175. if (permissionGranted.value)
  1176. return true;
  1177. const { state, query } = usePermission("camera", { controls: true });
  1178. yield query();
  1179. if (state.value !== "granted") {
  1180. const stream = yield navigator.mediaDevices.getUserMedia({ audio: true, video: true });
  1181. stream.getTracks().forEach((t) => t.stop());
  1182. update();
  1183. permissionGranted.value = true;
  1184. } else {
  1185. permissionGranted.value = true;
  1186. }
  1187. return permissionGranted.value;
  1188. });
  1189. }
  1190. if (navigator) {
  1191. isSupported = Boolean(navigator.mediaDevices && navigator.mediaDevices.enumerateDevices);
  1192. if (isSupported) {
  1193. if (requestPermissions)
  1194. ensurePermissions();
  1195. useEventListener(navigator.mediaDevices, "devicechange", update);
  1196. update();
  1197. }
  1198. }
  1199. return {
  1200. devices,
  1201. ensurePermissions,
  1202. permissionGranted,
  1203. videoInputs,
  1204. audioInputs,
  1205. audioOutputs,
  1206. isSupported
  1207. };
  1208. }
  1209. function useDisplayMedia(options = {}) {
  1210. var _a, _b;
  1211. const enabled = ref((_a = options.enabled) != null ? _a : false);
  1212. const video = options.video;
  1213. const audio = options.audio;
  1214. const { navigator = defaultNavigator } = options;
  1215. const isSupported = Boolean((_b = navigator == null ? void 0 : navigator.mediaDevices) == null ? void 0 : _b.getDisplayMedia);
  1216. const constraint = { audio, video };
  1217. const stream = shallowRef();
  1218. function _start() {
  1219. return __async(this, null, function* () {
  1220. if (!isSupported || stream.value)
  1221. return;
  1222. stream.value = yield navigator.mediaDevices.getDisplayMedia(constraint);
  1223. return stream.value;
  1224. });
  1225. }
  1226. function _stop() {
  1227. return __async(this, null, function* () {
  1228. var _a2;
  1229. (_a2 = stream.value) == null ? void 0 : _a2.getTracks().forEach((t) => t.stop());
  1230. stream.value = void 0;
  1231. });
  1232. }
  1233. function stop() {
  1234. _stop();
  1235. enabled.value = false;
  1236. }
  1237. function start() {
  1238. return __async(this, null, function* () {
  1239. yield _start();
  1240. if (stream.value)
  1241. enabled.value = true;
  1242. return stream.value;
  1243. });
  1244. }
  1245. watch(enabled, (v) => {
  1246. if (v)
  1247. _start();
  1248. else
  1249. _stop();
  1250. }, { immediate: true });
  1251. return {
  1252. isSupported,
  1253. stream,
  1254. start,
  1255. stop,
  1256. enabled
  1257. };
  1258. }
  1259. function useDocumentVisibility({ document: document2 = defaultDocument } = {}) {
  1260. if (!document2)
  1261. return ref("visible");
  1262. const visibility = ref(document2.visibilityState);
  1263. useEventListener(document2, "visibilitychange", () => {
  1264. visibility.value = document2.visibilityState;
  1265. });
  1266. return visibility;
  1267. }
  1268. var __defProp$8 = Object.defineProperty;
  1269. var __defProps$3 = Object.defineProperties;
  1270. var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
  1271. var __getOwnPropSymbols$a = Object.getOwnPropertySymbols;
  1272. var __hasOwnProp$a = Object.prototype.hasOwnProperty;
  1273. var __propIsEnum$a = Object.prototype.propertyIsEnumerable;
  1274. var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  1275. var __spreadValues$8 = (a, b) => {
  1276. for (var prop in b || (b = {}))
  1277. if (__hasOwnProp$a.call(b, prop))
  1278. __defNormalProp$8(a, prop, b[prop]);
  1279. if (__getOwnPropSymbols$a)
  1280. for (var prop of __getOwnPropSymbols$a(b)) {
  1281. if (__propIsEnum$a.call(b, prop))
  1282. __defNormalProp$8(a, prop, b[prop]);
  1283. }
  1284. return a;
  1285. };
  1286. var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
  1287. function useDraggable(target, options = {}) {
  1288. var _a, _b;
  1289. const draggingElement = (_a = options.draggingElement) != null ? _a : defaultWindow;
  1290. const position = ref((_b = options.initialValue) != null ? _b : { x: 0, y: 0 });
  1291. const pressedDelta = ref();
  1292. const filterEvent = (e) => {
  1293. if (options.pointerTypes)
  1294. return options.pointerTypes.includes(e.pointerType);
  1295. return true;
  1296. };
  1297. const preventDefault = (e) => {
  1298. if (unref(options.preventDefault))
  1299. e.preventDefault();
  1300. };
  1301. const start = (e) => {
  1302. var _a2;
  1303. if (!filterEvent(e))
  1304. return;
  1305. if (unref(options.exact) && e.target !== unref(target))
  1306. return;
  1307. const rect = unref(target).getBoundingClientRect();
  1308. const pos = {
  1309. x: e.pageX - rect.left,
  1310. y: e.pageY - rect.top
  1311. };
  1312. if (((_a2 = options.onStart) == null ? void 0 : _a2.call(options, pos, e)) === false)
  1313. return;
  1314. pressedDelta.value = pos;
  1315. preventDefault(e);
  1316. };
  1317. const move = (e) => {
  1318. var _a2;
  1319. if (!filterEvent(e))
  1320. return;
  1321. if (!pressedDelta.value)
  1322. return;
  1323. position.value = {
  1324. x: e.pageX - pressedDelta.value.x,
  1325. y: e.pageY - pressedDelta.value.y
  1326. };
  1327. (_a2 = options.onMove) == null ? void 0 : _a2.call(options, position.value, e);
  1328. preventDefault(e);
  1329. };
  1330. const end = (e) => {
  1331. var _a2;
  1332. if (!filterEvent(e))
  1333. return;
  1334. pressedDelta.value = void 0;
  1335. (_a2 = options.onEnd) == null ? void 0 : _a2.call(options, position.value, e);
  1336. preventDefault(e);
  1337. };
  1338. if (isClient) {
  1339. useEventListener(target, "pointerdown", start, true);
  1340. useEventListener(draggingElement, "pointermove", move, true);
  1341. useEventListener(draggingElement, "pointerup", end, true);
  1342. }
  1343. return __spreadProps$3(__spreadValues$8({}, toRefs(position)), {
  1344. position,
  1345. isDragging: computed(() => !!pressedDelta.value),
  1346. style: computed(() => `left:${position.value.x}px;top:${position.value.y}px;`)
  1347. });
  1348. }
  1349. var __getOwnPropSymbols$9 = Object.getOwnPropertySymbols;
  1350. var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
  1351. var __propIsEnum$9 = Object.prototype.propertyIsEnumerable;
  1352. var __objRest$2 = (source, exclude) => {
  1353. var target = {};
  1354. for (var prop in source)
  1355. if (__hasOwnProp$9.call(source, prop) && exclude.indexOf(prop) < 0)
  1356. target[prop] = source[prop];
  1357. if (source != null && __getOwnPropSymbols$9)
  1358. for (var prop of __getOwnPropSymbols$9(source)) {
  1359. if (exclude.indexOf(prop) < 0 && __propIsEnum$9.call(source, prop))
  1360. target[prop] = source[prop];
  1361. }
  1362. return target;
  1363. };
  1364. function useResizeObserver(target, callback, options = {}) {
  1365. const _a = options, { window: window2 = defaultWindow } = _a, observerOptions = __objRest$2(_a, ["window"]);
  1366. let observer;
  1367. const isSupported = window2 && "ResizeObserver" in window2;
  1368. const cleanup = () => {
  1369. if (observer) {
  1370. observer.disconnect();
  1371. observer = void 0;
  1372. }
  1373. };
  1374. const stopWatch = watch(() => unrefElement(target), (el) => {
  1375. cleanup();
  1376. if (isSupported && window2 && el) {
  1377. observer = new window2.ResizeObserver(callback);
  1378. observer.observe(el, observerOptions);
  1379. }
  1380. }, { immediate: true, flush: "post" });
  1381. const stop = () => {
  1382. cleanup();
  1383. stopWatch();
  1384. };
  1385. tryOnScopeDispose(stop);
  1386. return {
  1387. isSupported,
  1388. stop
  1389. };
  1390. }
  1391. function useElementBounding(target, options = {}) {
  1392. const height = ref(0);
  1393. const bottom = ref(0);
  1394. const left = ref(0);
  1395. const right = ref(0);
  1396. const top = ref(0);
  1397. const width = ref(0);
  1398. const x = ref(0);
  1399. const y = ref(0);
  1400. useResizeObserver(target, ([entry]) => {
  1401. height.value = entry.contentRect.height;
  1402. bottom.value = entry.contentRect.bottom;
  1403. left.value = entry.contentRect.left;
  1404. right.value = entry.contentRect.right;
  1405. top.value = entry.contentRect.top;
  1406. width.value = entry.contentRect.width;
  1407. x.value = entry.contentRect.x;
  1408. y.value = entry.contentRect.y;
  1409. }, options);
  1410. return {
  1411. x,
  1412. y,
  1413. top,
  1414. right,
  1415. bottom,
  1416. left,
  1417. width,
  1418. height
  1419. };
  1420. }
  1421. function useElementHover(el) {
  1422. const isHovered = ref(false);
  1423. useEventListener(el, "mouseenter", () => isHovered.value = true);
  1424. useEventListener(el, "mouseleave", () => isHovered.value = false);
  1425. return isHovered;
  1426. }
  1427. function useElementSize(target, initialSize = { width: 0, height: 0 }, options = {}) {
  1428. const width = ref(initialSize.width);
  1429. const height = ref(initialSize.height);
  1430. useResizeObserver(target, ([entry]) => {
  1431. width.value = entry.contentRect.width;
  1432. height.value = entry.contentRect.height;
  1433. }, options);
  1434. return {
  1435. width,
  1436. height
  1437. };
  1438. }
  1439. function useElementVisibility(element, { window: window2 = defaultWindow, scrollTarget } = {}) {
  1440. const elementIsVisible = ref(false);
  1441. const testBounding = () => {
  1442. if (!window2)
  1443. return;
  1444. const document2 = window2.document;
  1445. if (!element.value) {
  1446. elementIsVisible.value = false;
  1447. } else {
  1448. const rect = element.value.getBoundingClientRect();
  1449. elementIsVisible.value = rect.top <= (window2.innerHeight || document2.documentElement.clientHeight) && rect.left <= (window2.innerWidth || document2.documentElement.clientWidth) && rect.bottom >= 0 && rect.right >= 0;
  1450. }
  1451. };
  1452. tryOnMounted(testBounding);
  1453. if (window2)
  1454. tryOnMounted(() => useEventListener((scrollTarget == null ? void 0 : scrollTarget.value) || window2, "scroll", testBounding, { capture: false, passive: true }));
  1455. return elementIsVisible;
  1456. }
  1457. var events = /* @__PURE__ */ new Map();
  1458. function useEventBus(key) {
  1459. const scope = getCurrentScope();
  1460. function on(listener) {
  1461. const listeners = events.get(key) || [];
  1462. listeners.push(listener);
  1463. events.set(key, listeners);
  1464. const _off = () => off(listener);
  1465. scope == null ? void 0 : scope.cleanups.push(_off);
  1466. return _off;
  1467. }
  1468. function once(listener) {
  1469. function _listener(...args) {
  1470. off(_listener);
  1471. listener(...args);
  1472. }
  1473. return on(_listener);
  1474. }
  1475. function off(listener) {
  1476. const listeners = events.get(key);
  1477. if (!listeners)
  1478. return;
  1479. const index = listeners.indexOf(listener);
  1480. if (index > -1)
  1481. listeners.splice(index, 1);
  1482. if (!listeners.length)
  1483. events.delete(key);
  1484. }
  1485. function reset() {
  1486. events.delete(key);
  1487. }
  1488. function emit(event) {
  1489. var _a;
  1490. (_a = events.get(key)) == null ? void 0 : _a.forEach((v) => v(event));
  1491. }
  1492. return { on, once, off, emit, reset };
  1493. }
  1494. function useEventSource(url, events2 = [], options = {}) {
  1495. const event = ref(null);
  1496. const data = ref(null);
  1497. const status = ref("CONNECTING");
  1498. const eventSource = ref(null);
  1499. const error = ref(null);
  1500. const {
  1501. withCredentials = false
  1502. } = options;
  1503. const close = () => {
  1504. if (eventSource.value) {
  1505. eventSource.value.close();
  1506. eventSource.value = null;
  1507. status.value = "CLOSED";
  1508. }
  1509. };
  1510. const es = new EventSource(url, { withCredentials });
  1511. eventSource.value = es;
  1512. es.onopen = () => {
  1513. status.value = "OPEN";
  1514. error.value = null;
  1515. };
  1516. es.onerror = (e) => {
  1517. status.value = "CLOSED";
  1518. error.value = e;
  1519. };
  1520. es.onmessage = (e) => {
  1521. event.value = null;
  1522. data.value = e.data;
  1523. };
  1524. for (const event_name of events2) {
  1525. useEventListener(es, event_name, (e) => {
  1526. event.value = event_name;
  1527. data.value = e.data || null;
  1528. });
  1529. }
  1530. tryOnScopeDispose(() => {
  1531. close();
  1532. });
  1533. return {
  1534. eventSource,
  1535. event,
  1536. data,
  1537. status,
  1538. error,
  1539. close
  1540. };
  1541. }
  1542. function useEyeDropper() {
  1543. const isSupported = Boolean(window && "EyeDropper" in window);
  1544. const sRGBHex = ref("");
  1545. function open() {
  1546. return __async(this, null, function* () {
  1547. const eyeDropper = new window.EyeDropper();
  1548. const result = yield eyeDropper.open();
  1549. sRGBHex.value = result.sRGBHex;
  1550. return result;
  1551. });
  1552. }
  1553. return { isSupported, sRGBHex, open };
  1554. }
  1555. function useFavicon(newIcon = null, options = {}) {
  1556. const {
  1557. baseUrl = "",
  1558. rel = "icon",
  1559. document: document2 = defaultDocument
  1560. } = options;
  1561. const favicon = isRef(newIcon) ? newIcon : ref(newIcon);
  1562. const applyIcon = (icon) => {
  1563. document2 == null ? void 0 : document2.head.querySelectorAll(`link[rel*="${rel}"]`).forEach((el) => el.href = `${baseUrl}${icon}`);
  1564. };
  1565. watch(favicon, (i, o) => {
  1566. if (isString(i) && i !== o)
  1567. applyIcon(i);
  1568. }, { immediate: true });
  1569. return favicon;
  1570. }
  1571. var __defProp$7 = Object.defineProperty;
  1572. var __defProps$2 = Object.defineProperties;
  1573. var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
  1574. var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
  1575. var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
  1576. var __propIsEnum$8 = Object.prototype.propertyIsEnumerable;
  1577. var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  1578. var __spreadValues$7 = (a, b) => {
  1579. for (var prop in b || (b = {}))
  1580. if (__hasOwnProp$8.call(b, prop))
  1581. __defNormalProp$7(a, prop, b[prop]);
  1582. if (__getOwnPropSymbols$8)
  1583. for (var prop of __getOwnPropSymbols$8(b)) {
  1584. if (__propIsEnum$8.call(b, prop))
  1585. __defNormalProp$7(a, prop, b[prop]);
  1586. }
  1587. return a;
  1588. };
  1589. var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
  1590. var payloadMapping = {
  1591. json: "application/json",
  1592. text: "text/plain",
  1593. formData: "multipart/form-data"
  1594. };
  1595. function isFetchOptions(obj) {
  1596. return containsProp(obj, "immediate", "refetch", "initialData", "timeout", "beforeFetch", "afterFetch", "onFetchError");
  1597. }
  1598. function headersToObject(headers) {
  1599. if (headers instanceof Headers)
  1600. return Object.fromEntries([...headers.entries()]);
  1601. return headers;
  1602. }
  1603. function createFetch(config = {}) {
  1604. const _options = config.options || {};
  1605. const _fetchOptions = config.fetchOptions || {};
  1606. function useFactoryFetch(url, ...args) {
  1607. const computedUrl = computed(() => config.baseUrl ? joinPaths(unref(config.baseUrl), unref(url)) : unref(url));
  1608. let options = _options;
  1609. let fetchOptions = _fetchOptions;
  1610. if (args.length > 0) {
  1611. if (isFetchOptions(args[0])) {
  1612. options = __spreadValues$7(__spreadValues$7({}, options), args[0]);
  1613. } else {
  1614. fetchOptions = __spreadProps$2(__spreadValues$7(__spreadValues$7({}, fetchOptions), args[0]), {
  1615. headers: __spreadValues$7(__spreadValues$7({}, headersToObject(fetchOptions.headers) || {}), headersToObject(args[0].headers) || {})
  1616. });
  1617. }
  1618. }
  1619. if (args.length > 1 && isFetchOptions(args[1]))
  1620. options = __spreadValues$7(__spreadValues$7({}, options), args[1]);
  1621. return useFetch(computedUrl, fetchOptions, options);
  1622. }
  1623. return useFactoryFetch;
  1624. }
  1625. function useFetch(url, ...args) {
  1626. var _a;
  1627. const supportsAbort = typeof AbortController === "function";
  1628. let fetchOptions = {};
  1629. let options = { immediate: true, refetch: false, timeout: 0 };
  1630. const config = {
  1631. method: "get",
  1632. type: "text",
  1633. payload: void 0
  1634. };
  1635. if (args.length > 0) {
  1636. if (isFetchOptions(args[0]))
  1637. options = __spreadValues$7(__spreadValues$7({}, options), args[0]);
  1638. else
  1639. fetchOptions = args[0];
  1640. }
  1641. if (args.length > 1) {
  1642. if (isFetchOptions(args[1]))
  1643. options = __spreadValues$7(__spreadValues$7({}, options), args[1]);
  1644. }
  1645. const {
  1646. fetch = (_a = defaultWindow) == null ? void 0 : _a.fetch,
  1647. initialData,
  1648. timeout
  1649. } = options;
  1650. const responseEvent = createEventHook();
  1651. const errorEvent = createEventHook();
  1652. const finallyEvent = createEventHook();
  1653. const isFinished = ref(false);
  1654. const isFetching = ref(false);
  1655. const aborted = ref(false);
  1656. const statusCode = ref(null);
  1657. const response = shallowRef(null);
  1658. const error = ref(null);
  1659. const data = shallowRef(initialData);
  1660. const canAbort = computed(() => supportsAbort && isFetching.value);
  1661. let controller;
  1662. let timer;
  1663. const abort = () => {
  1664. if (supportsAbort && controller)
  1665. controller.abort();
  1666. };
  1667. const loading = (isLoading) => {
  1668. isFetching.value = isLoading;
  1669. isFinished.value = !isLoading;
  1670. };
  1671. if (timeout)
  1672. timer = useTimeoutFn(abort, timeout, { immediate: false });
  1673. const execute = (throwOnFailed = false) => __async(this, null, function* () {
  1674. var _a2;
  1675. loading(true);
  1676. error.value = null;
  1677. statusCode.value = null;
  1678. aborted.value = false;
  1679. controller = void 0;
  1680. if (supportsAbort) {
  1681. controller = new AbortController();
  1682. controller.signal.onabort = () => aborted.value = true;
  1683. fetchOptions = __spreadProps$2(__spreadValues$7({}, fetchOptions), {
  1684. signal: controller.signal
  1685. });
  1686. }
  1687. const defaultFetchOptions = {
  1688. method: config.method,
  1689. headers: {}
  1690. };
  1691. if (config.payload) {
  1692. const headers = headersToObject(defaultFetchOptions.headers);
  1693. if (config.payloadType)
  1694. headers["Content-Type"] = (_a2 = payloadMapping[config.payloadType]) != null ? _a2 : config.payloadType;
  1695. defaultFetchOptions.body = config.payloadType === "json" ? JSON.stringify(unref(config.payload)) : unref(config.payload);
  1696. }
  1697. let isCanceled = false;
  1698. const context = { url: unref(url), options: fetchOptions, cancel: () => {
  1699. isCanceled = true;
  1700. } };
  1701. if (options.beforeFetch)
  1702. Object.assign(context, yield options.beforeFetch(context));
  1703. if (isCanceled || !fetch) {
  1704. loading(false);
  1705. return Promise.resolve();
  1706. }
  1707. let responseData = null;
  1708. if (timer)
  1709. timer.start();
  1710. return new Promise((resolve, reject) => {
  1711. var _a3;
  1712. fetch(context.url, __spreadProps$2(__spreadValues$7(__spreadValues$7({}, defaultFetchOptions), context.options), {
  1713. headers: __spreadValues$7(__spreadValues$7({}, headersToObject(defaultFetchOptions.headers)), headersToObject((_a3 = context.options) == null ? void 0 : _a3.headers))
  1714. })).then((fetchResponse) => __async(this, null, function* () {
  1715. response.value = fetchResponse;
  1716. statusCode.value = fetchResponse.status;
  1717. responseData = yield fetchResponse[config.type]();
  1718. if (options.afterFetch)
  1719. ({ data: responseData } = yield options.afterFetch({ data: responseData, response: fetchResponse }));
  1720. data.value = responseData;
  1721. if (!fetchResponse.ok)
  1722. throw new Error(fetchResponse.statusText);
  1723. responseEvent.trigger(fetchResponse);
  1724. resolve(fetchResponse);
  1725. })).catch((fetchError) => __async(this, null, function* () {
  1726. let errorData = fetchError.message || fetchError.name;
  1727. if (options.onFetchError)
  1728. ({ data: responseData, error: errorData } = yield options.onFetchError({ data: responseData, error: fetchError }));
  1729. data.value = responseData;
  1730. error.value = errorData;
  1731. errorEvent.trigger(fetchError);
  1732. if (throwOnFailed)
  1733. reject(fetchError);
  1734. else
  1735. resolve(void 0);
  1736. })).finally(() => {
  1737. loading(false);
  1738. if (timer)
  1739. timer.stop();
  1740. finallyEvent.trigger(null);
  1741. });
  1742. });
  1743. });
  1744. watch(() => [
  1745. unref(url),
  1746. unref(options.refetch)
  1747. ], () => unref(options.refetch) && execute(), { deep: true });
  1748. const shell = {
  1749. isFinished,
  1750. statusCode,
  1751. response,
  1752. error,
  1753. data,
  1754. isFetching,
  1755. canAbort,
  1756. aborted,
  1757. abort,
  1758. execute,
  1759. onFetchResponse: responseEvent.on,
  1760. onFetchError: errorEvent.on,
  1761. onFetchFinally: finallyEvent.on,
  1762. get: setMethod("get"),
  1763. put: setMethod("put"),
  1764. post: setMethod("post"),
  1765. delete: setMethod("delete"),
  1766. json: setType("json"),
  1767. text: setType("text"),
  1768. blob: setType("blob"),
  1769. arrayBuffer: setType("arrayBuffer"),
  1770. formData: setType("formData")
  1771. };
  1772. function setMethod(method) {
  1773. return (payload, payloadType) => {
  1774. if (!isFetching.value) {
  1775. config.method = method;
  1776. config.payload = payload;
  1777. config.payloadType = payloadType;
  1778. if (isRef(config.payload)) {
  1779. watch(() => [
  1780. unref(config.payload),
  1781. unref(options.refetch)
  1782. ], () => unref(options.refetch) && execute(), { deep: true });
  1783. }
  1784. if (!payloadType && unref(payload) && Object.getPrototypeOf(unref(payload)) === Object.prototype)
  1785. config.payloadType = "json";
  1786. return shell;
  1787. }
  1788. return void 0;
  1789. };
  1790. }
  1791. function setType(type) {
  1792. return () => {
  1793. if (!isFetching.value) {
  1794. config.type = type;
  1795. return shell;
  1796. }
  1797. return void 0;
  1798. };
  1799. }
  1800. if (options.immediate)
  1801. setTimeout(execute, 0);
  1802. return shell;
  1803. }
  1804. function joinPaths(start, end) {
  1805. if (!start.endsWith("/") && !end.startsWith("/"))
  1806. return `${start}/${end}`;
  1807. return `${start}${end}`;
  1808. }
  1809. function useFocus(options = {}) {
  1810. const {
  1811. initialValue = false
  1812. } = options;
  1813. const activeElement = useActiveElement(options);
  1814. const target = computed(() => unrefElement(options.target));
  1815. const focused = computed({
  1816. get() {
  1817. return activeElement.value === target.value;
  1818. },
  1819. set(value) {
  1820. var _a, _b;
  1821. if (!value && focused.value)
  1822. (_a = target.value) == null ? void 0 : _a.blur();
  1823. if (value && !focused.value)
  1824. (_b = target.value) == null ? void 0 : _b.focus();
  1825. }
  1826. });
  1827. watch(target, () => {
  1828. focused.value = initialValue;
  1829. }, { immediate: true, flush: "post" });
  1830. return { focused };
  1831. }
  1832. function useRafFn(fn, options = {}) {
  1833. const {
  1834. immediate = true,
  1835. window: window2 = defaultWindow
  1836. } = options;
  1837. const isActive = ref(false);
  1838. function loop() {
  1839. if (!isActive.value)
  1840. return;
  1841. fn();
  1842. if (window2)
  1843. window2.requestAnimationFrame(loop);
  1844. }
  1845. function resume() {
  1846. if (!isActive.value) {
  1847. isActive.value = true;
  1848. loop();
  1849. }
  1850. }
  1851. function pause() {
  1852. isActive.value = false;
  1853. }
  1854. if (immediate)
  1855. resume();
  1856. tryOnScopeDispose(pause);
  1857. return {
  1858. isActive,
  1859. pause,
  1860. resume
  1861. };
  1862. }
  1863. function useFps(options) {
  1864. var _a;
  1865. const fps = ref(0);
  1866. const every = (_a = options == null ? void 0 : options.every) != null ? _a : 10;
  1867. let last = performance.now();
  1868. let ticks = 0;
  1869. useRafFn(() => {
  1870. ticks += 1;
  1871. if (ticks >= every) {
  1872. const now2 = performance.now();
  1873. const diff = now2 - last;
  1874. fps.value = Math.round(1e3 / (diff / ticks));
  1875. last = now2;
  1876. ticks = 0;
  1877. }
  1878. });
  1879. return fps;
  1880. }
  1881. var functionsMap = [
  1882. [
  1883. "requestFullscreen",
  1884. "exitFullscreen",
  1885. "fullscreenElement",
  1886. "fullscreenEnabled",
  1887. "fullscreenchange",
  1888. "fullscreenerror"
  1889. ],
  1890. [
  1891. "webkitRequestFullscreen",
  1892. "webkitExitFullscreen",
  1893. "webkitFullscreenElement",
  1894. "webkitFullscreenEnabled",
  1895. "webkitfullscreenchange",
  1896. "webkitfullscreenerror"
  1897. ],
  1898. [
  1899. "webkitRequestFullScreen",
  1900. "webkitCancelFullScreen",
  1901. "webkitCurrentFullScreenElement",
  1902. "webkitCancelFullScreen",
  1903. "webkitfullscreenchange",
  1904. "webkitfullscreenerror"
  1905. ],
  1906. [
  1907. "mozRequestFullScreen",
  1908. "mozCancelFullScreen",
  1909. "mozFullScreenElement",
  1910. "mozFullScreenEnabled",
  1911. "mozfullscreenchange",
  1912. "mozfullscreenerror"
  1913. ],
  1914. [
  1915. "msRequestFullscreen",
  1916. "msExitFullscreen",
  1917. "msFullscreenElement",
  1918. "msFullscreenEnabled",
  1919. "MSFullscreenChange",
  1920. "MSFullscreenError"
  1921. ]
  1922. ];
  1923. function useFullscreen(target, options = {}) {
  1924. const { document: document2 = defaultDocument } = options;
  1925. const targetRef = target || (document2 == null ? void 0 : document2.querySelector("html"));
  1926. const isFullscreen = ref(false);
  1927. let isSupported = false;
  1928. let map = functionsMap[0];
  1929. if (!document2) {
  1930. isSupported = false;
  1931. } else {
  1932. for (const m of functionsMap) {
  1933. if (m[1] in document2) {
  1934. map = m;
  1935. isSupported = true;
  1936. break;
  1937. }
  1938. }
  1939. }
  1940. const [REQUEST, EXIT, ELEMENT, , EVENT] = map;
  1941. function exit() {
  1942. return __async(this, null, function* () {
  1943. if (!isSupported)
  1944. return;
  1945. if (document2 == null ? void 0 : document2[ELEMENT])
  1946. yield document2[EXIT]();
  1947. isFullscreen.value = false;
  1948. });
  1949. }
  1950. function enter() {
  1951. return __async(this, null, function* () {
  1952. if (!isSupported)
  1953. return;
  1954. yield exit();
  1955. const target2 = unrefElement(targetRef);
  1956. if (target2) {
  1957. yield target2[REQUEST]();
  1958. isFullscreen.value = true;
  1959. }
  1960. });
  1961. }
  1962. function toggle() {
  1963. return __async(this, null, function* () {
  1964. if (isFullscreen.value)
  1965. yield exit();
  1966. else
  1967. yield enter();
  1968. });
  1969. }
  1970. if (document2) {
  1971. useEventListener(document2, EVENT, () => {
  1972. isFullscreen.value = !!(document2 == null ? void 0 : document2[ELEMENT]);
  1973. }, false);
  1974. }
  1975. return {
  1976. isSupported,
  1977. isFullscreen,
  1978. enter,
  1979. exit,
  1980. toggle
  1981. };
  1982. }
  1983. function useGeolocation(options = {}) {
  1984. const {
  1985. enableHighAccuracy = true,
  1986. maximumAge = 3e4,
  1987. timeout = 27e3,
  1988. navigator = defaultNavigator
  1989. } = options;
  1990. const isSupported = navigator && "geolocation" in navigator;
  1991. const locatedAt = ref(null);
  1992. const error = ref(null);
  1993. const coords = ref({
  1994. accuracy: 0,
  1995. latitude: 0,
  1996. longitude: 0,
  1997. altitude: null,
  1998. altitudeAccuracy: null,
  1999. heading: null,
  2000. speed: null
  2001. });
  2002. function updatePosition(position) {
  2003. locatedAt.value = position.timestamp;
  2004. coords.value = position.coords;
  2005. error.value = null;
  2006. }
  2007. let watcher;
  2008. if (isSupported) {
  2009. watcher = navigator.geolocation.watchPosition(updatePosition, (err) => error.value = err, {
  2010. enableHighAccuracy,
  2011. maximumAge,
  2012. timeout
  2013. });
  2014. }
  2015. tryOnScopeDispose(() => {
  2016. if (watcher && navigator)
  2017. navigator.geolocation.clearWatch(watcher);
  2018. });
  2019. return {
  2020. isSupported,
  2021. coords,
  2022. locatedAt,
  2023. error
  2024. };
  2025. }
  2026. var defaultEvents$1 = ["mousemove", "mousedown", "resize", "keydown", "touchstart", "wheel"];
  2027. var oneMinute = 6e4;
  2028. function useIdle(timeout = oneMinute, options = {}) {
  2029. const {
  2030. initialState = false,
  2031. listenForVisibilityChange = true,
  2032. events: events2 = defaultEvents$1,
  2033. window: window2 = defaultWindow,
  2034. eventFilter = throttleFilter(50)
  2035. } = options;
  2036. const idle = ref(initialState);
  2037. const lastActive = ref(timestamp());
  2038. let timer;
  2039. const onEvent = createFilterWrapper(eventFilter, () => {
  2040. idle.value = false;
  2041. lastActive.value = timestamp();
  2042. clearTimeout(timer);
  2043. timer = setTimeout(() => idle.value = true, timeout);
  2044. });
  2045. if (window2) {
  2046. const document2 = window2.document;
  2047. for (const event of events2)
  2048. useEventListener(window2, event, onEvent, { passive: true });
  2049. if (listenForVisibilityChange) {
  2050. useEventListener(document2, "visibilitychange", () => {
  2051. if (!document2.hidden)
  2052. onEvent();
  2053. });
  2054. }
  2055. }
  2056. timer = setTimeout(() => idle.value = true, timeout);
  2057. return { idle, lastActive };
  2058. }
  2059. function useIntersectionObserver(target, callback, options = {}) {
  2060. const {
  2061. root,
  2062. rootMargin = "0px",
  2063. threshold = 0.1,
  2064. window: window2 = defaultWindow
  2065. } = options;
  2066. const isSupported = window2 && "IntersectionObserver" in window2;
  2067. let cleanup = noop;
  2068. const stopWatch = isSupported ? watch(() => ({
  2069. el: unrefElement(target),
  2070. root: unrefElement(root)
  2071. }), ({ el, root: root2 }) => {
  2072. cleanup();
  2073. if (!el)
  2074. return;
  2075. const observer = new window2.IntersectionObserver(callback, {
  2076. root: root2,
  2077. rootMargin,
  2078. threshold
  2079. });
  2080. observer.observe(el);
  2081. cleanup = () => {
  2082. observer.disconnect();
  2083. cleanup = noop;
  2084. };
  2085. }, { immediate: true, flush: "post" }) : noop;
  2086. const stop = () => {
  2087. cleanup();
  2088. stopWatch();
  2089. };
  2090. tryOnScopeDispose(stop);
  2091. return {
  2092. isSupported,
  2093. stop
  2094. };
  2095. }
  2096. var defaultEvents = ["mousedown", "mouseup", "keydown", "keyup"];
  2097. function useKeyModifier(modifier, options = {}) {
  2098. const {
  2099. events: events2 = defaultEvents,
  2100. document: document2 = defaultDocument,
  2101. initial = null
  2102. } = options;
  2103. const state = ref(initial);
  2104. if (document2) {
  2105. events2.forEach((listenerEvent) => {
  2106. useEventListener(document2, listenerEvent, (evt) => {
  2107. state.value = evt.getModifierState(modifier);
  2108. });
  2109. });
  2110. }
  2111. return state;
  2112. }
  2113. function useLocalStorage(key, initialValue, options = {}) {
  2114. const { window: window2 = defaultWindow } = options;
  2115. return useStorage(key, initialValue, window2 == null ? void 0 : window2.localStorage, options);
  2116. }
  2117. var DefaultMagicKeysAliasMap = {
  2118. ctrl: "control",
  2119. command: "meta",
  2120. cmd: "meta",
  2121. option: "alt",
  2122. up: "arrowup",
  2123. down: "arrowdown",
  2124. left: "arrowleft",
  2125. right: "arrowright"
  2126. };
  2127. function useMagicKeys(options = {}) {
  2128. const {
  2129. reactive: useReactive = false,
  2130. target = defaultWindow,
  2131. aliasMap = DefaultMagicKeysAliasMap,
  2132. passive = true,
  2133. onEventFired = noop
  2134. } = options;
  2135. const current = reactive(/* @__PURE__ */ new Set());
  2136. const obj = { toJSON() {
  2137. return {};
  2138. }, current };
  2139. const refs = useReactive ? reactive(obj) : obj;
  2140. function updateRefs(e, value) {
  2141. const key = e.key.toLowerCase();
  2142. const code = e.code.toLowerCase();
  2143. const values = [code, key];
  2144. if (value)
  2145. current.add(e.code);
  2146. else
  2147. current.delete(e.code);
  2148. for (const key2 of values) {
  2149. if (key2 in refs) {
  2150. if (useReactive)
  2151. refs[key2] = value;
  2152. else
  2153. refs[key2].value = value;
  2154. }
  2155. }
  2156. }
  2157. if (target) {
  2158. useEventListener(target, "keydown", (e) => {
  2159. updateRefs(e, true);
  2160. return onEventFired(e);
  2161. }, { passive });
  2162. useEventListener(target, "keyup", (e) => {
  2163. updateRefs(e, false);
  2164. return onEventFired(e);
  2165. }, { passive });
  2166. }
  2167. const proxy = new Proxy(refs, {
  2168. get(target2, prop, rec) {
  2169. if (typeof prop !== "string")
  2170. return Reflect.get(target2, prop, rec);
  2171. prop = prop.toLowerCase();
  2172. if (prop in aliasMap)
  2173. prop = aliasMap[prop];
  2174. if (!(prop in refs)) {
  2175. if (/[+_-]/.test(prop)) {
  2176. const keys2 = prop.split(/[+_-]/g).map((i) => i.trim());
  2177. refs[prop] = computed(() => keys2.every((key) => unref(proxy[key])));
  2178. } else {
  2179. refs[prop] = ref(false);
  2180. }
  2181. }
  2182. const r = Reflect.get(target2, prop, rec);
  2183. return useReactive ? unref(r) : r;
  2184. }
  2185. });
  2186. return proxy;
  2187. }
  2188. var __defProp$6 = Object.defineProperty;
  2189. var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
  2190. var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
  2191. var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
  2192. var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  2193. var __spreadValues$6 = (a, b) => {
  2194. for (var prop in b || (b = {}))
  2195. if (__hasOwnProp$7.call(b, prop))
  2196. __defNormalProp$6(a, prop, b[prop]);
  2197. if (__getOwnPropSymbols$7)
  2198. for (var prop of __getOwnPropSymbols$7(b)) {
  2199. if (__propIsEnum$7.call(b, prop))
  2200. __defNormalProp$6(a, prop, b[prop]);
  2201. }
  2202. return a;
  2203. };
  2204. function usingElRef(source, cb) {
  2205. if (unref(source))
  2206. cb(unref(source));
  2207. }
  2208. function timeRangeToArray(timeRanges) {
  2209. let ranges = [];
  2210. for (let i = 0; i < timeRanges.length; ++i)
  2211. ranges = [...ranges, [timeRanges.start(i), timeRanges.end(i)]];
  2212. return ranges;
  2213. }
  2214. function tracksToArray(tracks) {
  2215. return Array.from(tracks).map(({ label, kind, language, mode, activeCues, cues, inBandMetadataTrackDispatchType }, id) => ({ id, label, kind, language, mode, activeCues, cues, inBandMetadataTrackDispatchType }));
  2216. }
  2217. var defaultOptions = {
  2218. src: "",
  2219. tracks: []
  2220. };
  2221. function useMediaControls(target, options = {}) {
  2222. options = __spreadValues$6(__spreadValues$6({}, defaultOptions), options);
  2223. const {
  2224. document: document2 = defaultDocument
  2225. } = options;
  2226. const currentTime = ref(0);
  2227. const duration = ref(0);
  2228. const seeking = ref(false);
  2229. const volume = ref(1);
  2230. const waiting = ref(false);
  2231. const ended = ref(false);
  2232. const playing = ref(false);
  2233. const rate = ref(1);
  2234. const stalled = ref(false);
  2235. const buffered = ref([]);
  2236. const tracks = ref([]);
  2237. const selectedTrack = ref(-1);
  2238. const isPictureInPicture = ref(false);
  2239. const muted = ref(false);
  2240. const supportsPictureInPicture = document2 && "pictureInPictureEnabled" in document2;
  2241. const sourceErrorEvent = createEventHook();
  2242. const disableTrack = (track) => {
  2243. usingElRef(target, (el) => {
  2244. if (track) {
  2245. const id = isNumber(track) ? track : track.id;
  2246. el.textTracks[id].mode = "disabled";
  2247. } else {
  2248. for (let i = 0; i < el.textTracks.length; ++i)
  2249. el.textTracks[i].mode = "disabled";
  2250. }
  2251. selectedTrack.value = -1;
  2252. });
  2253. };
  2254. const enableTrack = (track, disableTracks = true) => {
  2255. usingElRef(target, (el) => {
  2256. const id = isNumber(track) ? track : track.id;
  2257. if (disableTracks)
  2258. disableTrack();
  2259. el.textTracks[id].mode = "showing";
  2260. selectedTrack.value = id;
  2261. });
  2262. };
  2263. const togglePictureInPicture = () => {
  2264. return new Promise((resolve, reject) => {
  2265. usingElRef(target, (el) => __async(this, null, function* () {
  2266. if (supportsPictureInPicture) {
  2267. if (!isPictureInPicture.value) {
  2268. el.requestPictureInPicture().then(resolve).catch(reject);
  2269. } else {
  2270. document2.exitPictureInPicture().then(resolve).catch(reject);
  2271. }
  2272. }
  2273. }));
  2274. });
  2275. };
  2276. watchEffect(() => {
  2277. if (!document2)
  2278. return;
  2279. const el = unref(target);
  2280. if (!el)
  2281. return;
  2282. const src = unref(options.src);
  2283. let sources = [];
  2284. if (!src)
  2285. return;
  2286. if (isString(src))
  2287. sources = [{ src }];
  2288. else if (Array.isArray(src))
  2289. sources = src;
  2290. else if (isObject(src))
  2291. sources = [src];
  2292. el.querySelectorAll("source").forEach((e) => {
  2293. e.removeEventListener("error", sourceErrorEvent.trigger);
  2294. e.remove();
  2295. });
  2296. sources.forEach(({ src: src2, type }) => {
  2297. const source = document2.createElement("source");
  2298. source.setAttribute("src", src2);
  2299. source.setAttribute("type", type || "");
  2300. source.addEventListener("error", sourceErrorEvent.trigger);
  2301. el.appendChild(source);
  2302. });
  2303. el.load();
  2304. });
  2305. tryOnScopeDispose(() => {
  2306. const el = unref(target);
  2307. if (!el)
  2308. return;
  2309. el.querySelectorAll("source").forEach((e) => e.removeEventListener("error", sourceErrorEvent.trigger));
  2310. });
  2311. watch(volume, (vol) => {
  2312. const el = unref(target);
  2313. if (!el)
  2314. return;
  2315. el.volume = vol;
  2316. });
  2317. watch(muted, (mute) => {
  2318. const el = unref(target);
  2319. if (!el)
  2320. return;
  2321. el.muted = mute;
  2322. });
  2323. watchEffect(() => {
  2324. if (!document2)
  2325. return;
  2326. const textTracks = unref(options.tracks);
  2327. const el = unref(target);
  2328. if (!textTracks || !textTracks.length || !el)
  2329. return;
  2330. el.querySelectorAll("track").forEach((e) => e.remove());
  2331. textTracks.forEach(({ default: isDefault, kind, label, src, srcLang }, i) => {
  2332. const track = document2.createElement("track");
  2333. track.default = isDefault || false;
  2334. track.kind = kind;
  2335. track.label = label;
  2336. track.src = src;
  2337. track.srclang = srcLang;
  2338. if (track.default)
  2339. selectedTrack.value = i;
  2340. el.appendChild(track);
  2341. });
  2342. });
  2343. const { ignoreUpdates: ignoreCurrentTimeUpdates } = ignorableWatch(currentTime, (time) => {
  2344. const el = unref(target);
  2345. if (!el)
  2346. return;
  2347. el.currentTime = time;
  2348. });
  2349. const { ignoreUpdates: ignorePlayingUpdates } = ignorableWatch(playing, (isPlaying) => {
  2350. const el = unref(target);
  2351. if (!el)
  2352. return;
  2353. isPlaying ? el.play() : el.pause();
  2354. });
  2355. useEventListener(target, "timeupdate", () => ignoreCurrentTimeUpdates(() => currentTime.value = unref(target).currentTime));
  2356. useEventListener(target, "durationchange", () => duration.value = unref(target).duration);
  2357. useEventListener(target, "progress", () => buffered.value = timeRangeToArray(unref(target).buffered));
  2358. useEventListener(target, "seeking", () => seeking.value = true);
  2359. useEventListener(target, "seeked", () => seeking.value = false);
  2360. useEventListener(target, "waiting", () => waiting.value = true);
  2361. useEventListener(target, "playing", () => waiting.value = false);
  2362. useEventListener(target, "ratechange", () => rate.value = unref(target).playbackRate);
  2363. useEventListener(target, "stalled", () => stalled.value = true);
  2364. useEventListener(target, "ended", () => ended.value = true);
  2365. useEventListener(target, "pause", () => ignorePlayingUpdates(() => playing.value = false));
  2366. useEventListener(target, "play", () => ignorePlayingUpdates(() => playing.value = true));
  2367. useEventListener(target, "enterpictureinpicture", () => isPictureInPicture.value = true);
  2368. useEventListener(target, "leavepictureinpicture", () => isPictureInPicture.value = false);
  2369. useEventListener(target, "volumechange", () => {
  2370. const el = unref(target);
  2371. if (!el)
  2372. return;
  2373. volume.value = el.volume;
  2374. muted.value = el.muted;
  2375. });
  2376. const listeners = [];
  2377. const stop = watch([target], () => {
  2378. const el = unref(target);
  2379. if (!el)
  2380. return;
  2381. stop();
  2382. listeners[0] = useEventListener(el.textTracks, "addtrack", () => tracks.value = tracksToArray(el.textTracks));
  2383. listeners[1] = useEventListener(el.textTracks, "removetrack", () => tracks.value = tracksToArray(el.textTracks));
  2384. listeners[2] = useEventListener(el.textTracks, "change", () => tracks.value = tracksToArray(el.textTracks));
  2385. });
  2386. tryOnScopeDispose(() => listeners.forEach((listener) => listener()));
  2387. return {
  2388. currentTime,
  2389. duration,
  2390. waiting,
  2391. seeking,
  2392. ended,
  2393. stalled,
  2394. buffered,
  2395. playing,
  2396. volume,
  2397. muted,
  2398. tracks,
  2399. selectedTrack,
  2400. enableTrack,
  2401. disableTrack,
  2402. supportsPictureInPicture,
  2403. togglePictureInPicture,
  2404. isPictureInPicture,
  2405. onSourceError: sourceErrorEvent.on
  2406. };
  2407. }
  2408. function useMemory(options = {}) {
  2409. const memory = ref();
  2410. const isSupported = performance && "memory" in performance;
  2411. if (isSupported) {
  2412. const { interval = 1e3 } = options;
  2413. useIntervalFn(() => {
  2414. memory.value = performance.memory;
  2415. }, interval, { immediate: options.immediate, immediateCallback: options.immediateCallback });
  2416. }
  2417. return { isSupported, memory };
  2418. }
  2419. function useMouse(options = {}) {
  2420. const {
  2421. touch = true,
  2422. resetOnTouchEnds = false,
  2423. initialValue = { x: 0, y: 0 },
  2424. window: window2 = defaultWindow
  2425. } = options;
  2426. const x = ref(initialValue.x);
  2427. const y = ref(initialValue.y);
  2428. const sourceType = ref(null);
  2429. const mouseHandler = (event) => {
  2430. x.value = event.pageX;
  2431. y.value = event.pageY;
  2432. sourceType.value = "mouse";
  2433. };
  2434. const reset = () => {
  2435. x.value = initialValue.x;
  2436. y.value = initialValue.y;
  2437. };
  2438. const touchHandler = (event) => {
  2439. if (event.touches.length > 0) {
  2440. x.value = event.touches[0].clientX;
  2441. y.value = event.touches[0].clientY;
  2442. sourceType.value = "touch";
  2443. }
  2444. };
  2445. if (window2) {
  2446. useEventListener(window2, "mousemove", mouseHandler, { passive: true });
  2447. useEventListener(window2, "dragover", mouseHandler, { passive: true });
  2448. if (touch) {
  2449. useEventListener(window2, "touchstart", touchHandler, { passive: true });
  2450. useEventListener(window2, "touchmove", touchHandler, { passive: true });
  2451. if (resetOnTouchEnds)
  2452. useEventListener(window2, "touchend", reset, { passive: true });
  2453. }
  2454. }
  2455. return {
  2456. x,
  2457. y,
  2458. sourceType
  2459. };
  2460. }
  2461. function useMouseInElement(target, options = {}) {
  2462. const {
  2463. handleOutside = true,
  2464. window: window2 = defaultWindow
  2465. } = options;
  2466. const { x, y, sourceType } = useMouse(options);
  2467. const targetRef = ref(target != null ? target : window2 == null ? void 0 : window2.document.body);
  2468. const elementX = ref(0);
  2469. const elementY = ref(0);
  2470. const elementPositionX = ref(0);
  2471. const elementPositionY = ref(0);
  2472. const elementHeight = ref(0);
  2473. const elementWidth = ref(0);
  2474. const isOutside = ref(false);
  2475. let stop = () => {
  2476. };
  2477. if (window2) {
  2478. stop = watch([targetRef, x, y], () => {
  2479. const el = unrefElement(targetRef);
  2480. if (!el)
  2481. return;
  2482. const {
  2483. left,
  2484. top,
  2485. width,
  2486. height
  2487. } = el.getBoundingClientRect();
  2488. elementPositionX.value = left + window2.pageXOffset;
  2489. elementPositionY.value = top + window2.pageYOffset;
  2490. elementHeight.value = height;
  2491. elementWidth.value = width;
  2492. const elX = x.value - elementPositionX.value;
  2493. const elY = y.value - elementPositionY.value;
  2494. isOutside.value = elX < 0 || elY < 0 || elX > elementWidth.value || elY > elementHeight.value;
  2495. if (handleOutside || !isOutside.value) {
  2496. elementX.value = elX;
  2497. elementY.value = elY;
  2498. }
  2499. }, { immediate: true });
  2500. }
  2501. return {
  2502. x,
  2503. y,
  2504. sourceType,
  2505. elementX,
  2506. elementY,
  2507. elementPositionX,
  2508. elementPositionY,
  2509. elementHeight,
  2510. elementWidth,
  2511. isOutside,
  2512. stop
  2513. };
  2514. }
  2515. function useMousePressed(options = {}) {
  2516. const {
  2517. touch = true,
  2518. drag = true,
  2519. initialValue = false,
  2520. window: window2 = defaultWindow
  2521. } = options;
  2522. const pressed = ref(initialValue);
  2523. const sourceType = ref(null);
  2524. if (!window2) {
  2525. return {
  2526. pressed,
  2527. sourceType
  2528. };
  2529. }
  2530. const onPressed = (srcType) => () => {
  2531. pressed.value = true;
  2532. sourceType.value = srcType;
  2533. };
  2534. const onReleased = () => {
  2535. pressed.value = false;
  2536. sourceType.value = null;
  2537. };
  2538. const target = computed(() => unrefElement(options.target) || window2);
  2539. useEventListener(target, "mousedown", onPressed("mouse"), { passive: true });
  2540. useEventListener(window2, "mouseleave", onReleased, { passive: true });
  2541. useEventListener(window2, "mouseup", onReleased, { passive: true });
  2542. if (drag) {
  2543. useEventListener(target, "dragstart", onPressed("mouse"), { passive: true });
  2544. useEventListener(window2, "drop", onReleased, { passive: true });
  2545. useEventListener(window2, "dragend", onReleased, { passive: true });
  2546. }
  2547. if (touch) {
  2548. useEventListener(target, "touchstart", onPressed("touch"), { passive: true });
  2549. useEventListener(window2, "touchend", onReleased, { passive: true });
  2550. useEventListener(window2, "touchcancel", onReleased, { passive: true });
  2551. }
  2552. return {
  2553. pressed,
  2554. sourceType
  2555. };
  2556. }
  2557. var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
  2558. var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
  2559. var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
  2560. var __objRest$1 = (source, exclude) => {
  2561. var target = {};
  2562. for (var prop in source)
  2563. if (__hasOwnProp$6.call(source, prop) && exclude.indexOf(prop) < 0)
  2564. target[prop] = source[prop];
  2565. if (source != null && __getOwnPropSymbols$6)
  2566. for (var prop of __getOwnPropSymbols$6(source)) {
  2567. if (exclude.indexOf(prop) < 0 && __propIsEnum$6.call(source, prop))
  2568. target[prop] = source[prop];
  2569. }
  2570. return target;
  2571. };
  2572. function useMutationObserver(target, callback, options = {}) {
  2573. const _a = options, { window: window2 = defaultWindow } = _a, mutationOptions = __objRest$1(_a, ["window"]);
  2574. let observer;
  2575. const isSupported = window2 && "IntersectionObserver" in window2;
  2576. const cleanup = () => {
  2577. if (observer) {
  2578. observer.disconnect();
  2579. observer = void 0;
  2580. }
  2581. };
  2582. const stopWatch = watch(() => unrefElement(target), (el) => {
  2583. cleanup();
  2584. if (isSupported && window2 && el) {
  2585. observer = new window2.MutationObserver(callback);
  2586. observer.observe(el, mutationOptions);
  2587. }
  2588. }, { immediate: true });
  2589. const stop = () => {
  2590. cleanup();
  2591. stopWatch();
  2592. };
  2593. tryOnScopeDispose(stop);
  2594. return {
  2595. isSupported,
  2596. stop
  2597. };
  2598. }
  2599. function useNetwork(options = {}) {
  2600. const { window: window2 = defaultWindow } = options;
  2601. const navigator = window2 == null ? void 0 : window2.navigator;
  2602. const isSupported = Boolean(navigator && "connection" in navigator);
  2603. const isOnline = ref(true);
  2604. const saveData = ref(false);
  2605. const offlineAt = ref(void 0);
  2606. const downlink = ref(void 0);
  2607. const downlinkMax = ref(void 0);
  2608. const rtt = ref(void 0);
  2609. const effectiveType = ref(void 0);
  2610. const type = ref("unknown");
  2611. const connection = isSupported && navigator.connection;
  2612. function updateNetworkInformation() {
  2613. if (!navigator)
  2614. return;
  2615. isOnline.value = navigator.onLine;
  2616. offlineAt.value = isOnline.value ? void 0 : Date.now();
  2617. if (connection) {
  2618. downlink.value = connection.downlink;
  2619. downlinkMax.value = connection.downlinkMax;
  2620. effectiveType.value = connection.effectiveType;
  2621. rtt.value = connection.rtt;
  2622. saveData.value = connection.saveData;
  2623. type.value = connection.type;
  2624. }
  2625. }
  2626. if (window2) {
  2627. useEventListener(window2, "offline", () => {
  2628. isOnline.value = false;
  2629. offlineAt.value = Date.now();
  2630. });
  2631. useEventListener(window2, "online", () => {
  2632. isOnline.value = true;
  2633. });
  2634. }
  2635. if (connection)
  2636. useEventListener(connection, "change", updateNetworkInformation, false);
  2637. updateNetworkInformation();
  2638. return {
  2639. isSupported,
  2640. isOnline,
  2641. saveData,
  2642. offlineAt,
  2643. downlink,
  2644. downlinkMax,
  2645. effectiveType,
  2646. rtt,
  2647. type
  2648. };
  2649. }
  2650. var __defProp$5 = Object.defineProperty;
  2651. var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
  2652. var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
  2653. var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
  2654. var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  2655. var __spreadValues$5 = (a, b) => {
  2656. for (var prop in b || (b = {}))
  2657. if (__hasOwnProp$5.call(b, prop))
  2658. __defNormalProp$5(a, prop, b[prop]);
  2659. if (__getOwnPropSymbols$5)
  2660. for (var prop of __getOwnPropSymbols$5(b)) {
  2661. if (__propIsEnum$5.call(b, prop))
  2662. __defNormalProp$5(a, prop, b[prop]);
  2663. }
  2664. return a;
  2665. };
  2666. function useNow(options = {}) {
  2667. const {
  2668. controls: exposeControls = false,
  2669. interval = "requestAnimationFrame"
  2670. } = options;
  2671. const now2 = ref(new Date());
  2672. const update = () => now2.value = new Date();
  2673. const controls = interval === "requestAnimationFrame" ? useRafFn(update, { immediate: true }) : useIntervalFn(update, interval, { immediate: true });
  2674. if (exposeControls) {
  2675. return __spreadValues$5({
  2676. now: now2
  2677. }, controls);
  2678. } else {
  2679. return now2;
  2680. }
  2681. }
  2682. function useOnline(options = {}) {
  2683. const { isOnline } = useNetwork(options);
  2684. return isOnline;
  2685. }
  2686. function usePageLeave(options = {}) {
  2687. const { window: window2 = defaultWindow } = options;
  2688. const isLeft = ref(false);
  2689. const handler = (event) => {
  2690. if (!window2)
  2691. return;
  2692. event = event || window2.event;
  2693. const from = event.relatedTarget || event.toElement;
  2694. isLeft.value = !from;
  2695. };
  2696. if (window2) {
  2697. useEventListener(window2, "mouseout", handler, { passive: true });
  2698. useEventListener(window2.document, "mouseleave", handler, { passive: true });
  2699. useEventListener(window2.document, "mouseenter", handler, { passive: true });
  2700. }
  2701. return isLeft;
  2702. }
  2703. function useParallax(target, options = {}) {
  2704. const {
  2705. deviceOrientationTiltAdjust = (i) => i,
  2706. deviceOrientationRollAdjust = (i) => i,
  2707. mouseTiltAdjust = (i) => i,
  2708. mouseRollAdjust = (i) => i,
  2709. window: window2 = defaultWindow
  2710. } = options;
  2711. const orientation = reactive(useDeviceOrientation({ window: window2 }));
  2712. const {
  2713. elementX: x,
  2714. elementY: y,
  2715. elementWidth: width,
  2716. elementHeight: height
  2717. } = useMouseInElement(target, { handleOutside: false, window: window2 });
  2718. const source = computed(() => {
  2719. if (orientation.isSupported && (orientation.alpha != null && orientation.alpha !== 0 || orientation.gamma != null && orientation.gamma !== 0))
  2720. return "deviceOrientation";
  2721. return "mouse";
  2722. });
  2723. const roll = computed(() => {
  2724. if (source.value === "deviceOrientation") {
  2725. const value = -orientation.beta / 90;
  2726. return deviceOrientationRollAdjust(value);
  2727. } else {
  2728. const value = -(y.value - height.value / 2) / height.value;
  2729. return mouseRollAdjust(value);
  2730. }
  2731. });
  2732. const tilt = computed(() => {
  2733. if (source.value === "deviceOrientation") {
  2734. const value = orientation.gamma / 90;
  2735. return deviceOrientationTiltAdjust(value);
  2736. } else {
  2737. const value = (x.value - width.value / 2) / width.value;
  2738. return mouseTiltAdjust(value);
  2739. }
  2740. });
  2741. return { roll, tilt, source };
  2742. }
  2743. var __defProp$4 = Object.defineProperty;
  2744. var __defProps$1 = Object.defineProperties;
  2745. var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
  2746. var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
  2747. var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
  2748. var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
  2749. var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  2750. var __spreadValues$4 = (a, b) => {
  2751. for (var prop in b || (b = {}))
  2752. if (__hasOwnProp$4.call(b, prop))
  2753. __defNormalProp$4(a, prop, b[prop]);
  2754. if (__getOwnPropSymbols$4)
  2755. for (var prop of __getOwnPropSymbols$4(b)) {
  2756. if (__propIsEnum$4.call(b, prop))
  2757. __defNormalProp$4(a, prop, b[prop]);
  2758. }
  2759. return a;
  2760. };
  2761. var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
  2762. var defaultState = {
  2763. x: 0,
  2764. y: 0,
  2765. pointerId: 0,
  2766. pressure: 0,
  2767. tiltX: 0,
  2768. tiltY: 0,
  2769. width: 0,
  2770. height: 0,
  2771. twist: 0,
  2772. pointerType: null
  2773. };
  2774. var keys = Object.keys(defaultState);
  2775. function usePointer(options = {}) {
  2776. const {
  2777. target = defaultWindow
  2778. } = options;
  2779. const isInside = ref(false);
  2780. const state = ref(options.initialValue || {});
  2781. Object.assign(state.value, defaultState, state.value);
  2782. const handler = (event) => {
  2783. isInside.value = true;
  2784. if (options.pointerTypes && !options.pointerTypes.includes(event.pointerType))
  2785. return;
  2786. state.value = objectPick(event, keys, false);
  2787. };
  2788. if (target) {
  2789. useEventListener(target, "pointerdown", handler, { passive: true });
  2790. useEventListener(target, "pointermove", handler, { passive: true });
  2791. useEventListener(target, "pointerleave", () => isInside.value = false, { passive: true });
  2792. }
  2793. return __spreadProps$1(__spreadValues$4({}, toRefs(state)), {
  2794. isInside
  2795. });
  2796. }
  2797. var SwipeDirection;
  2798. (function(SwipeDirection2) {
  2799. SwipeDirection2["UP"] = "UP";
  2800. SwipeDirection2["RIGHT"] = "RIGHT";
  2801. SwipeDirection2["DOWN"] = "DOWN";
  2802. SwipeDirection2["LEFT"] = "LEFT";
  2803. SwipeDirection2["NONE"] = "NONE";
  2804. })(SwipeDirection || (SwipeDirection = {}));
  2805. function useSwipe(target, options = {}) {
  2806. const {
  2807. threshold = 50,
  2808. onSwipe,
  2809. onSwipeEnd,
  2810. onSwipeStart,
  2811. passive = true,
  2812. window: window2 = defaultWindow
  2813. } = options;
  2814. const coordsStart = reactive({ x: 0, y: 0 });
  2815. const coordsEnd = reactive({ x: 0, y: 0 });
  2816. const diffX = computed(() => coordsStart.x - coordsEnd.x);
  2817. const diffY = computed(() => coordsStart.y - coordsEnd.y);
  2818. const { max, abs } = Math;
  2819. const isThresholdExceeded = computed(() => max(abs(diffX.value), abs(diffY.value)) >= threshold);
  2820. const isSwiping = ref(false);
  2821. const direction = computed(() => {
  2822. if (!isThresholdExceeded.value)
  2823. return SwipeDirection.NONE;
  2824. if (abs(diffX.value) > abs(diffY.value)) {
  2825. return diffX.value > 0 ? SwipeDirection.LEFT : SwipeDirection.RIGHT;
  2826. } else {
  2827. return diffY.value > 0 ? SwipeDirection.UP : SwipeDirection.DOWN;
  2828. }
  2829. });
  2830. const getTouchEventCoords = (e) => [e.touches[0].clientX, e.touches[0].clientY];
  2831. const updateCoordsStart = (x, y) => {
  2832. coordsStart.x = x;
  2833. coordsStart.y = y;
  2834. };
  2835. const updateCoordsEnd = (x, y) => {
  2836. coordsEnd.x = x;
  2837. coordsEnd.y = y;
  2838. };
  2839. let listenerOptions;
  2840. const isPassiveEventSupported = checkPassiveEventSupport(window2 == null ? void 0 : window2.document);
  2841. if (!passive)
  2842. listenerOptions = isPassiveEventSupported ? { passive: false, capture: true } : { capture: true };
  2843. else
  2844. listenerOptions = isPassiveEventSupported ? { passive: true } : { capture: false };
  2845. const onTouchEnd = (e) => {
  2846. if (isSwiping.value)
  2847. onSwipeEnd == null ? void 0 : onSwipeEnd(e, direction.value);
  2848. isSwiping.value = false;
  2849. };
  2850. const stops = [
  2851. useEventListener(target, "touchstart", (e) => {
  2852. if (listenerOptions.capture && !listenerOptions.passive)
  2853. e.preventDefault();
  2854. const [x, y] = getTouchEventCoords(e);
  2855. updateCoordsStart(x, y);
  2856. updateCoordsEnd(x, y);
  2857. onSwipeStart == null ? void 0 : onSwipeStart(e);
  2858. }, listenerOptions),
  2859. useEventListener(target, "touchmove", (e) => {
  2860. const [x, y] = getTouchEventCoords(e);
  2861. updateCoordsEnd(x, y);
  2862. if (!isSwiping.value && isThresholdExceeded.value)
  2863. isSwiping.value = true;
  2864. if (isSwiping.value)
  2865. onSwipe == null ? void 0 : onSwipe(e);
  2866. }, listenerOptions),
  2867. useEventListener(target, "touchend", onTouchEnd, listenerOptions),
  2868. useEventListener(target, "touchcancel", onTouchEnd, listenerOptions)
  2869. ];
  2870. const stop = () => stops.forEach((s) => s());
  2871. return {
  2872. isPassiveEventSupported,
  2873. isSwiping,
  2874. direction,
  2875. coordsStart,
  2876. coordsEnd,
  2877. lengthX: diffX,
  2878. lengthY: diffY,
  2879. stop
  2880. };
  2881. }
  2882. function checkPassiveEventSupport(document2) {
  2883. if (!document2)
  2884. return false;
  2885. let supportsPassive = false;
  2886. const optionsBlock = {
  2887. get passive() {
  2888. supportsPassive = true;
  2889. return false;
  2890. }
  2891. };
  2892. document2.addEventListener("x", noop, optionsBlock);
  2893. document2.removeEventListener("x", noop);
  2894. return supportsPassive;
  2895. }
  2896. function usePointerSwipe(target, options = {}) {
  2897. const targetRef = ref(target);
  2898. const {
  2899. threshold = 50,
  2900. onSwipe,
  2901. onSwipeEnd,
  2902. onSwipeStart
  2903. } = options;
  2904. const posStart = reactive({ x: 0, y: 0 });
  2905. const updatePosStart = (x, y) => {
  2906. posStart.x = x;
  2907. posStart.y = y;
  2908. };
  2909. const posEnd = reactive({ x: 0, y: 0 });
  2910. const updatePosEnd = (x, y) => {
  2911. posEnd.x = x;
  2912. posEnd.y = y;
  2913. };
  2914. const distanceX = computed(() => posStart.x - posEnd.x);
  2915. const distanceY = computed(() => posStart.y - posEnd.y);
  2916. const { max, abs } = Math;
  2917. const isThresholdExceeded = computed(() => max(abs(distanceX.value), abs(distanceY.value)) >= threshold);
  2918. const isSwiping = ref(false);
  2919. const isPointerDown = ref(false);
  2920. const direction = computed(() => {
  2921. if (!isThresholdExceeded.value)
  2922. return SwipeDirection.NONE;
  2923. if (abs(distanceX.value) > abs(distanceY.value)) {
  2924. return distanceX.value > 0 ? SwipeDirection.LEFT : SwipeDirection.RIGHT;
  2925. } else {
  2926. return distanceY.value > 0 ? SwipeDirection.UP : SwipeDirection.DOWN;
  2927. }
  2928. });
  2929. const filterEvent = (e) => {
  2930. if (options.pointerTypes)
  2931. return options.pointerTypes.includes(e.pointerType);
  2932. return true;
  2933. };
  2934. const stops = [
  2935. useEventListener(target, "pointerdown", (e) => {
  2936. var _a, _b;
  2937. if (!filterEvent(e))
  2938. return;
  2939. isPointerDown.value = true;
  2940. (_b = (_a = targetRef.value) == null ? void 0 : _a.style) == null ? void 0 : _b.setProperty("touch-action", "none");
  2941. const eventTarget = e.target;
  2942. eventTarget == null ? void 0 : eventTarget.setPointerCapture(e.pointerId);
  2943. const { clientX: x, clientY: y } = e;
  2944. updatePosStart(x, y);
  2945. updatePosEnd(x, y);
  2946. onSwipeStart == null ? void 0 : onSwipeStart(e);
  2947. }),
  2948. useEventListener(target, "pointermove", (e) => {
  2949. if (!filterEvent(e))
  2950. return;
  2951. if (!isPointerDown.value)
  2952. return;
  2953. const { clientX: x, clientY: y } = e;
  2954. updatePosEnd(x, y);
  2955. if (!isSwiping.value && isThresholdExceeded.value)
  2956. isSwiping.value = true;
  2957. if (isSwiping.value)
  2958. onSwipe == null ? void 0 : onSwipe(e);
  2959. }),
  2960. useEventListener(target, "pointerup", (e) => {
  2961. var _a, _b;
  2962. if (!filterEvent(e))
  2963. return;
  2964. if (isSwiping.value)
  2965. onSwipeEnd == null ? void 0 : onSwipeEnd(e, direction.value);
  2966. isPointerDown.value = false;
  2967. isSwiping.value = false;
  2968. (_b = (_a = targetRef.value) == null ? void 0 : _a.style) == null ? void 0 : _b.setProperty("touch-action", "initial");
  2969. })
  2970. ];
  2971. const stop = () => stops.forEach((s) => s());
  2972. return {
  2973. isSwiping: readonly(isSwiping),
  2974. direction: readonly(direction),
  2975. posStart: readonly(posStart),
  2976. posEnd: readonly(posEnd),
  2977. distanceX,
  2978. distanceY,
  2979. stop
  2980. };
  2981. }
  2982. function usePreferredColorScheme(options) {
  2983. const isLight = useMediaQuery("(prefers-color-scheme: light)", options);
  2984. const isDark = useMediaQuery("(prefers-color-scheme: dark)", options);
  2985. return computed(() => {
  2986. if (isDark.value)
  2987. return "dark";
  2988. if (isLight.value)
  2989. return "light";
  2990. return "no-preference";
  2991. });
  2992. }
  2993. function usePreferredLanguages(options = {}) {
  2994. const { window: window2 = defaultWindow } = options;
  2995. if (!window2)
  2996. return ref(["en"]);
  2997. const navigator = window2.navigator;
  2998. const value = ref(navigator.languages);
  2999. useEventListener(window2, "languagechange", () => {
  3000. value.value = navigator.languages;
  3001. });
  3002. return value;
  3003. }
  3004. function useScriptTag(src, onLoaded = noop, options = {}) {
  3005. const {
  3006. immediate = true,
  3007. manual = false,
  3008. type = "text/javascript",
  3009. async = true,
  3010. crossOrigin,
  3011. referrerPolicy,
  3012. noModule,
  3013. defer,
  3014. document: document2 = defaultDocument
  3015. } = options;
  3016. const scriptTag = ref(null);
  3017. let _promise = null;
  3018. const loadScript = (waitForScriptLoad) => new Promise((resolve, reject) => {
  3019. const resolveWithElement = (el2) => {
  3020. scriptTag.value = el2;
  3021. resolve(el2);
  3022. return el2;
  3023. };
  3024. if (!document2) {
  3025. resolve(false);
  3026. return;
  3027. }
  3028. let shouldAppend = false;
  3029. let el = document2.querySelector(`script[src="${src}"]`);
  3030. if (!el) {
  3031. el = document2.createElement("script");
  3032. el.type = type;
  3033. el.async = async;
  3034. el.src = unref(src);
  3035. if (defer)
  3036. el.defer = defer;
  3037. if (crossOrigin)
  3038. el.crossOrigin = crossOrigin;
  3039. if (noModule)
  3040. el.noModule = noModule;
  3041. if (referrerPolicy)
  3042. el.referrerPolicy = referrerPolicy;
  3043. shouldAppend = true;
  3044. } else if (el.hasAttribute("data-loaded")) {
  3045. resolveWithElement(el);
  3046. }
  3047. el.addEventListener("error", (event) => reject(event));
  3048. el.addEventListener("abort", (event) => reject(event));
  3049. el.addEventListener("load", () => {
  3050. el.setAttribute("data-loaded", "true");
  3051. onLoaded(el);
  3052. resolveWithElement(el);
  3053. });
  3054. if (shouldAppend)
  3055. el = document2.head.appendChild(el);
  3056. if (!waitForScriptLoad)
  3057. resolveWithElement(el);
  3058. });
  3059. const load = (waitForScriptLoad = true) => {
  3060. if (!_promise)
  3061. _promise = loadScript(waitForScriptLoad);
  3062. return _promise;
  3063. };
  3064. const unload = () => {
  3065. if (!document2)
  3066. return;
  3067. _promise = null;
  3068. if (scriptTag.value) {
  3069. document2.head.removeChild(scriptTag.value);
  3070. scriptTag.value = null;
  3071. }
  3072. };
  3073. if (immediate && !manual)
  3074. tryOnMounted(load);
  3075. if (!manual)
  3076. tryOnUnmounted(unload);
  3077. return { scriptTag, load, unload };
  3078. }
  3079. function useScroll(element, options = {}) {
  3080. const {
  3081. throttle = 0,
  3082. idle = 200,
  3083. onStop = noop,
  3084. onScroll = noop,
  3085. offset = {
  3086. left: 0,
  3087. right: 0,
  3088. top: 0,
  3089. bottom: 0
  3090. },
  3091. eventListenerOptions = {
  3092. capture: false,
  3093. passive: true
  3094. }
  3095. } = options;
  3096. const x = ref(0);
  3097. const y = ref(0);
  3098. const isScrolling = ref(false);
  3099. const arrivedState = reactive({
  3100. left: true,
  3101. right: false,
  3102. top: true,
  3103. bottom: false
  3104. });
  3105. if (element) {
  3106. const onScrollEnd = useDebounceFn(() => {
  3107. isScrolling.value = false;
  3108. onStop();
  3109. }, throttle + idle);
  3110. const onScrollHandler = (e) => {
  3111. const eventTarget = e.target === document ? e.target.documentElement : e.target;
  3112. const scrollLeft = eventTarget.scrollLeft;
  3113. arrivedState.left = scrollLeft <= 0 + (offset.left || 0);
  3114. arrivedState.right = scrollLeft + eventTarget.clientWidth >= eventTarget.scrollWidth - (offset.right || 0);
  3115. x.value = scrollLeft;
  3116. const scrollTop = eventTarget.scrollTop;
  3117. arrivedState.top = scrollTop <= 0 + (offset.top || 0);
  3118. arrivedState.bottom = scrollTop + eventTarget.clientHeight >= eventTarget.scrollHeight - (offset.bottom || 0);
  3119. y.value = scrollTop;
  3120. isScrolling.value = true;
  3121. onScrollEnd();
  3122. onScroll();
  3123. };
  3124. useEventListener(element, "scroll", throttle ? useThrottleFn(onScrollHandler, throttle) : onScrollHandler, eventListenerOptions);
  3125. }
  3126. return {
  3127. x,
  3128. y,
  3129. isScrolling,
  3130. arrivedState
  3131. };
  3132. }
  3133. function useSessionStorage(key, initialValue, options = {}) {
  3134. const { window: window2 = defaultWindow } = options;
  3135. return useStorage(key, initialValue, window2 == null ? void 0 : window2.sessionStorage, options);
  3136. }
  3137. var __defProp$3 = Object.defineProperty;
  3138. var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
  3139. var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
  3140. var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
  3141. var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  3142. var __spreadValues$3 = (a, b) => {
  3143. for (var prop in b || (b = {}))
  3144. if (__hasOwnProp$3.call(b, prop))
  3145. __defNormalProp$3(a, prop, b[prop]);
  3146. if (__getOwnPropSymbols$3)
  3147. for (var prop of __getOwnPropSymbols$3(b)) {
  3148. if (__propIsEnum$3.call(b, prop))
  3149. __defNormalProp$3(a, prop, b[prop]);
  3150. }
  3151. return a;
  3152. };
  3153. function useShare(shareOptions = {}, options = {}) {
  3154. const { navigator = defaultNavigator } = options;
  3155. const _navigator = navigator;
  3156. const isSupported = _navigator && "canShare" in _navigator;
  3157. const share = (..._0) => __async(this, [..._0], function* (overrideOptions = {}) {
  3158. if (isSupported) {
  3159. const data = __spreadValues$3(__spreadValues$3({}, unref(shareOptions)), unref(overrideOptions));
  3160. let granted = true;
  3161. if (data.files && _navigator.canShare)
  3162. granted = _navigator.canShare({ files: data.files });
  3163. if (granted)
  3164. return _navigator.share(data);
  3165. }
  3166. });
  3167. return {
  3168. isSupported,
  3169. share
  3170. };
  3171. }
  3172. function useSpeechRecognition(options = {}) {
  3173. const {
  3174. interimResults = true,
  3175. continuous = true,
  3176. window: window2 = defaultWindow
  3177. } = options;
  3178. const lang = ref(options.lang || "en-US");
  3179. const isListening = ref(false);
  3180. const isFinal = ref(false);
  3181. const result = ref("");
  3182. const error = shallowRef(void 0);
  3183. const toggle = (value = !isListening.value) => {
  3184. isListening.value = value;
  3185. };
  3186. const start = () => {
  3187. isListening.value = true;
  3188. };
  3189. const stop = () => {
  3190. isListening.value = false;
  3191. };
  3192. const SpeechRecognition = window2 && (window2.SpeechRecognition || window2.webkitSpeechRecognition);
  3193. const isSupported = Boolean(SpeechRecognition);
  3194. let recognition;
  3195. if (isSupported) {
  3196. recognition = new SpeechRecognition();
  3197. recognition.continuous = continuous;
  3198. recognition.interimResults = interimResults;
  3199. recognition.lang = unref(lang);
  3200. recognition.onstart = () => {
  3201. isFinal.value = false;
  3202. };
  3203. watch(lang, (lang2) => {
  3204. if (recognition && !isListening.value)
  3205. recognition.lang = lang2;
  3206. });
  3207. recognition.onresult = (event) => {
  3208. const transcript = Array.from(event.results).map((result2) => {
  3209. isFinal.value = result2.isFinal;
  3210. return result2[0];
  3211. }).map((result2) => result2.transcript).join("");
  3212. result.value = transcript;
  3213. error.value = void 0;
  3214. };
  3215. recognition.onerror = (event) => {
  3216. error.value = event;
  3217. };
  3218. recognition.onend = () => {
  3219. isListening.value = false;
  3220. recognition.lang = unref(lang);
  3221. };
  3222. watch(isListening, () => {
  3223. if (isListening.value)
  3224. recognition.start();
  3225. else
  3226. recognition.stop();
  3227. });
  3228. }
  3229. tryOnScopeDispose(() => {
  3230. isListening.value = false;
  3231. });
  3232. return {
  3233. isSupported,
  3234. isListening,
  3235. isFinal,
  3236. recognition,
  3237. result,
  3238. error,
  3239. toggle,
  3240. start,
  3241. stop
  3242. };
  3243. }
  3244. function useSpeechSynthesis(text, options = {}) {
  3245. var _a, _b;
  3246. const {
  3247. pitch = 1,
  3248. rate = 1,
  3249. volume = 1,
  3250. window: window2 = defaultWindow
  3251. } = options;
  3252. const synth = window2 && window2.speechSynthesis;
  3253. const isSupported = Boolean(synth);
  3254. const isPlaying = ref(false);
  3255. const status = ref("init");
  3256. const voiceInfo = {
  3257. lang: ((_a = options.voice) == null ? void 0 : _a.lang) || "default",
  3258. name: ((_b = options.voice) == null ? void 0 : _b.name) || ""
  3259. };
  3260. const spokenText = ref(text || "");
  3261. const lang = ref(options.lang || "en-US");
  3262. const error = shallowRef(void 0);
  3263. const toggle = (value = !isPlaying.value) => {
  3264. isPlaying.value = value;
  3265. };
  3266. const bindEventsForUtterance = (utterance2) => {
  3267. utterance2.lang = unref(lang);
  3268. options.voice && (utterance2.voice = options.voice);
  3269. utterance2.pitch = pitch;
  3270. utterance2.rate = rate;
  3271. utterance2.volume = volume;
  3272. utterance2.onstart = () => {
  3273. isPlaying.value = true;
  3274. status.value = "play";
  3275. };
  3276. utterance2.onpause = () => {
  3277. isPlaying.value = false;
  3278. status.value = "pause";
  3279. };
  3280. utterance2.onresume = () => {
  3281. isPlaying.value = true;
  3282. status.value = "play";
  3283. };
  3284. utterance2.onend = () => {
  3285. isPlaying.value = false;
  3286. status.value = "end";
  3287. };
  3288. utterance2.onerror = (event) => {
  3289. error.value = event;
  3290. };
  3291. utterance2.onend = () => {
  3292. isPlaying.value = false;
  3293. utterance2.lang = unref(lang);
  3294. };
  3295. };
  3296. const utterance = computed(() => {
  3297. isPlaying.value = false;
  3298. status.value = "init";
  3299. const newUtterance = new SpeechSynthesisUtterance(spokenText.value);
  3300. bindEventsForUtterance(newUtterance);
  3301. return newUtterance;
  3302. });
  3303. const speak = () => {
  3304. synth.cancel();
  3305. utterance && synth.speak(utterance.value);
  3306. };
  3307. if (isSupported) {
  3308. bindEventsForUtterance(utterance.value);
  3309. watch(lang, (lang2) => {
  3310. if (utterance.value && !isPlaying.value)
  3311. utterance.value.lang = lang2;
  3312. });
  3313. watch(isPlaying, () => {
  3314. if (isPlaying.value)
  3315. synth.resume();
  3316. else
  3317. synth.pause();
  3318. });
  3319. }
  3320. tryOnScopeDispose(() => {
  3321. isPlaying.value = false;
  3322. });
  3323. return {
  3324. isSupported,
  3325. isPlaying,
  3326. status,
  3327. voiceInfo,
  3328. utterance,
  3329. error,
  3330. toggle,
  3331. speak
  3332. };
  3333. }
  3334. function useTemplateRefsList() {
  3335. const refs = ref([]);
  3336. refs.value.set = (el) => {
  3337. if (el)
  3338. refs.value.push(el);
  3339. };
  3340. onBeforeUpdate(() => {
  3341. refs.value.length = 0;
  3342. });
  3343. return refs;
  3344. }
  3345. var __defProp$2 = Object.defineProperty;
  3346. var __defProps = Object.defineProperties;
  3347. var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
  3348. var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
  3349. var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
  3350. var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
  3351. var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  3352. var __spreadValues$2 = (a, b) => {
  3353. for (var prop in b || (b = {}))
  3354. if (__hasOwnProp$2.call(b, prop))
  3355. __defNormalProp$2(a, prop, b[prop]);
  3356. if (__getOwnPropSymbols$2)
  3357. for (var prop of __getOwnPropSymbols$2(b)) {
  3358. if (__propIsEnum$2.call(b, prop))
  3359. __defNormalProp$2(a, prop, b[prop]);
  3360. }
  3361. return a;
  3362. };
  3363. var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
  3364. function useThrottledRefHistory(source, options = {}) {
  3365. const { throttle = 200, trailing = true } = options;
  3366. const filter = throttleFilter(throttle, trailing);
  3367. const history = useRefHistory(source, __spreadProps(__spreadValues$2({}, options), { eventFilter: filter }));
  3368. return __spreadValues$2({}, history);
  3369. }
  3370. var __defProp$1 = Object.defineProperty;
  3371. var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
  3372. var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
  3373. var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
  3374. var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  3375. var __spreadValues$1 = (a, b) => {
  3376. for (var prop in b || (b = {}))
  3377. if (__hasOwnProp$1.call(b, prop))
  3378. __defNormalProp$1(a, prop, b[prop]);
  3379. if (__getOwnPropSymbols$1)
  3380. for (var prop of __getOwnPropSymbols$1(b)) {
  3381. if (__propIsEnum$1.call(b, prop))
  3382. __defNormalProp$1(a, prop, b[prop]);
  3383. }
  3384. return a;
  3385. };
  3386. var __objRest = (source, exclude) => {
  3387. var target = {};
  3388. for (var prop in source)
  3389. if (__hasOwnProp$1.call(source, prop) && exclude.indexOf(prop) < 0)
  3390. target[prop] = source[prop];
  3391. if (source != null && __getOwnPropSymbols$1)
  3392. for (var prop of __getOwnPropSymbols$1(source)) {
  3393. if (exclude.indexOf(prop) < 0 && __propIsEnum$1.call(source, prop))
  3394. target[prop] = source[prop];
  3395. }
  3396. return target;
  3397. };
  3398. var UNITS = [
  3399. { max: 6e4, value: 1e3, name: "second" },
  3400. { max: 276e4, value: 6e4, name: "minute" },
  3401. { max: 72e6, value: 36e5, name: "hour" },
  3402. { max: 5184e5, value: 864e5, name: "day" },
  3403. { max: 24192e5, value: 6048e5, name: "week" },
  3404. { max: 28512e6, value: 2592e6, name: "month" },
  3405. { max: Infinity, value: 31536e6, name: "year" }
  3406. ];
  3407. var DEFAULT_MESSAGES = {
  3408. justNow: "just now",
  3409. past: (n) => n.match(/\d/) ? `${n} ago` : n,
  3410. future: (n) => n.match(/\d/) ? `in ${n}` : n,
  3411. month: (n, past) => n === 1 ? past ? "last month" : "next month" : `${n} month${n > 1 ? "s" : ""}`,
  3412. year: (n, past) => n === 1 ? past ? "last year" : "next year" : `${n} year${n > 1 ? "s" : ""}`,
  3413. day: (n, past) => n === 1 ? past ? "yesterday" : "tomorrow" : `${n} day${n > 1 ? "s" : ""}`,
  3414. week: (n, past) => n === 1 ? past ? "last week" : "next week" : `${n} week${n > 1 ? "s" : ""}`,
  3415. hour: (n) => `${n} hour${n > 1 ? "s" : ""}`,
  3416. minute: (n) => `${n} minute${n > 1 ? "s" : ""}`,
  3417. second: (n) => `${n} second${n > 1 ? "s" : ""}`
  3418. };
  3419. var DEFAULT_FORMATTER = (date) => date.toISOString().slice(0, 10);
  3420. function useTimeAgo(time, options = {}) {
  3421. const {
  3422. controls: exposeControls = false,
  3423. max,
  3424. updateInterval = 3e4,
  3425. messages = DEFAULT_MESSAGES,
  3426. fullDateFormatter = DEFAULT_FORMATTER
  3427. } = options;
  3428. const { abs, round } = Math;
  3429. const _a = useNow({ interval: updateInterval, controls: true }), { now: now2 } = _a, controls = __objRest(_a, ["now"]);
  3430. function getTimeago(from, now22) {
  3431. var _a2;
  3432. const diff = +now22 - +from;
  3433. const absDiff = abs(diff);
  3434. if (absDiff < 6e4)
  3435. return messages.justNow;
  3436. if (typeof max === "number" && absDiff > max)
  3437. return fullDateFormatter(new Date(from));
  3438. if (typeof max === "string") {
  3439. const unitMax = (_a2 = UNITS.find((i) => i.name === max)) == null ? void 0 : _a2.max;
  3440. if (unitMax && absDiff > unitMax)
  3441. return fullDateFormatter(new Date(from));
  3442. }
  3443. for (const unit of UNITS) {
  3444. if (absDiff < unit.max)
  3445. return format(diff, unit);
  3446. }
  3447. }
  3448. function applyFormat(name, val, isPast) {
  3449. const formatter = messages[name];
  3450. if (typeof formatter === "function")
  3451. return formatter(val, isPast);
  3452. return formatter.replace("{0}", val.toString());
  3453. }
  3454. function format(diff, unit) {
  3455. const val = round(abs(diff) / unit.value);
  3456. const past = diff > 0;
  3457. const str = applyFormat(unit.name, val, past);
  3458. return applyFormat(past ? "past" : "future", str, past);
  3459. }
  3460. const timeAgo = computed(() => getTimeago(new Date(unref(time)), unref(now2.value)));
  3461. if (exposeControls) {
  3462. return __spreadValues$1({
  3463. timeAgo
  3464. }, controls);
  3465. } else {
  3466. return timeAgo;
  3467. }
  3468. }
  3469. var __defProp = Object.defineProperty;
  3470. var __getOwnPropSymbols = Object.getOwnPropertySymbols;
  3471. var __hasOwnProp = Object.prototype.hasOwnProperty;
  3472. var __propIsEnum = Object.prototype.propertyIsEnumerable;
  3473. var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  3474. var __spreadValues = (a, b) => {
  3475. for (var prop in b || (b = {}))
  3476. if (__hasOwnProp.call(b, prop))
  3477. __defNormalProp(a, prop, b[prop]);
  3478. if (__getOwnPropSymbols)
  3479. for (var prop of __getOwnPropSymbols(b)) {
  3480. if (__propIsEnum.call(b, prop))
  3481. __defNormalProp(a, prop, b[prop]);
  3482. }
  3483. return a;
  3484. };
  3485. function useTimestamp(options = {}) {
  3486. const {
  3487. controls: exposeControls = false,
  3488. offset = 0,
  3489. immediate = true,
  3490. interval = "requestAnimationFrame"
  3491. } = options;
  3492. const ts = ref(timestamp() + offset);
  3493. const update = () => ts.value = timestamp() + offset;
  3494. const controls = interval === "requestAnimationFrame" ? useRafFn(update, { immediate }) : useIntervalFn(update, interval, { immediate });
  3495. if (exposeControls) {
  3496. return __spreadValues({
  3497. timestamp: ts
  3498. }, controls);
  3499. } else {
  3500. return ts;
  3501. }
  3502. }
  3503. function useTitle(newTitle = null, options = {}) {
  3504. var _a, _b;
  3505. const {
  3506. document: document2 = defaultDocument,
  3507. observe = false
  3508. } = options;
  3509. const title = ref((_a = newTitle != null ? newTitle : document2 == null ? void 0 : document2.title) != null ? _a : null);
  3510. watch(title, (t, o) => {
  3511. if (isString(t) && t !== o && document2)
  3512. document2.title = t;
  3513. }, { immediate: true });
  3514. if (observe && document2) {
  3515. useMutationObserver((_b = document2.head) == null ? void 0 : _b.querySelector("title"), () => {
  3516. if (document2 && document2.title !== title.value)
  3517. title.value = document2.title;
  3518. }, { childList: true });
  3519. }
  3520. return title;
  3521. }
  3522. var TransitionPresets = {
  3523. linear: identity,
  3524. easeInSine: [0.12, 0, 0.39, 0],
  3525. easeOutSine: [0.61, 1, 0.88, 1],
  3526. easeInOutSine: [0.37, 0, 0.63, 1],
  3527. easeInQuad: [0.11, 0, 0.5, 0],
  3528. easeOutQuad: [0.5, 1, 0.89, 1],
  3529. easeInOutQuad: [0.45, 0, 0.55, 1],
  3530. easeInCubic: [0.32, 0, 0.67, 0],
  3531. easeOutCubic: [0.33, 1, 0.68, 1],
  3532. easeInOutCubic: [0.65, 0, 0.35, 1],
  3533. easeInQuart: [0.5, 0, 0.75, 0],
  3534. easeOutQuart: [0.25, 1, 0.5, 1],
  3535. easeInOutQuart: [0.76, 0, 0.24, 1],
  3536. easeInQuint: [0.64, 0, 0.78, 0],
  3537. easeOutQuint: [0.22, 1, 0.36, 1],
  3538. easeInOutQuint: [0.83, 0, 0.17, 1],
  3539. easeInExpo: [0.7, 0, 0.84, 0],
  3540. easeOutExpo: [0.16, 1, 0.3, 1],
  3541. easeInOutExpo: [0.87, 0, 0.13, 1],
  3542. easeInCirc: [0.55, 0, 1, 0.45],
  3543. easeOutCirc: [0, 0.55, 0.45, 1],
  3544. easeInOutCirc: [0.85, 0, 0.15, 1],
  3545. easeInBack: [0.36, 0, 0.66, -0.56],
  3546. easeOutBack: [0.34, 1.56, 0.64, 1],
  3547. easeInOutBack: [0.68, -0.6, 0.32, 1.6]
  3548. };
  3549. function createEasingFunction([p0, p1, p2, p3]) {
  3550. const a = (a1, a2) => 1 - 3 * a2 + 3 * a1;
  3551. const b = (a1, a2) => 3 * a2 - 6 * a1;
  3552. const c = (a1) => 3 * a1;
  3553. const calcBezier = (t, a1, a2) => ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t;
  3554. const getSlope = (t, a1, a2) => 3 * a(a1, a2) * t * t + 2 * b(a1, a2) * t + c(a1);
  3555. const getTforX = (x) => {
  3556. let aGuessT = x;
  3557. for (let i = 0; i < 4; ++i) {
  3558. const currentSlope = getSlope(aGuessT, p0, p2);
  3559. if (currentSlope === 0)
  3560. return aGuessT;
  3561. const currentX = calcBezier(aGuessT, p0, p2) - x;
  3562. aGuessT -= currentX / currentSlope;
  3563. }
  3564. return aGuessT;
  3565. };
  3566. return (x) => p0 === p1 && p2 === p3 ? x : calcBezier(getTforX(x), p1, p3);
  3567. }
  3568. function useTransition(source, options = {}) {
  3569. const {
  3570. delay = 0,
  3571. disabled = false,
  3572. duration = 1e3,
  3573. onFinished = noop,
  3574. onStarted = noop,
  3575. transition = identity
  3576. } = options;
  3577. const currentTransition = computed(() => {
  3578. const t = unref(transition);
  3579. return isFunction(t) ? t : createEasingFunction(t);
  3580. });
  3581. const sourceValue = computed(() => {
  3582. const s = unref(source);
  3583. return isNumber(s) ? s : s.map(unref);
  3584. });
  3585. const sourceVector = computed(() => isNumber(sourceValue.value) ? [sourceValue.value] : sourceValue.value);
  3586. const outputVector = ref(sourceVector.value.slice(0));
  3587. let currentDuration;
  3588. let diffVector;
  3589. let endAt;
  3590. let startAt;
  3591. let startVector;
  3592. const { resume, pause } = useRafFn(() => {
  3593. const now2 = Date.now();
  3594. const progress = clamp(1 - (endAt - now2) / currentDuration, 0, 1);
  3595. outputVector.value = startVector.map((val, i) => {
  3596. var _a;
  3597. return val + ((_a = diffVector[i]) != null ? _a : 0) * currentTransition.value(progress);
  3598. });
  3599. if (progress >= 1) {
  3600. pause();
  3601. onFinished();
  3602. }
  3603. }, { immediate: false });
  3604. const start = () => {
  3605. pause();
  3606. currentDuration = unref(duration);
  3607. diffVector = outputVector.value.map((n, i) => {
  3608. var _a, _b;
  3609. return ((_a = sourceVector.value[i]) != null ? _a : 0) - ((_b = outputVector.value[i]) != null ? _b : 0);
  3610. });
  3611. startVector = outputVector.value.slice(0);
  3612. startAt = Date.now();
  3613. endAt = startAt + currentDuration;
  3614. resume();
  3615. onStarted();
  3616. };
  3617. const timeout = useTimeoutFn(start, delay, { immediate: false });
  3618. watch(sourceVector, () => {
  3619. if (unref(disabled)) {
  3620. outputVector.value = sourceVector.value.slice(0);
  3621. } else {
  3622. if (unref(delay) <= 0)
  3623. start();
  3624. else
  3625. timeout.start();
  3626. }
  3627. }, { deep: true });
  3628. return computed(() => {
  3629. const targetVector = unref(disabled) ? sourceVector : outputVector;
  3630. return isNumber(sourceValue.value) ? targetVector.value[0] : targetVector.value;
  3631. });
  3632. }
  3633. function useUrlSearchParams(mode = "history", options = {}) {
  3634. const {
  3635. initialValue = {},
  3636. removeNullishValues = true,
  3637. removeFalsyValues = false,
  3638. window: window2 = defaultWindow
  3639. } = options;
  3640. if (!window2)
  3641. return reactive(initialValue);
  3642. const state = reactive(initialValue);
  3643. function getRawParams() {
  3644. if (mode === "history") {
  3645. return window2.location.search || "";
  3646. } else if (mode === "hash") {
  3647. const hash = window2.location.hash || "";
  3648. const index = hash.indexOf("?");
  3649. return index > 0 ? hash.slice(index) : "";
  3650. } else {
  3651. return (window2.location.hash || "").replace(/^#/, "");
  3652. }
  3653. }
  3654. function constructQuery(params) {
  3655. const stringified = params.toString();
  3656. if (mode === "history")
  3657. return `${stringified ? `?${stringified}` : ""}${location.hash || ""}`;
  3658. if (mode === "hash-params")
  3659. return `${location.search || ""}${stringified ? `#${stringified}` : ""}`;
  3660. const hash = window2.location.hash || "#";
  3661. const index = hash.indexOf("?");
  3662. if (index > 0)
  3663. return `${hash.slice(0, index)}${stringified ? `?${stringified}` : ""}`;
  3664. return `${hash}${stringified ? `?${stringified}` : ""}`;
  3665. }
  3666. function read() {
  3667. return new URLSearchParams(getRawParams());
  3668. }
  3669. function updateState(params) {
  3670. const unusedKeys = new Set(Object.keys(state));
  3671. for (const key of params.keys()) {
  3672. const paramsForKey = params.getAll(key);
  3673. state[key] = paramsForKey.length > 1 ? paramsForKey : params.get(key) || "";
  3674. unusedKeys.delete(key);
  3675. }
  3676. Array.from(unusedKeys).forEach((key) => delete state[key]);
  3677. }
  3678. const { pause, resume } = pausableWatch(state, () => {
  3679. const params = new URLSearchParams("");
  3680. Object.keys(state).forEach((key) => {
  3681. const mapEntry = state[key];
  3682. if (Array.isArray(mapEntry))
  3683. mapEntry.forEach((value) => params.append(key, value));
  3684. else if (removeNullishValues && mapEntry == null)
  3685. params.delete(key);
  3686. else if (removeFalsyValues && !mapEntry)
  3687. params.delete(key);
  3688. else
  3689. params.set(key, mapEntry);
  3690. });
  3691. write(params);
  3692. }, { deep: true });
  3693. function write(params, shouldUpdate) {
  3694. pause();
  3695. if (shouldUpdate)
  3696. updateState(params);
  3697. window2.history.replaceState({}, "", window2.location.pathname + constructQuery(params));
  3698. resume();
  3699. }
  3700. function onChanged() {
  3701. write(read(), true);
  3702. }
  3703. useEventListener(window2, "popstate", onChanged, false);
  3704. if (mode !== "history")
  3705. useEventListener(window2, "hashchange", onChanged, false);
  3706. updateState(read());
  3707. return state;
  3708. }
  3709. function useUserMedia(options = {}) {
  3710. var _a, _b, _c;
  3711. const enabled = ref((_a = options.enabled) != null ? _a : false);
  3712. const autoSwitch = ref((_b = options.autoSwitch) != null ? _b : true);
  3713. const videoDeviceId = ref(options.videoDeviceId);
  3714. const audioDeviceId = ref(options.audioDeviceId);
  3715. const { navigator = defaultNavigator } = options;
  3716. const isSupported = Boolean((_c = navigator == null ? void 0 : navigator.mediaDevices) == null ? void 0 : _c.getUserMedia);
  3717. const stream = shallowRef();
  3718. function getDeviceOptions(device) {
  3719. if (device.value === "none" || device.value === false)
  3720. return false;
  3721. if (device.value == null)
  3722. return true;
  3723. return {
  3724. deviceId: device.value
  3725. };
  3726. }
  3727. function _start() {
  3728. return __async(this, null, function* () {
  3729. if (!isSupported || stream.value)
  3730. return;
  3731. stream.value = yield navigator.mediaDevices.getUserMedia({
  3732. video: getDeviceOptions(videoDeviceId),
  3733. audio: getDeviceOptions(audioDeviceId)
  3734. });
  3735. return stream.value;
  3736. });
  3737. }
  3738. function _stop() {
  3739. return __async(this, null, function* () {
  3740. var _a2;
  3741. (_a2 = stream.value) == null ? void 0 : _a2.getTracks().forEach((t) => t.stop());
  3742. stream.value = void 0;
  3743. });
  3744. }
  3745. function stop() {
  3746. _stop();
  3747. enabled.value = false;
  3748. }
  3749. function start() {
  3750. return __async(this, null, function* () {
  3751. yield _start();
  3752. if (stream.value)
  3753. enabled.value = true;
  3754. return stream.value;
  3755. });
  3756. }
  3757. function restart() {
  3758. return __async(this, null, function* () {
  3759. _stop();
  3760. return yield start();
  3761. });
  3762. }
  3763. watch(enabled, (v) => {
  3764. if (v)
  3765. _start();
  3766. else
  3767. _stop();
  3768. }, { immediate: true });
  3769. watch([videoDeviceId, audioDeviceId], () => {
  3770. if (autoSwitch.value && stream.value)
  3771. restart();
  3772. }, { immediate: true });
  3773. return {
  3774. isSupported,
  3775. stream,
  3776. start,
  3777. stop,
  3778. restart,
  3779. videoDeviceId,
  3780. audioDeviceId,
  3781. enabled,
  3782. autoSwitch
  3783. };
  3784. }
  3785. function useVModel(props, key, emit, options = {}) {
  3786. var _a, _b, _c;
  3787. const {
  3788. passive = false,
  3789. eventName,
  3790. deep = false
  3791. } = options;
  3792. const vm = getCurrentInstance();
  3793. const _emit = emit || (vm == null ? void 0 : vm.emit) || ((_a = vm == null ? void 0 : vm.$emit) == null ? void 0 : _a.bind(vm));
  3794. let event = eventName;
  3795. if (!key) {
  3796. if (isVue2) {
  3797. const modelOptions = (_c = (_b = vm == null ? void 0 : vm.proxy) == null ? void 0 : _b.$options) == null ? void 0 : _c.model;
  3798. key = (modelOptions == null ? void 0 : modelOptions.value) || "value";
  3799. if (!eventName)
  3800. event = (modelOptions == null ? void 0 : modelOptions.event) || "input";
  3801. } else {
  3802. key = "modelValue";
  3803. }
  3804. }
  3805. event = eventName || event || `update:${key}`;
  3806. if (passive) {
  3807. const proxy = ref(props[key]);
  3808. watch(() => props[key], (v) => proxy.value = v);
  3809. watch(proxy, (v) => {
  3810. if (v !== props[key] || deep)
  3811. _emit(event, v);
  3812. }, {
  3813. deep
  3814. });
  3815. return proxy;
  3816. } else {
  3817. return computed({
  3818. get() {
  3819. return props[key];
  3820. },
  3821. set(value) {
  3822. _emit(event, value);
  3823. }
  3824. });
  3825. }
  3826. }
  3827. function useVModels(props, emit, options = {}) {
  3828. const ret = {};
  3829. for (const key in props)
  3830. ret[key] = useVModel(props, key, emit, options);
  3831. return ret;
  3832. }
  3833. function useVirtualList(list, options) {
  3834. const containerRef = ref();
  3835. const size = useElementSize(containerRef);
  3836. const currentList = ref([]);
  3837. const source = shallowRef(list);
  3838. const state = ref({ start: 0, end: 10 });
  3839. const { itemHeight, overscan = 5 } = options;
  3840. const getViewCapacity = (containerHeight) => {
  3841. if (typeof itemHeight === "number")
  3842. return Math.ceil(containerHeight / itemHeight);
  3843. const { start = 0 } = state.value;
  3844. let sum = 0;
  3845. let capacity = 0;
  3846. for (let i = start; i < source.value.length; i++) {
  3847. const height = itemHeight(i);
  3848. sum += height;
  3849. if (sum >= containerHeight) {
  3850. capacity = i;
  3851. break;
  3852. }
  3853. }
  3854. return capacity - start;
  3855. };
  3856. const getOffset = (scrollTop) => {
  3857. if (typeof itemHeight === "number")
  3858. return Math.floor(scrollTop / itemHeight) + 1;
  3859. let sum = 0;
  3860. let offset = 0;
  3861. for (let i = 0; i < source.value.length; i++) {
  3862. const height = itemHeight(i);
  3863. sum += height;
  3864. if (sum >= scrollTop) {
  3865. offset = i;
  3866. break;
  3867. }
  3868. }
  3869. return offset + 1;
  3870. };
  3871. const calculateRange = () => {
  3872. const element = containerRef.value;
  3873. if (element) {
  3874. const offset = getOffset(element.scrollTop);
  3875. const viewCapacity = getViewCapacity(element.clientHeight);
  3876. const from = offset - overscan;
  3877. const to = offset + viewCapacity + overscan;
  3878. state.value = {
  3879. start: from < 0 ? 0 : from,
  3880. end: to > source.value.length ? source.value.length : to
  3881. };
  3882. currentList.value = source.value.slice(state.value.start, state.value.end).map((ele, index) => ({
  3883. data: ele,
  3884. index: index + state.value.start
  3885. }));
  3886. }
  3887. };
  3888. watch([size.width, size.height, list], () => {
  3889. calculateRange();
  3890. });
  3891. const totalHeight = computed(() => {
  3892. if (typeof itemHeight === "number")
  3893. return source.value.length * itemHeight;
  3894. return source.value.reduce((sum, _, index) => sum + itemHeight(index), 0);
  3895. });
  3896. const getDistanceTop = (index) => {
  3897. if (typeof itemHeight === "number") {
  3898. const height2 = index * itemHeight;
  3899. return height2;
  3900. }
  3901. const height = source.value.slice(0, index).reduce((sum, _, i) => sum + itemHeight(i), 0);
  3902. return height;
  3903. };
  3904. const scrollTo = (index) => {
  3905. if (containerRef.value) {
  3906. containerRef.value.scrollTop = getDistanceTop(index);
  3907. calculateRange();
  3908. }
  3909. };
  3910. const offsetTop = computed(() => getDistanceTop(state.value.start));
  3911. const wrapperProps = computed(() => {
  3912. return {
  3913. style: {
  3914. width: "100%",
  3915. height: `${totalHeight.value - offsetTop.value}px`,
  3916. marginTop: `${offsetTop.value}px`
  3917. }
  3918. };
  3919. });
  3920. const containerStyle = { overflowY: "auto" };
  3921. return {
  3922. list: currentList,
  3923. scrollTo,
  3924. containerProps: {
  3925. ref: containerRef,
  3926. onScroll: () => {
  3927. calculateRange();
  3928. },
  3929. style: containerStyle
  3930. },
  3931. wrapperProps
  3932. };
  3933. }
  3934. var useWakeLock = (options = {}) => {
  3935. const { navigator = defaultNavigator, document: document2 = defaultDocument } = options;
  3936. let wakeLock;
  3937. const isSupported = navigator && "wakeLock" in navigator;
  3938. const isActive = ref(false);
  3939. function onVisibilityChange() {
  3940. return __async(this, null, function* () {
  3941. if (!isSupported || !wakeLock)
  3942. return;
  3943. if (document2 && document2.visibilityState === "visible")
  3944. wakeLock = yield navigator.wakeLock.request("screen");
  3945. isActive.value = !wakeLock.released;
  3946. });
  3947. }
  3948. if (document2)
  3949. useEventListener(document2, "visibilitychange", onVisibilityChange, { passive: true });
  3950. function request(type) {
  3951. return __async(this, null, function* () {
  3952. if (!isSupported)
  3953. return;
  3954. wakeLock = yield navigator.wakeLock.request(type);
  3955. isActive.value = !wakeLock.released;
  3956. });
  3957. }
  3958. function release() {
  3959. return __async(this, null, function* () {
  3960. if (!isSupported || !wakeLock)
  3961. return;
  3962. yield wakeLock.release();
  3963. isActive.value = !wakeLock.released;
  3964. wakeLock = null;
  3965. });
  3966. }
  3967. return {
  3968. isSupported,
  3969. isActive,
  3970. request,
  3971. release
  3972. };
  3973. };
  3974. function resolveNestedOptions(options) {
  3975. if (options === true)
  3976. return {};
  3977. return options;
  3978. }
  3979. function useWebSocket(url, options = {}) {
  3980. const {
  3981. onConnected,
  3982. onDisconnected,
  3983. onError,
  3984. onMessage,
  3985. immediate = true,
  3986. autoClose = true,
  3987. protocols = []
  3988. } = options;
  3989. const data = ref(null);
  3990. const status = ref("CONNECTING");
  3991. const wsRef = ref();
  3992. let heartbeatPause;
  3993. let heartbeatResume;
  3994. let explicitlyClosed = false;
  3995. let retried = 0;
  3996. let bufferedData = [];
  3997. const close = (code, reason) => {
  3998. if (!wsRef.value)
  3999. return;
  4000. explicitlyClosed = true;
  4001. heartbeatPause == null ? void 0 : heartbeatPause();
  4002. wsRef.value.close(code, reason);
  4003. };
  4004. const _sendBuffer = () => {
  4005. if (bufferedData.length && wsRef.value && status.value === "OPEN") {
  4006. for (const buffer of bufferedData)
  4007. wsRef.value.send(buffer);
  4008. bufferedData = [];
  4009. }
  4010. };
  4011. const send = (data2, useBuffer = true) => {
  4012. if (!wsRef.value || status.value !== "OPEN") {
  4013. if (useBuffer)
  4014. bufferedData.push(data2);
  4015. return false;
  4016. }
  4017. _sendBuffer();
  4018. wsRef.value.send(data2);
  4019. return true;
  4020. };
  4021. const _init = () => {
  4022. const ws = new WebSocket(url, protocols);
  4023. wsRef.value = ws;
  4024. status.value = "CONNECTING";
  4025. explicitlyClosed = false;
  4026. ws.onopen = () => {
  4027. status.value = "OPEN";
  4028. onConnected == null ? void 0 : onConnected(ws);
  4029. heartbeatResume == null ? void 0 : heartbeatResume();
  4030. _sendBuffer();
  4031. };
  4032. ws.onclose = (ev) => {
  4033. status.value = "CLOSED";
  4034. wsRef.value = void 0;
  4035. onDisconnected == null ? void 0 : onDisconnected(ws, ev);
  4036. if (!explicitlyClosed && options.autoReconnect) {
  4037. const {
  4038. retries = -1,
  4039. delay = 1e3,
  4040. onFailed
  4041. } = resolveNestedOptions(options.autoReconnect);
  4042. retried += 1;
  4043. if (retries < 0 || retried < retries)
  4044. setTimeout(_init, delay);
  4045. else
  4046. onFailed == null ? void 0 : onFailed();
  4047. }
  4048. };
  4049. ws.onerror = (e) => {
  4050. onError == null ? void 0 : onError(ws, e);
  4051. };
  4052. ws.onmessage = (e) => {
  4053. data.value = e.data;
  4054. onMessage == null ? void 0 : onMessage(ws, e);
  4055. };
  4056. };
  4057. if (options.heartbeat) {
  4058. const {
  4059. message = "ping",
  4060. interval = 1e3
  4061. } = resolveNestedOptions(options.heartbeat);
  4062. const { pause, resume } = useIntervalFn(() => send(message, false), interval, { immediate: false });
  4063. heartbeatPause = pause;
  4064. heartbeatResume = resume;
  4065. }
  4066. if (immediate)
  4067. _init();
  4068. if (autoClose) {
  4069. useEventListener(window, "beforeunload", close);
  4070. tryOnScopeDispose(close);
  4071. }
  4072. const open = () => {
  4073. close();
  4074. retried = 0;
  4075. _init();
  4076. };
  4077. return {
  4078. data,
  4079. status,
  4080. close,
  4081. send,
  4082. open,
  4083. ws: wsRef
  4084. };
  4085. }
  4086. function useWebWorker(url, workerOptions, options = {}) {
  4087. const {
  4088. window: window2 = defaultWindow
  4089. } = options;
  4090. const data = ref(null);
  4091. const worker = shallowRef();
  4092. const post = function post2(val) {
  4093. if (!worker.value)
  4094. return;
  4095. worker.value.postMessage(val);
  4096. };
  4097. const terminate = function terminate2() {
  4098. if (!worker.value)
  4099. return;
  4100. worker.value.terminate();
  4101. };
  4102. if (window2) {
  4103. worker.value = new window2.Worker(url, workerOptions);
  4104. worker.value.onmessage = (e) => {
  4105. data.value = e.data;
  4106. };
  4107. tryOnScopeDispose(() => {
  4108. if (worker.value)
  4109. worker.value.terminate();
  4110. });
  4111. }
  4112. return {
  4113. data,
  4114. post,
  4115. terminate,
  4116. worker
  4117. };
  4118. }
  4119. var jobRunner = (userFunc) => (e) => {
  4120. const userFuncArgs = e.data[0];
  4121. return Promise.resolve(userFunc.apply(void 0, userFuncArgs)).then((result) => {
  4122. postMessage(["SUCCESS", result]);
  4123. }).catch((error) => {
  4124. postMessage(["ERROR", error]);
  4125. });
  4126. };
  4127. var depsParser = (deps) => {
  4128. if (deps.length === 0)
  4129. return "";
  4130. const depsString = deps.map((dep) => `${dep}`).toString();
  4131. return `importScripts('${depsString}')`;
  4132. };
  4133. var createWorkerBlobUrl = (fn, deps) => {
  4134. const blobCode = `${depsParser(deps)}; onmessage=(${jobRunner})(${fn})`;
  4135. const blob = new Blob([blobCode], { type: "text/javascript" });
  4136. const url = URL.createObjectURL(blob);
  4137. return url;
  4138. };
  4139. var useWebWorkerFn = (fn, options = {}) => {
  4140. const {
  4141. dependencies = [],
  4142. timeout,
  4143. window: window2 = defaultWindow
  4144. } = options;
  4145. const worker = ref();
  4146. const workerStatus = ref("PENDING");
  4147. const promise = ref({});
  4148. const timeoutId = ref();
  4149. const workerTerminate = (status = "PENDING") => {
  4150. if (worker.value && worker.value._url && window2) {
  4151. worker.value.terminate();
  4152. URL.revokeObjectURL(worker.value._url);
  4153. promise.value = {};
  4154. worker.value = void 0;
  4155. window2.clearTimeout(timeoutId.value);
  4156. workerStatus.value = status;
  4157. }
  4158. };
  4159. workerTerminate();
  4160. tryOnScopeDispose(workerTerminate);
  4161. const generateWorker = () => {
  4162. const blobUrl = createWorkerBlobUrl(fn, dependencies);
  4163. const newWorker = new Worker(blobUrl);
  4164. newWorker._url = blobUrl;
  4165. newWorker.onmessage = (e) => {
  4166. const { resolve = () => {
  4167. }, reject = () => {
  4168. } } = promise.value;
  4169. const [status, result] = e.data;
  4170. switch (status) {
  4171. case "SUCCESS":
  4172. resolve(result);
  4173. workerTerminate(status);
  4174. break;
  4175. default:
  4176. reject(result);
  4177. workerTerminate("ERROR");
  4178. break;
  4179. }
  4180. };
  4181. newWorker.onerror = (e) => {
  4182. const { reject = () => {
  4183. } } = promise.value;
  4184. reject(e);
  4185. workerTerminate("ERROR");
  4186. };
  4187. if (timeout) {
  4188. timeoutId.value = setTimeout(() => workerTerminate("TIMEOUT_EXPIRED"), timeout);
  4189. }
  4190. return newWorker;
  4191. };
  4192. const callWorker = (...fnArgs) => new Promise((resolve, reject) => {
  4193. promise.value = {
  4194. resolve,
  4195. reject
  4196. };
  4197. worker.value && worker.value.postMessage([[...fnArgs]]);
  4198. workerStatus.value = "RUNNING";
  4199. });
  4200. const workerFn = (...fnArgs) => {
  4201. if (workerStatus.value === "RUNNING") {
  4202. console.error("[useWebWorkerFn] You can only run one instance of the worker at a time.");
  4203. return Promise.reject();
  4204. }
  4205. worker.value = generateWorker();
  4206. return callWorker(...fnArgs);
  4207. };
  4208. return {
  4209. workerFn,
  4210. workerStatus,
  4211. workerTerminate
  4212. };
  4213. };
  4214. function useWindowFocus({ window: window2 = defaultWindow } = {}) {
  4215. if (!window2)
  4216. return ref(false);
  4217. const focused = ref(window2.document.hasFocus());
  4218. useEventListener(window2, "blur", () => {
  4219. focused.value = false;
  4220. });
  4221. useEventListener(window2, "focus", () => {
  4222. focused.value = true;
  4223. });
  4224. return focused;
  4225. }
  4226. function useWindowScroll({ window: window2 = defaultWindow } = {}) {
  4227. if (!window2) {
  4228. return {
  4229. x: ref(0),
  4230. y: ref(0)
  4231. };
  4232. }
  4233. const x = ref(window2.pageXOffset);
  4234. const y = ref(window2.pageYOffset);
  4235. useEventListener("scroll", () => {
  4236. x.value = window2.pageXOffset;
  4237. y.value = window2.pageYOffset;
  4238. }, {
  4239. capture: false,
  4240. passive: true
  4241. });
  4242. return { x, y };
  4243. }
  4244. function useWindowSize({ window: window2 = defaultWindow, initialWidth = Infinity, initialHeight = Infinity } = {}) {
  4245. if (!window2) {
  4246. return {
  4247. width: ref(initialWidth),
  4248. height: ref(initialHeight)
  4249. };
  4250. }
  4251. const width = ref(window2.innerWidth);
  4252. const height = ref(window2.innerHeight);
  4253. useEventListener("resize", () => {
  4254. width.value = window2.innerWidth;
  4255. height.value = window2.innerHeight;
  4256. }, { passive: true });
  4257. return { width, height };
  4258. }
  4259. export {
  4260. DefaultMagicKeysAliasMap,
  4261. StorageSerializers,
  4262. SwipeDirection,
  4263. TransitionPresets,
  4264. and,
  4265. assert,
  4266. asyncComputed,
  4267. autoResetRef,
  4268. biSyncRef,
  4269. breakpointsAntDesign,
  4270. breakpointsBootstrapV5,
  4271. breakpointsQuasar,
  4272. breakpointsSematic,
  4273. breakpointsTailwind,
  4274. breakpointsVuetify,
  4275. bypassFilter,
  4276. clamp,
  4277. computedInject,
  4278. containsProp,
  4279. controlledComputed,
  4280. controlledRef,
  4281. createEventHook,
  4282. createFetch,
  4283. createFilterWrapper,
  4284. createGlobalState,
  4285. reactify as createReactiveFn,
  4286. createSharedComposable,
  4287. createSingletonPromise,
  4288. createUnrefFn,
  4289. debounceFilter,
  4290. useDebounce as debouncedRef,
  4291. debouncedWatch,
  4292. eagerComputed,
  4293. extendRef,
  4294. get,
  4295. identity,
  4296. ignorableWatch,
  4297. increaseWithUnit,
  4298. invoke,
  4299. isBoolean,
  4300. isClient,
  4301. isDef,
  4302. isDefined,
  4303. isFunction,
  4304. isNumber,
  4305. isObject,
  4306. isString,
  4307. isWindow,
  4308. makeDestructurable,
  4309. noop,
  4310. not,
  4311. now,
  4312. objectPick,
  4313. onClickOutside,
  4314. onKeyDown,
  4315. onKeyPressed,
  4316. onKeyStroke,
  4317. onKeyUp,
  4318. onStartTyping,
  4319. or,
  4320. pausableFilter,
  4321. pausableWatch,
  4322. promiseTimeout,
  4323. rand,
  4324. reactify,
  4325. reactifyObject,
  4326. reactivePick,
  4327. refDefault,
  4328. set,
  4329. syncRef,
  4330. templateRef,
  4331. throttleFilter,
  4332. useThrottle as throttledRef,
  4333. throttledWatch,
  4334. timestamp,
  4335. toReactive,
  4336. toRefs,
  4337. tryOnBeforeUnmount,
  4338. tryOnMounted,
  4339. tryOnScopeDispose,
  4340. tryOnUnmounted,
  4341. unrefElement,
  4342. until,
  4343. useActiveElement,
  4344. useAsyncState,
  4345. useBase64,
  4346. useBattery,
  4347. useBreakpoints,
  4348. useBrowserLocation,
  4349. useClipboard,
  4350. useConfirmDialog,
  4351. useCounter,
  4352. useCssVar,
  4353. useDark,
  4354. useDebounce,
  4355. useDebounceFn,
  4356. useDebouncedRefHistory,
  4357. useDeviceMotion,
  4358. useDeviceOrientation,
  4359. useDevicePixelRatio,
  4360. useDevicesList,
  4361. useDisplayMedia,
  4362. useDocumentVisibility,
  4363. useDraggable,
  4364. useElementBounding,
  4365. useElementHover,
  4366. useElementSize,
  4367. useElementVisibility,
  4368. useEventBus,
  4369. useEventListener,
  4370. useEventSource,
  4371. useEyeDropper,
  4372. useFavicon,
  4373. useFetch,
  4374. useFocus,
  4375. useFps,
  4376. useFullscreen,
  4377. useGeolocation,
  4378. useIdle,
  4379. useIntersectionObserver,
  4380. useInterval,
  4381. useIntervalFn,
  4382. useKeyModifier,
  4383. useLastChanged,
  4384. useLocalStorage,
  4385. useMagicKeys,
  4386. useManualRefHistory,
  4387. useMediaControls,
  4388. useMediaQuery,
  4389. useMemory,
  4390. useMouse,
  4391. useMouseInElement,
  4392. useMousePressed,
  4393. useMutationObserver,
  4394. useNetwork,
  4395. useNow,
  4396. useOnline,
  4397. usePageLeave,
  4398. useParallax,
  4399. usePermission,
  4400. usePointer,
  4401. usePointerSwipe,
  4402. usePreferredColorScheme,
  4403. usePreferredDark,
  4404. usePreferredLanguages,
  4405. useRafFn,
  4406. useRefHistory,
  4407. useResizeObserver,
  4408. useScriptTag,
  4409. useScroll,
  4410. useSessionStorage,
  4411. useShare,
  4412. useSpeechRecognition,
  4413. useSpeechSynthesis,
  4414. useStorage,
  4415. useSwipe,
  4416. useTemplateRefsList,
  4417. useThrottle,
  4418. useThrottleFn,
  4419. useThrottledRefHistory,
  4420. useTimeAgo,
  4421. useTimeout,
  4422. useTimeoutFn,
  4423. useTimestamp,
  4424. useTitle,
  4425. useToggle,
  4426. useTransition,
  4427. useUrlSearchParams,
  4428. useUserMedia,
  4429. useVModel,
  4430. useVModels,
  4431. useVirtualList,
  4432. useWakeLock,
  4433. useWebSocket,
  4434. useWebWorker,
  4435. useWebWorkerFn,
  4436. useWindowFocus,
  4437. useWindowScroll,
  4438. useWindowSize,
  4439. watchAtMost,
  4440. watchOnce,
  4441. watchWithFilter,
  4442. whenever
  4443. };
  4444. //# sourceMappingURL=@vueuse_core.js.map