stacks 0.56.24 → 0.58.18

package/core/src/utils/dist/index.js

@@ -0,0 +1,1276 @@
+// @bun
+// src/base.ts
+import {toString} from "@stacksjs/strings";
+function assert(condition, message) {
+  if (!condition)
+    throw new Error(message);
+}
+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.cloudPath("cdk.out/"),
+    p.cloudPath("cdk.context.json"),
+    p.cloudPath("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";
+var originRequestFunctionHash = hashPaths(p2.cloudPath("src/edge"));
+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, runCommand} from "@stacksjs/cli";
+import {err, 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")
+    log.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));
+  log.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;
+}
+// /Users/chrisbreuer/Code/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";
+
+// /Users/chrisbreuer/Code/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/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";
+
+// /Users/chrisbreuer/Code/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.4";
+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,
+  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,
+  breakpointsVuetify,
+  breakpointsTailwind,
+  breakpointsSematic,
+  breakpointsQuasar,
+  breakpointsMasterCss,
+  breakpointsBootstrapV5,
+  breakpointsAntDesign,
+  batchInvoke,
+  autoResetRef,
+  asyncComputed,
+  assert,
+  anyOf,
+  and,
+  allocate,
+  add,
+  USD,
+  Macroable,
+  HeadVuePlugin,
+  Head
+};