stacks 0.58.72 → 0.59.1

package/core/utils/dist/index.js

@@ -1,1311 +0,0 @@
-// @bun
-// src/base.ts
-import {toString} from "@stacksjs/strings";
-async function loop(times, callback) {
-  [...Array(times)].forEach(async (item, i) => await callback(i));
-}
-// src/clean.ts
-import {path as p} from "@stacksjs/path";
-
-// src/delete.ts
-import {rimraf} from "rimraf";
-
-// src/clean.ts
-async function cleanProject() {
-  return await rimraf([
-    p.projectPath("bun.lockb"),
-    p.projectPath("yarn.lock"),
-    p.projectPath("node_modules/"),
-    p.frameworkPath("dist"),
-    p.frameworkPath("node_modules"),
-    p.frameworkPath("**/dist"),
-    p.frameworkPath("**/node_modules"),
-    p.frameworkCloudPath("cdk.out/"),
-    p.frameworkCloudPath("cdk.context.json"),
-    p.frameworkCloudPath("dist.zip")
-  ]);
-}
-// src/config.ts
-import {
-defineApp,
-defineCache,
-defineCli,
-defineCdn,
-defineCronJob,
-defineJob,
-defineDependencies,
-defineDatabase,
-defineDns,
-defineEmailConfig,
-defineGit,
-defineHashing,
-defineLibrary,
-defineNotification,
-defineSms,
-defineEmail,
-defineChat,
-definePayment,
-defineQueue,
-defineSearchEngine,
-defineServices,
-defineStorage,
-defineUi
-} from "@stacksjs/config";
-// src/currency.ts
-import {
-add,
-allocate,
-compare,
-convert,
-equal,
-greaterThan,
-greaterThanOrEqual,
-hasSubUnits,
-isZero,
-lessThan,
-lessThanOrEqual,
-maximum,
-minimum,
-multiply,
-normalizeScale,
-dinero,
-dinero as dinero2,
-subtract,
-toSnapshot,
-toUnits,
-toDecimal,
-trimScale,
-haveSameCurrency,
-haveSameAmount,
-dinero as dinero3
-} from "dinero.js";
-import {USD} from "@dinero.js/currencies";
-// src/debounce.ts
-import {debounce} from "perfect-debounce";
-// src/equal.ts
-import {getTypeName} from "@stacksjs/types";
-function isDeepEqual(value1, value2) {
-  const type1 = getTypeName(value1);
-  const type2 = getTypeName(value2);
-  if (type1 !== type2)
-    return false;
-  if (type1 === "array") {
-    if (value1.length !== value2.length)
-      return false;
-    return value1.every((item, i) => {
-      return isDeepEqual(item, value2[i]);
-    });
-  }
-  if (type1 === "object") {
-    const keyArr = Object.keys(value1);
-    if (keyArr.length !== Object.keys(value2).length)
-      return false;
-    return keyArr.every((key) => {
-      return isDeepEqual(value1[key], value2[key]);
-    });
-  }
-  return Object.is(value1, value2);
-}
-// src/export-size.ts
-import {getExportsSize} from "export-size";
-// src/function.ts
-function batchInvoke(functions) {
-  functions.forEach((fn) => fn && fn());
-}
-function tap(value, callback) {
-  callback(value);
-  return value;
-}
-// src/git.ts
-import {execSync} from "child_process";
-function isGitClean() {
-  try {
-    execSync("git diff-index --quiet HEAD --");
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-// src/guards.ts
-function notNullish(v) {
-  return v != null;
-}
-function noNull(v) {
-  return v !== null;
-}
-function notUndefined(v) {
-  return v !== undefined;
-}
-function isTruthy(v) {
-  return Boolean(v);
-}
-// src/hash.ts
-import {hashPaths} from "@stacksjs/storage";
-import {path as p2} from "@stacksjs/path";
-import {config as config2} from "@stacksjs/config";
-function originRequestFunctionHash() {
-  try {
-    return hashPaths(p2.cloudPath("src/edge"));
-  } catch (error) {
-    log.error("Are we in a Docker container? Failed to hash paths. Error below:");
-    log.error(error);
-    return;
-  }
-}
-var docsSrc = [
-  p2.projectPath("docs"),
-  p2.projectPath("config/docs.ts")
-];
-var websiteSrc = [
-  p2.projectPath("resources/views")
-];
-var websiteSourceHash = config2.app.docMode === true ? hashPaths(docsSrc) : hashPaths(websiteSrc);
-// src/helpers.ts
-import {log as log2, runCommand} from "@stacksjs/cli";
-import {err, handleError, ok} from "@stacksjs/error-handling";
-import {frameworkPath, projectPath} from "@stacksjs/path";
-import * as storage2 from "@stacksjs/storage";
-import {Action} from "@stacksjs/enums";
-import {parse} from "yaml";
-import {app, ui} from "@stacksjs/config";
-async function packageManager() {
-  const { packageManager: packageManager2 } = await storage2.readPackageJson(frameworkPath("package.json"));
-  return packageManager2;
-}
-async function initProject() {
-  if (app.env !== "production")
-    log2.info("Project not yet initialized, generating application key...");
-  else
-    handleError("Please run `buddy key:generate` to generate an application key");
-  const result = await runAction(Action.KeyGenerate, { cwd: projectPath() });
-  if (result.isErr())
-    return err(handleError(result.error));
-  log2.info("Application key generated.");
-  return ok(result.value);
-}
-async function ensureProjectIsInitialized() {
-  if (storage2.isFile(projectPath(".env")))
-    return await isAppKeySet();
-  if (storage2.isFile(projectPath(".env.example")))
-    await runCommand("cp .env.example .env", { cwd: projectPath() });
-  else
-    console.error("no .env.example file found");
-  return await isAppKeySet();
-}
-async function installIfVersionMismatch() {
-}
-async function frameworkVersion() {
-  return (await storage2.readPackageJson(frameworkPath("package.json"))).version;
-}
-async function isAppKeySet() {
-  const env = await storage2.readTextFile(".env", projectPath());
-  const lines = env.data.split("\n");
-  const appKey = lines.find((line) => line.startsWith("APP_KEY="));
-  return !!(appKey && appKey.length > 16);
-}
-function determineResetPreset(preset) {
-  if (ui.reset)
-    preset = ui.reset;
-  if (preset === "tailwind")
-    return ["import \'@unocss/reset/tailwind.css\'"];
-  if (preset === "normalize")
-    return ["import \'@unocss/reset/normalize.css\'"];
-  if (preset === "sanitize")
-    return ["import \'@unocss/reset/sanitize/sanitize.css\'", "import \'@unocss/reset/sanitize/assets.css"];
-  if (preset === "eric-meyer")
-    return ["import \'@unocss/reset/eric-meyer.css\'"];
-  if (preset === "antfu")
-    return ["import \'@unocss/reset/antfu.css\'"];
-  return [];
-}
-function isManifest(obj) {
-  return obj && typeof obj === "object" && isOptionalString(obj.name) && isOptionalString(obj.version) && isOptionalString(obj.description);
-}
-function isOptionalString(value) {
-  const type = typeof value;
-  return value === null || type === "undefined" || type === "string";
-}
-async function setEnvValue(key, value) {
-  const file = await storage2.readTextFile(projectPath(".env"));
-  await storage2.writeTextFile({
-    path: projectPath(".env"),
-    data: file.data.replace(/APP_KEY=/g, `APP_KEY=${value}`)
-  });
-}
-async function runNpmScript(script, options) {
-  const { data: manifest } = await storage2.readJsonFile("package.json", frameworkPath());
-  if (isManifest(manifest) && hasScript(manifest, script))
-    return await runCommand(`bun --bun run ${script}`, options);
-  return err(handleError(`The ${script} script does not exist in the package.json file.`));
-}
-function hasScript(manifest, script) {
-  const scripts = manifest.scripts;
-  if (scripts && typeof scripts === "object")
-    return Boolean(scripts[script]);
-  return false;
-}
-function parseYaml(content) {
-  return parse(content);
-}
-function determineDebugLevel(options) {
-  if (options?.verbose === true)
-    return true;
-  return app.debug === true;
-}
-function isIpv6(address) {
-  return address.family === "IPv6" || address.family === 6;
-}
-import {dump, load} from "js-yaml";
-// src/macroable.ts
-import {Macroable} from "macroable";
-// src/math.ts
-function rand(min, max) {
-  min = Math.ceil(min);
-  max = Math.floor(max);
-  return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-import {
-and,
-createGenericProjection,
-createProjection,
-logicNot,
-logicOr,
-or,
-useAbs,
-useAverage,
-useCeil,
-useClamp,
-useFloor,
-useMath,
-useMax,
-useMin,
-usePrecision,
-useProjection,
-useRound,
-useSum,
-useTrunc
-} from "@vueuse/math";
-var clamp = (n, min, max) => Math.min(max, Math.max(min, n));
-// src/p.ts
-import pLimit from "p-limit";
-function p3(items, options) {
-  return new PInstance(items, options);
-}
-var VOID = Symbol("p-void");
-
-class PInstance extends Promise {
-  items;
-  options;
-  promises = new Set;
-  get promise() {
-    let batch;
-    const items = [...Array.from(this.items), ...Array.from(this.promises)];
-    if (this.options?.concurrency) {
-      const limit = pLimit(this.options.concurrency);
-      batch = Promise.all(items.map((p4) => limit(() => p4)));
-    } else {
-      batch = Promise.all(items);
-    }
-    return batch.then((l) => l.filter((i) => i !== VOID));
-  }
-  constructor(items = [], options) {
-    super(() => {
-    });
-    this.items = items;
-    this.options = options;
-  }
-  add(...args) {
-    args.forEach((i) => {
-      this.promises.add(i);
-    });
-  }
-  map(fn) {
-    return new PInstance(Array.from(this.items).map(async (i, idx) => {
-      const v = await i;
-      if (v === VOID)
-        return VOID;
-      return fn(v, idx);
-    }), this.options);
-  }
-  filter(fn) {
-    return new PInstance(Array.from(this.items).map(async (i, idx) => {
-      const v = await i;
-      const r = await fn(v, idx);
-      if (!r)
-        return VOID;
-      return v;
-    }), this.options);
-  }
-  forEach(fn) {
-    return this.map(fn).then();
-  }
-  reduce(fn, initialValue) {
-    return this.promise.then((array) => array.reduce(fn, initialValue));
-  }
-  clear() {
-    this.promises.clear();
-  }
-  then(fn) {
-    const p4 = this.promise;
-    if (fn)
-      return p4.then(fn);
-    return p4;
-  }
-  catch(fn) {
-    return this.promise.catch(fn);
-  }
-  finally(fn) {
-    return this.promise.finally(fn);
-  }
-}
-// src/promise.ts
-import {remove} from "@stacksjs/arrays";
-function createSingletonPromise(fn) {
-  let _promise;
-  function wrapper() {
-    if (!_promise)
-      _promise = fn();
-    return _promise;
-  }
-  wrapper.reset = async () => {
-    const _prev = _promise;
-    _promise = undefined;
-    if (_prev)
-      await _prev;
-  };
-  return wrapper;
-}
-function createPromiseLock() {
-  const locks = [];
-  return {
-    async run(fn) {
-      const p4 = fn();
-      locks.push(p4);
-      try {
-        return await p4;
-      } finally {
-        remove(locks, p4);
-      }
-    },
-    async wait() {
-      await Promise.allSettled(locks);
-    },
-    isWaiting() {
-      return Boolean(locks.length);
-    },
-    clear() {
-      locks.length = 0;
-    }
-  };
-}
-function createControlledPromise() {
-  let resolve, reject;
-  const promise = new Promise((_resolve, _reject) => {
-    resolve = _resolve;
-    reject = _reject;
-  });
-  promise.resolve = resolve;
-  promise.reject = reject;
-  return promise;
-}
-// /home/runner/work/stacks/stacks/node_modules/magic-regexp/dist/shared/magic-regexp.b7c910ac.mjs
-var NO_WRAP_RE = /^(\(.*\)|\\?.)$/;
-var wrap = (s) => {
-  const v = s.toString();
-  return NO_WRAP_RE.test(v) ? v : `(?:${v})`;
-};
-var GROUPED_AS_REPLACE_RE = /^(?:\(\?:(.+)\)|(\(?.+\)?))$/;
-var GROUPED_REPLACE_RE = /^(?:\(\?:(.+)\)([?+*]|{[\d,]+})?|(.+))$/;
-var createInput = (s) => {
-  const groupedAsFn = (key) => createInput(`(?<${key}>${`${s}`.replace(GROUPED_AS_REPLACE_RE, "$1$2")})`);
-  return {
-    toString: () => s.toString(),
-    and: Object.assign((...inputs) => createInput(`${s}${exactly(...inputs)}`), {
-      referenceTo: (groupName) => createInput(`${s}\\k<${groupName}>`)
-    }),
-    or: (...inputs) => createInput(`(?:${s}|${exactly(...inputs)})`),
-    after: (...input) => createInput(`(?<=${exactly(...input)})${s}`),
-    before: (...input) => createInput(`${s}(?=${exactly(...input)})`),
-    notAfter: (...input) => createInput(`(?<!${exactly(...input)})${s}`),
-    notBefore: (...input) => createInput(`${s}(?!${exactly(...input)})`),
-    times: Object.assign((number) => createInput(`${wrap(s)}{${number}}`), {
-      any: () => createInput(`${wrap(s)}*`),
-      atLeast: (min) => createInput(`${wrap(s)}{${min},}`),
-      atMost: (max) => createInput(`${wrap(s)}{0,${max}}`),
-      between: (min, max) => createInput(`${wrap(s)}{${min},${max}}`)
-    }),
-    optionally: () => createInput(`${wrap(s)}?`),
-    as: groupedAsFn,
-    groupedAs: groupedAsFn,
-    grouped: () => createInput(`${s}`.replace(GROUPED_REPLACE_RE, "($1$3)$2")),
-    at: {
-      lineStart: () => createInput(`^${s}`),
-      lineEnd: () => createInput(`${s}\$`)
-    }
-  };
-};
-var ESCAPE_REPLACE_RE = /[.*+?^${}()|[\]\\/]/g;
-var charIn = (chars) => createInput(`[${chars.replace(/[-\\^\]]/g, "\\$&")}]`);
-var charNotIn = (chars) => createInput(`[^${chars.replace(/[-\\^\]]/g, "\\$&")}]`);
-var anyOf = (...inputs) => createInput(`(?:${inputs.map((a) => exactly(a)).join("|")})`);
-var char = createInput(".");
-var word = createInput("\\b\\w+\\b");
-var wordChar = createInput("\\w");
-var wordBoundary = createInput("\\b");
-var digit = createInput("\\d");
-var whitespace = createInput("\\s");
-var letter = Object.assign(createInput("[a-zA-Z]"), {
-  lowercase: createInput("[a-z]"),
-  uppercase: createInput("[A-Z]")
-});
-var tab = createInput("\\t");
-var linefeed = createInput("\\n");
-var carriageReturn = createInput("\\r");
-var not = {
-  word: createInput("\\W+"),
-  wordChar: createInput("\\W"),
-  wordBoundary: createInput("\\B"),
-  digit: createInput("\\D"),
-  whitespace: createInput("\\S"),
-  letter: Object.assign(createInput("[^a-zA-Z]"), {
-    lowercase: createInput("[^a-z]"),
-    uppercase: createInput("[^A-Z]")
-  }),
-  tab: createInput("[^\\t]"),
-  linefeed: createInput("[^\\n]"),
-  carriageReturn: createInput("[^\\r]")
-};
-var maybe = (...inputs) => createInput(`${wrap(exactly(...inputs))}?`);
-var exactly = (...inputs) => createInput(inputs.map((input) => typeof input === "string" ? input.replace(ESCAPE_REPLACE_RE, "\\$&") : input).join(""));
-var oneOrMore = (...inputs) => createInput(`${wrap(exactly(...inputs))}+`);
-var withIndices = "d";
-var caseInsensitive = "i";
-var global = "g";
-var multiline = "m";
-var dotAll = "s";
-var unicode = "u";
-var sticky = "y";
-
-// /home/runner/work/stacks/stacks/node_modules/magic-regexp/dist/index.mjs
-var createRegExp = (...inputs) => {
-  const flags = inputs.length > 1 && (Array.isArray(inputs[inputs.length - 1]) || inputs[inputs.length - 1] instanceof Set) ? inputs.pop() : undefined;
-  return new RegExp(exactly(...inputs).toString(), [...flags || ""].join(""));
-};
-// src/retry.ts
-function retry(fn, options) {
-  const { retries = 3, initialDelay = 1000, backoffFactor = 2, jitter = true } = options;
-  return new Promise((resolve, reject) => {
-    let attemptCount = 0;
-    const attempt = async () => {
-      try {
-        resolve(await fn());
-      } catch (err2) {
-        if (attemptCount >= retries) {
-          reject(err2);
-        } else {
-          const delay = calculateDelay(attemptCount, initialDelay, backoffFactor, jitter);
-          setTimeout(() => attempt(), delay);
-          attemptCount++;
-        }
-      }
-    };
-    attempt();
-  });
-}
-function calculateDelay(attemptCount, initialDelay, backoffFactor, jitter) {
-  let delay = initialDelay * backoffFactor ** attemptCount;
-  if (jitter) {
-    const random = Math.random();
-    const jitterValue = delay * 0.3;
-    delay = delay + jitterValue * (random - 0.5) * 2;
-  }
-  return delay;
-}
-// src/sleep.ts
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function wait(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function waitUntil(condition, interval = 1000) {
-  return new Promise((resolve) => {
-    const check = setInterval(() => {
-      if (condition()) {
-        clearInterval(check);
-        resolve();
-      }
-    }, interval);
-  });
-}
-function waitWhile(condition, interval = 1000) {
-  return new Promise((resolve) => {
-    const check = setInterval(() => {
-      if (!condition()) {
-        clearInterval(check);
-        resolve();
-      }
-    }, interval);
-  });
-}
-// src/throttle.ts
-function throttle(fn, wait2 = 300) {
-  let inThrottle;
-  let lastFn;
-  let lastTime;
-  return function(...args) {
-    if (!inThrottle) {
-      fn.apply(this, args);
-      lastTime = Date.now();
-      inThrottle = true;
-    } else {
-      clearTimeout(lastFn);
-      lastFn = setTimeout(() => {
-        if (Date.now() - lastTime >= wait2) {
-          fn.apply(this, args);
-          lastTime = Date.now();
-        }
-      }, Math.max(wait2 - (Date.now() - lastTime), 0));
-    }
-  };
-}
-// src/vendors.ts
-import {
-asyncComputed,
-breakpointsAntDesign,
-breakpointsBootstrapV5,
-breakpointsMasterCss,
-breakpointsQuasar,
-breakpointsSematic,
-breakpointsTailwind,
-breakpointsVuetify,
-cloneFnJSON,
-computedAsync,
-computedInject,
-createFetch,
-createReusableTemplate,
-createTemplatePromise,
-createUnrefFn,
-customStorageEventName,
-defaultDocument,
-defaultLocation,
-defaultNavigator,
-defaultWindow,
-executeTransition,
-formatTimeAgo,
-getSSRHandler,
-mapGamepadToXbox360Controller,
-onClickOutside,
-onKeyDown,
-onKeyPressed,
-onKeyStroke,
-onKeyUp,
-onLongPress,
-onStartTyping,
-setSSRHandler,
-templateRef,
-unrefElement,
-useActiveElement,
-useAnimate,
-useAsyncQueue,
-useAsyncState,
-useBase64,
-useBattery,
-useBluetooth,
-useBreakpoints,
-useBroadcastChannel,
-useBrowserLocation,
-useCached,
-useClipboard,
-useCloned,
-useColorMode,
-useConfirmDialog,
-useCssVar,
-useCurrentElement,
-useCycleList,
-useDark,
-useDebouncedRefHistory,
-useDeviceMotion,
-useDeviceOrientation,
-useDevicePixelRatio,
-useDevicesList,
-useDisplayMedia,
-useDocumentVisibility,
-useDraggable,
-useDropZone,
-useElementBounding,
-useElementByPoint,
-useElementHover,
-useElementSize,
-useElementVisibility,
-useEventBus,
-useEventListener,
-useEventSource,
-useEyeDropper,
-useFavicon,
-useFetch,
-useFileDialog,
-useFileSystemAccess,
-useFocus,
-useFocusWithin,
-useFps,
-useFullscreen,
-useGamepad,
-useGeolocation,
-useIdle,
-useImage,
-useInfiniteScroll,
-useIntersectionObserver,
-useKeyModifier,
-useLocalStorage,
-useMagicKeys,
-useManualRefHistory,
-useMediaControls,
-useMediaQuery,
-useMemoize,
-useMemory,
-useMounted,
-useMouse,
-useMouseInElement,
-useMousePressed,
-useMutationObserver,
-useNavigatorLanguage,
-useNetwork,
-useObjectUrl,
-useOffsetPagination,
-useOnline,
-usePageLeave,
-useParallax,
-useParentElement,
-usePerformanceObserver,
-usePermission,
-usePointer,
-usePointerLock,
-usePointerSwipe,
-usePreferredColorScheme,
-usePreferredContrast,
-usePreferredDark,
-usePreferredLanguages,
-usePreferredReducedMotion,
-usePrevious,
-useRafFn,
-useRefHistory,
-useResizeObserver,
-useScreenOrientation,
-useScreenSafeArea,
-useScriptTag,
-useScroll,
-useScrollLock,
-useSessionStorage,
-useShare,
-useSorted,
-useSpeechRecognition,
-useSpeechSynthesis,
-useStepper,
-useStorage,
-useStorageAsync,
-useStyleTag,
-useSupported,
-useSwipe,
-useTemplateRefsList,
-useTextDirection,
-useTextSelection,
-useTextareaAutosize,
-useThrottledRefHistory,
-useTimeAgo,
-useTimeoutPoll,
-useTimestamp,
-useTitle,
-useTransition,
-useToggle,
-useUrlSearchParams,
-useUserMedia,
-useVModel,
-useVModels,
-useVibrate,
-useVirtualList,
-useWakeLock,
-useWebNotification,
-useWebSocket,
-useWebWorker,
-useWebWorkerFn,
-useWindowFocus,
-useWindowScroll,
-useWindowSize,
-useDateFormat,
-useNow,
-watchArray,
-watchAtMost,
-watchDebounced,
-watchDeep,
-watchIgnorable,
-watchImmediate,
-watchOnce,
-watchPausable,
-watchThrottled,
-watchTriggerable,
-watchWithFilter,
-whenever,
-syncRef,
-syncRefs,
-throttledRef,
-throttledWatch,
-toReactive,
-tryOnBeforeMount,
-tryOnBeforeUnmount,
-tryOnMounted,
-tryOnScopeDispose,
-tryOnUnmounted,
-until,
-isDefined,
-ignorableWatch,
-extendRef,
-eagerComputed,
-debouncedRef,
-debouncedWatch,
-createReactiveFn,
-createSharedComposable,
-createInjectionState,
-createGlobalState,
-createEventHook,
-controlledRef,
-controlledComputed,
-computedEager,
-computedWithControl,
-autoResetRef,
-injectLocal,
-makeDestructurable,
-pausableWatch,
-provideLocal,
-reactify,
-reactifyObject,
-reactiveComputed,
-reactiveOmit,
-reactivePick,
-refAutoReset,
-refDebounced,
-refDefault,
-refThrottled,
-refWithControl,
-resolveRef,
-resolveUnref,
-useArrayDifference,
-useArrayEvery,
-useArrayFilter,
-useArrayFind,
-useArrayFindIndex,
-useArrayIncludes,
-useArrayMap,
-useArrayReduce,
-useArraySome,
-useArrayUnique,
-useClipboardItems,
-useCounter,
-useDebounce,
-useDebounceFn,
-useInterval,
-useIntervalFn,
-useLastChanged,
-useThrottle,
-useThrottleFn,
-useTimeout,
-useTimeoutFn,
-useToNumber,
-useToString
-} from "@vueuse/core";
-import {
-Head,
-HeadVuePlugin,
-createHead,
-renderHeadToString
-} from "@vueuse/head";
-
-// /home/runner/work/stacks/stacks/node_modules/pretty-bytes/index.js
-var BYTE_UNITS = [
-  "B",
-  "kB",
-  "MB",
-  "GB",
-  "TB",
-  "PB",
-  "EB",
-  "ZB",
-  "YB"
-];
-var BIBYTE_UNITS = [
-  "B",
-  "KiB",
-  "MiB",
-  "GiB",
-  "TiB",
-  "PiB",
-  "EiB",
-  "ZiB",
-  "YiB"
-];
-var BIT_UNITS = [
-  "b",
-  "kbit",
-  "Mbit",
-  "Gbit",
-  "Tbit",
-  "Pbit",
-  "Ebit",
-  "Zbit",
-  "Ybit"
-];
-var BIBIT_UNITS = [
-  "b",
-  "kibit",
-  "Mibit",
-  "Gibit",
-  "Tibit",
-  "Pibit",
-  "Eibit",
-  "Zibit",
-  "Yibit"
-];
-var toLocaleString = (number, locale, options) => {
-  let result = number;
-  if (typeof locale === "string" || Array.isArray(locale)) {
-    result = number.toLocaleString(locale, options);
-  } else if (locale === true || options !== undefined) {
-    result = number.toLocaleString(undefined, options);
-  }
-  return result;
-};
-function prettyBytes(number, options) {
-  if (!Number.isFinite(number)) {
-    throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`);
-  }
-  options = {
-    bits: false,
-    binary: false,
-    space: true,
-    ...options
-  };
-  const UNITS = options.bits ? options.binary ? BIBIT_UNITS : BIT_UNITS : options.binary ? BIBYTE_UNITS : BYTE_UNITS;
-  const separator = options.space ? " " : "";
-  if (options.signed && number === 0) {
-    return ` 0${separator}${UNITS[0]}`;
-  }
-  const isNegative = number < 0;
-  const prefix = isNegative ? "-" : options.signed ? "+" : "";
-  if (isNegative) {
-    number = -number;
-  }
-  let localeOptions;
-  if (options.minimumFractionDigits !== undefined) {
-    localeOptions = { minimumFractionDigits: options.minimumFractionDigits };
-  }
-  if (options.maximumFractionDigits !== undefined) {
-    localeOptions = { maximumFractionDigits: options.maximumFractionDigits, ...localeOptions };
-  }
-  if (number < 1) {
-    const numberString2 = toLocaleString(number, options.locale, localeOptions);
-    return prefix + numberString2 + separator + UNITS[0];
-  }
-  const exponent = Math.min(Math.floor(options.binary ? Math.log(number) / Math.log(1024) : Math.log10(number) / 3), UNITS.length - 1);
-  number /= (options.binary ? 1024 : 1000) ** exponent;
-  if (!localeOptions) {
-    number = number.toPrecision(3);
-  }
-  const numberString = toLocaleString(Number(number), options.locale, localeOptions);
-  const unit = UNITS[exponent];
-  return prefix + numberString + separator + unit;
-}
-// package.json
-var version = "0.58.72";
-export {
-  wordChar,
-  wordBoundary,
-  word,
-  withIndices,
-  whitespace,
-  whenever,
-  websiteSourceHash,
-  watchWithFilter,
-  watchTriggerable,
-  watchThrottled,
-  watchPausable,
-  watchOnce,
-  watchImmediate,
-  watchIgnorable,
-  watchDeep,
-  watchDebounced,
-  watchAtMost,
-  watchArray,
-  waitWhile,
-  waitUntil,
-  wait,
-  version,
-  useWindowSize,
-  useWindowScroll,
-  useWindowFocus,
-  useWebWorkerFn,
-  useWebWorker,
-  useWebSocket,
-  useWebNotification,
-  useWakeLock,
-  useVirtualList,
-  useVibrate,
-  useVModels,
-  useVModel,
-  useUserMedia,
-  useUrlSearchParams,
-  useTrunc,
-  useTransition,
-  useToggle,
-  useToString,
-  useToNumber,
-  useTitle,
-  useTimestamp,
-  useTimeoutPoll,
-  useTimeoutFn,
-  useTimeout,
-  useTimeAgo,
-  useThrottledRefHistory,
-  useThrottleFn,
-  useThrottle,
-  useTextareaAutosize,
-  useTextSelection,
-  useTextDirection,
-  useTemplateRefsList,
-  useSwipe,
-  useSupported,
-  useSum,
-  useStyleTag,
-  useStorageAsync,
-  useStorage,
-  useStepper,
-  useSpeechSynthesis,
-  useSpeechRecognition,
-  useSorted,
-  useShare,
-  useSessionStorage,
-  useScrollLock,
-  useScroll,
-  useScriptTag,
-  useScreenSafeArea,
-  useScreenOrientation,
-  useRound,
-  useResizeObserver,
-  useRefHistory,
-  useRafFn,
-  useProjection,
-  usePrevious,
-  usePreferredReducedMotion,
-  usePreferredLanguages,
-  usePreferredDark,
-  usePreferredContrast,
-  usePreferredColorScheme,
-  usePrecision,
-  usePointerSwipe,
-  usePointerLock,
-  usePointer,
-  usePermission,
-  usePerformanceObserver,
-  useParentElement,
-  useParallax,
-  usePageLeave,
-  useOnline,
-  useOffsetPagination,
-  useObjectUrl,
-  useNow,
-  useNetwork,
-  useNavigatorLanguage,
-  useMutationObserver,
-  useMousePressed,
-  useMouseInElement,
-  useMouse,
-  useMounted,
-  useMin,
-  useMemory,
-  useMemoize,
-  useMediaQuery,
-  useMediaControls,
-  useMax,
-  useMath,
-  useManualRefHistory,
-  useMagicKeys,
-  useLocalStorage,
-  useLastChanged,
-  useKeyModifier,
-  useIntervalFn,
-  useInterval,
-  useIntersectionObserver,
-  useInfiniteScroll,
-  useImage,
-  useIdle,
-  useGeolocation,
-  useGamepad,
-  useFullscreen,
-  useFps,
-  useFocusWithin,
-  useFocus,
-  useFloor,
-  useFileSystemAccess,
-  useFileDialog,
-  useFetch,
-  useFavicon,
-  useEyeDropper,
-  useEventSource,
-  useEventListener,
-  useEventBus,
-  useElementVisibility,
-  useElementSize,
-  useElementHover,
-  useElementByPoint,
-  useElementBounding,
-  useDropZone,
-  useDraggable,
-  useDocumentVisibility,
-  useDisplayMedia,
-  useDevicesList,
-  useDevicePixelRatio,
-  useDeviceOrientation,
-  useDeviceMotion,
-  useDebouncedRefHistory,
-  useDebounceFn,
-  useDebounce,
-  useDateFormat,
-  useDark,
-  useCycleList,
-  useCurrentElement,
-  useCssVar,
-  useCounter,
-  useConfirmDialog,
-  useColorMode,
-  useCloned,
-  useClipboardItems,
-  useClipboard,
-  useClamp,
-  useCeil,
-  useCached,
-  useBrowserLocation,
-  useBroadcastChannel,
-  useBreakpoints,
-  useBluetooth,
-  useBattery,
-  useBase64,
-  useAverage,
-  useAsyncState,
-  useAsyncQueue,
-  useArrayUnique,
-  useArraySome,
-  useArrayReduce,
-  useArrayMap,
-  useArrayIncludes,
-  useArrayFindIndex,
-  useArrayFind,
-  useArrayFilter,
-  useArrayEvery,
-  useArrayDifference,
-  useAnimate,
-  useActiveElement,
-  useAbs,
-  until,
-  unrefElement,
-  unicode,
-  tryOnUnmounted,
-  tryOnScopeDispose,
-  tryOnMounted,
-  tryOnBeforeUnmount,
-  tryOnBeforeMount,
-  trimScale,
-  toUnits,
-  toString,
-  toSnapshot,
-  toReactive,
-  toDecimal,
-  throttledWatch,
-  throttledRef,
-  throttle,
-  templateRef,
-  tap,
-  tab,
-  syncRefs,
-  syncRef,
-  subtract,
-  sticky,
-  sleep,
-  setSSRHandler,
-  setEnvValue,
-  runNpmScript,
-  rimraf,
-  retry,
-  resolveUnref,
-  resolveRef,
-  renderHeadToString,
-  refWithControl,
-  refThrottled,
-  refDefault,
-  refDebounced,
-  refAutoReset,
-  prettyBytes as readableSize,
-  reactivePick,
-  reactiveOmit,
-  reactiveComputed,
-  reactifyObject,
-  reactify,
-  rand,
-  provideLocal,
-  pausableWatch,
-  parseYaml,
-  packageManager,
-  p3 as p,
-  originRequestFunctionHash,
-  or,
-  oneOrMore,
-  onStartTyping,
-  onLongPress,
-  onKeyUp,
-  onKeyStroke,
-  onKeyPressed,
-  onKeyDown,
-  onClickOutside,
-  notUndefined,
-  notNullish,
-  not,
-  normalizeScale,
-  noNull,
-  multiply,
-  multiline,
-  dinero2 as money,
-  minimum,
-  maybe,
-  maximum,
-  mapGamepadToXbox360Controller,
-  makeDestructurable,
-  loop,
-  logicOr,
-  logicNot,
-  load as loadYaml,
-  linefeed,
-  letter,
-  lessThanOrEqual,
-  lessThan,
-  isZero,
-  isTruthy,
-  isOptionalString,
-  isManifest,
-  isIpv6,
-  isGitClean,
-  isDefined,
-  isDeepEqual,
-  isAppKeySet,
-  installIfVersionMismatch,
-  injectLocal,
-  initProject,
-  ignorableWatch,
-  haveSameCurrency,
-  haveSameAmount,
-  hasSubUnits,
-  hasScript,
-  greaterThanOrEqual,
-  greaterThan,
-  global,
-  getSSRHandler,
-  getExportsSize,
-  frameworkVersion,
-  formatTimeAgo,
-  extendRef,
-  executeTransition,
-  exactly,
-  equal,
-  ensureProjectIsInitialized,
-  eagerComputed,
-  dump as dumpYaml,
-  dotAll,
-  dinero,
-  digit,
-  determineResetPreset,
-  determineDebugLevel,
-  delay,
-  defineUi,
-  defineStorage,
-  defineSms,
-  defineServices,
-  defineSearchEngine,
-  defineQueue,
-  definePayment,
-  defineNotification,
-  defineLibrary,
-  defineJob,
-  defineHashing,
-  defineGit,
-  defineEmailConfig,
-  defineEmail,
-  defineDns,
-  defineDependencies,
-  defineDatabase,
-  defineCronJob,
-  defineCli,
-  defineChat,
-  defineCdn,
-  defineCache,
-  defineApp,
-  defaultWindow,
-  defaultNavigator,
-  defaultLocation,
-  defaultDocument,
-  debouncedWatch,
-  debouncedRef,
-  debounce,
-  customStorageEventName,
-  dinero3 as currency,
-  createUnrefFn,
-  createTemplatePromise,
-  createSingletonPromise,
-  createSharedComposable,
-  createReusableTemplate,
-  createRegExp,
-  createReactiveFn,
-  createPromiseLock,
-  createProjection,
-  createInjectionState,
-  createHead,
-  createGlobalState,
-  createGenericProjection,
-  createFetch,
-  createEventHook,
-  createControlledPromise,
-  convert,
-  controlledRef,
-  controlledComputed,
-  computedWithControl,
-  computedInject,
-  computedEager,
-  computedAsync,
-  compare,
-  cloneFnJSON,
-  cleanProject,
-  clamp,
-  charNotIn,
-  charIn,
-  char,
-  caseInsensitive,
-  carriageReturn,
-  calculateDelay,
-  breakpointsVuetify,
-  breakpointsTailwind,
-  breakpointsSematic,
-  breakpointsQuasar,
-  breakpointsMasterCss,
-  breakpointsBootstrapV5,
-  breakpointsAntDesign,
-  batchInvoke,
-  autoResetRef,
-  asyncComputed,
-  anyOf,
-  and,
-  allocate,
-  add,
-  USD,
-  Macroable,
-  HeadVuePlugin,
-  Head
-};