@stacksjs/types 0.58.27 → 0.58.43

package/dist/index.js

@@ -16,7 +16,7 @@ var __toESM = (mod, isNodeMode, target) => {
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 
-// /home/runner/work/stacks/stacks/node_modules/slugify/slugify.js
+// /Users/chrisbreuer/Code/stacks/node_modules/slugify/slugify.js
 var require_slugify = __commonJS((exports, module) => {
   (function(name, root, factory) {
     if (typeof exports === "object") {
@@ -67,7 +67,7 @@ var require_slugify = __commonJS((exports, module) => {
   });
 });
 
-// /home/runner/work/stacks/stacks/node_modules/pluralize/pluralize.js
+// /Users/chrisbreuer/Code/stacks/node_modules/pluralize/pluralize.js
 var require_pluralize = __commonJS((exports, module) => {
   (function(root, pluralize) {
     if (typeof require === "function" && typeof exports === "object" && typeof module === "object") {
@@ -430,9 +430,361 @@ var ExitCode;
   ExitCode2[ExitCode2["FatalError"] = 1] = "FatalError";
   ExitCode2[ExitCode2["InvalidArgument"] = 9] = "InvalidArgument";
 })(ExitCode || (ExitCode = {}));
-// /home/runner/work/stacks/stacks/storage/framework/core/strings/src/utils.ts
+// /Users/chrisbreuer/Code/stacks/storage/framework/core/strings/dist/index.js
 var import_slugify = __toESM(require_slugify(), 1);
-// /home/runner/work/stacks/stacks/node_modules/title-case/dist/index.js
+var slash = function(str) {
+  return str.replace(/\\/g, "/");
+};
+var ensurePrefix = function(prefix, str) {
+  if (!str.startsWith(prefix))
+    return prefix + str;
+  return str;
+};
+var ensureSuffix = function(suffix, str) {
+  return str.endsWith(suffix) ? str : str + suffix;
+};
+var template = function(str, ...args) {
+  return str.replace(/{(\d+)}/g, (match, key) => {
+    const index = Number(key);
+    return Number.isNaN(index) ? match : args[index];
+  });
+};
+var truncate = function(str, length, end = "...") {
+  if (str.length <= length)
+    return str;
+  return str.slice(0, length - end.length) + end;
+};
+var random = function(size = 16, dict = urlAlphabet) {
+  let id = "";
+  let i = size;
+  const len = dict.length;
+  while (i--)
+    id += dict[Math.random() * len | 0];
+  return id;
+};
+var slug = function(str, options) {
+  if (options)
+    return import_slugify.default(str, options);
+  return import_slugify.default(str, {
+    lower: true,
+    strict: true
+  });
+};
+
+// /Users/chrisbreuer/Code/stacks/node_modules/detect-indent/index.js
+var makeIndentsMap = function(string, ignoreSingleSpaces) {
+  const indents = new Map;
+  let previousSize = 0;
+  let previousIndentType;
+  let key;
+  for (const line of string.split(/\n/g)) {
+    if (!line) {
+      continue;
+    }
+    let indent;
+    let indentType;
+    let use;
+    let weight;
+    let entry;
+    const matches = line.match(INDENT_REGEX);
+    if (matches === null) {
+      previousSize = 0;
+      previousIndentType = "";
+    } else {
+      indent = matches[0].length;
+      indentType = matches[1] ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
+      if (ignoreSingleSpaces && indentType === INDENT_TYPE_SPACE && indent === 1) {
+        continue;
+      }
+      if (indentType !== previousIndentType) {
+        previousSize = 0;
+      }
+      previousIndentType = indentType;
+      use = 1;
+      weight = 0;
+      const indentDifference = indent - previousSize;
+      previousSize = indent;
+      if (indentDifference === 0) {
+        use = 0;
+        weight = 1;
+      } else {
+        const absoluteIndentDifference = indentDifference > 0 ? indentDifference : -indentDifference;
+        key = encodeIndentsKey(indentType, absoluteIndentDifference);
+      }
+      entry = indents.get(key);
+      entry = entry === undefined ? [1, 0] : [entry[0] + use, entry[1] + weight];
+      indents.set(key, entry);
+    }
+  }
+  return indents;
+};
+var encodeIndentsKey = function(indentType, indentAmount) {
+  const typeCharacter = indentType === INDENT_TYPE_SPACE ? "s" : "t";
+  return typeCharacter + String(indentAmount);
+};
+var decodeIndentsKey = function(indentsKey) {
+  const keyHasTypeSpace = indentsKey[0] === "s";
+  const type = keyHasTypeSpace ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
+  const amount = Number(indentsKey.slice(1));
+  return { type, amount };
+};
+var getMostUsedKey = function(indents) {
+  let result;
+  let maxUsed = 0;
+  let maxWeight = 0;
+  for (const [key, [usedCount, weight]] of indents) {
+    if (usedCount > maxUsed || usedCount === maxUsed && weight > maxWeight) {
+      maxUsed = usedCount;
+      maxWeight = weight;
+      result = key;
+    }
+  }
+  return result;
+};
+var makeIndentString = function(type, amount) {
+  const indentCharacter = type === INDENT_TYPE_SPACE ? " " : "\t";
+  return indentCharacter.repeat(amount);
+};
+var INDENT_REGEX = /^(?:( )+|\t+)/;
+var INDENT_TYPE_SPACE = "space";
+var INDENT_TYPE_TAB = "tab";
+function detectIndent(string) {
+  if (typeof string !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  let indents = makeIndentsMap(string, true);
+  if (indents.size === 0) {
+    indents = makeIndentsMap(string, false);
+  }
+  const keyOfMostUsedIndent = getMostUsedKey(indents);
+  let type;
+  let amount = 0;
+  let indent = "";
+  if (keyOfMostUsedIndent !== undefined) {
+    ({ type, amount } = decodeIndentsKey(keyOfMostUsedIndent));
+    indent = makeIndentString(type, amount);
+  }
+  return {
+    amount,
+    type,
+    indent
+  };
+}
+
+// /Users/chrisbreuer/Code/stacks/node_modules/detect-newline/index.js
+function detectNewline(string) {
+  if (typeof string !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  const newlines = string.match(/(?:\r?\n)/g) || [];
+  if (newlines.length === 0) {
+    return;
+  }
+  const crlf = newlines.filter((newline) => newline === "\r\n").length;
+  const lf = newlines.length - crlf;
+  return crlf > lf ? "\r\n" : "\n";
+}
+
+// /Users/chrisbreuer/Code/stacks/storage/framework/core/strings/dist/index.js
+var capitalize = function(str) {
+  return str[0] ? str[0].toUpperCase() + str.slice(1).toLowerCase() : "";
+};
+
+// /Users/chrisbreuer/Code/stacks/node_modules/change-case/dist/index.js
+function split(value) {
+  let result = value.trim();
+  result = result.replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+  result = result.replace(DEFAULT_STRIP_REGEXP, "\0");
+  let start = 0;
+  let end = result.length;
+  while (result.charAt(start) === "\0")
+    start++;
+  if (start === end)
+    return [];
+  while (result.charAt(end - 1) === "\0")
+    end--;
+  return result.slice(start, end).split(/\0/g);
+}
+function splitSeparateNumbers(value) {
+  const words = split(value);
+  for (let i = 0;i < words.length; i++) {
+    const word = words[i];
+    const match = SPLIT_SEPARATE_NUMBER_RE.exec(word);
+    if (match) {
+      const offset = match.index + (match[1] ?? match[2]).length;
+      words.splice(i, 1, word.slice(0, offset), word.slice(offset));
+    }
+  }
+  return words;
+}
+function noCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+  return prefix + words.map(lowerFactory(options?.locale)).join(options?.delimiter ?? " ") + suffix;
+}
+function camelCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+  const lower = lowerFactory(options?.locale);
+  const upper = upperFactory(options?.locale);
+  const transform = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
+  return prefix + words.map((word, index) => {
+    if (index === 0)
+      return lower(word);
+    return transform(word, index);
+  }).join(options?.delimiter ?? "") + suffix;
+}
+function pascalCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+  const lower = lowerFactory(options?.locale);
+  const upper = upperFactory(options?.locale);
+  const transform = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
+  return prefix + words.map(transform).join(options?.delimiter ?? "") + suffix;
+}
+function capitalCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+  const lower = lowerFactory(options?.locale);
+  const upper = upperFactory(options?.locale);
+  return prefix + words.map(capitalCaseTransformFactory(lower, upper)).join(options?.delimiter ?? " ") + suffix;
+}
+function constantCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+  return prefix + words.map(upperFactory(options?.locale)).join(options?.delimiter ?? "_") + suffix;
+}
+function dotCase(input, options) {
+  return noCase(input, { delimiter: ".", ...options });
+}
+function kebabCase(input, options) {
+  return noCase(input, { delimiter: "-", ...options });
+}
+function pathCase(input, options) {
+  return noCase(input, { delimiter: "/", ...options });
+}
+function sentenceCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+  const lower = lowerFactory(options?.locale);
+  const upper = upperFactory(options?.locale);
+  const transform = capitalCaseTransformFactory(lower, upper);
+  return prefix + words.map((word, index) => {
+    if (index === 0)
+      return transform(word);
+    return lower(word);
+  }).join(options?.delimiter ?? " ") + suffix;
+}
+function snakeCase(input, options) {
+  return noCase(input, { delimiter: "_", ...options });
+}
+var lowerFactory = function(locale) {
+  return locale === false ? (input) => input.toLowerCase() : (input) => input.toLocaleLowerCase(locale);
+};
+var upperFactory = function(locale) {
+  return locale === false ? (input) => input.toUpperCase() : (input) => input.toLocaleUpperCase(locale);
+};
+var capitalCaseTransformFactory = function(lower, upper) {
+  return (word) => `${upper(word[0])}${lower(word.slice(1))}`;
+};
+var pascalCaseTransformFactory = function(lower, upper) {
+  return (word, index) => {
+    const char0 = word[0];
+    const initial = index > 0 && char0 >= "0" && char0 <= "9" ? "_" + char0 : upper(char0);
+    return initial + lower(word.slice(1));
+  };
+};
+var splitPrefixSuffix = function(input, options = {}) {
+  const splitFn = options.split ?? (options.separateNumbers ? splitSeparateNumbers : split);
+  const prefixCharacters = options.prefixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+  const suffixCharacters = options.suffixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+  let prefixIndex = 0;
+  let suffixIndex = input.length;
+  while (prefixIndex < input.length) {
+    const char = input.charAt(prefixIndex);
+    if (!prefixCharacters.includes(char))
+      break;
+    prefixIndex++;
+  }
+  while (suffixIndex > prefixIndex) {
+    const index = suffixIndex - 1;
+    const char = input.charAt(index);
+    if (!suffixCharacters.includes(char))
+      break;
+    suffixIndex = index;
+  }
+  return [
+    input.slice(0, prefixIndex),
+    splitFn(input.slice(prefixIndex, suffixIndex)),
+    input.slice(suffixIndex)
+  ];
+};
+var SPLIT_LOWER_UPPER_RE = /([\p{Ll}\d])(\p{Lu})/gu;
+var SPLIT_UPPER_UPPER_RE = /(\p{Lu})([\p{Lu}][\p{Ll}])/gu;
+var SPLIT_SEPARATE_NUMBER_RE = /(\d)\p{Ll}|(\p{L})\d/u;
+var DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
+var SPLIT_REPLACE_VALUE = "$1\0$2";
+var DEFAULT_PREFIX_SUFFIX_CHARACTERS = "";
+
+// /Users/chrisbreuer/Code/stacks/node_modules/title-case/dist/index.js
+function titleCase(input, options = {}) {
+  const { locale = undefined, sentenceCase: sentenceCase2 = false, sentenceTerminators = SENTENCE_TERMINATORS, titleTerminators = TITLE_TERMINATORS, smallWords = SMALL_WORDS, wordSeparators = WORD_SEPARATORS } = typeof options === "string" || Array.isArray(options) ? { locale: options } : options;
+  const terminators = sentenceCase2 ? sentenceTerminators : titleTerminators;
+  let result = "";
+  let isNewSentence = true;
+  for (const m of input.matchAll(TOKENS)) {
+    const { 1: token, 2: whiteSpace, index = 0 } = m;
+    if (whiteSpace) {
+      result += whiteSpace;
+      continue;
+    }
+    if (IS_SPECIAL_CASE.test(token)) {
+      const acronym = token.match(IS_ACRONYM);
+      if (acronym) {
+        const [_, prefix = "", suffix = ""] = acronym;
+        result += sentenceCase2 && !isNewSentence ? token : upperAt(token, prefix.length, locale);
+        isNewSentence = terminators.has(suffix.charAt(0));
+        continue;
+      }
+      result += token;
+      isNewSentence = terminators.has(token.charAt(token.length - 1));
+    } else {
+      const matches = Array.from(token.matchAll(ALPHANUMERIC_PATTERN));
+      let value = token;
+      let isSentenceEnd = false;
+      for (let i = 0;i < matches.length; i++) {
+        const { 0: word, index: wordIndex = 0 } = matches[i];
+        const nextChar = token.charAt(wordIndex + word.length);
+        isSentenceEnd = terminators.has(nextChar);
+        if (isNewSentence) {
+          isNewSentence = false;
+        } else if (sentenceCase2 || IS_MANUAL_CASE.test(word)) {
+          continue;
+        } else if (matches.length === 1) {
+          if (smallWords.has(word)) {
+            const isFinalToken = index + token.length === input.length;
+            if (!isFinalToken && !isSentenceEnd) {
+              continue;
+            }
+          }
+        } else if (i > 0) {
+          if (!wordSeparators.has(token.charAt(wordIndex - 1))) {
+            continue;
+          }
+          if (smallWords.has(word) && wordSeparators.has(nextChar)) {
+            continue;
+          }
+        }
+        value = upperAt(value, wordIndex, locale);
+      }
+      result += value;
+      isNewSentence = isSentenceEnd || terminators.has(token.charAt(token.length - 1));
+    }
+  }
+  return result;
+}
+var upperAt = function(input, index, locale) {
+  return input.slice(0, index) + input.charAt(index).toLocaleUpperCase(locale) + input.slice(index + 1);
+};
+var TOKENS = /(\S+)|(.)/g;
+var IS_SPECIAL_CASE = /[\.#]\p{Alphabetic}/u;
+var IS_MANUAL_CASE = /\p{Ll}(?=[\p{Lu}])/u;
+var ALPHANUMERIC_PATTERN = /\p{Alphabetic}+/gu;
+var IS_ACRONYM = /^(\P{Alphabetic})*(?:\p{Alphabetic}\.){2,}(\P{Alphabetic})*$/u;
 var WORD_SEPARATORS = new Set(["\u2014", "\u2013", "-", "\u2015", "/"]);
 var SENTENCE_TERMINATORS = new Set([".", "!", "?"]);
 var TITLE_TERMINATORS = new Set([
@@ -480,12 +832,298 @@ var SMALL_WORDS = new Set([
   "without",
   "yet"
 ]);
-// /home/runner/work/stacks/stacks/storage/framework/core/strings/src/pluralize.ts
+
+// /Users/chrisbreuer/Code/stacks/storage/framework/core/strings/dist/index.js
 var pluralize = __toESM(require_pluralize(), 1);
-// /home/runner/work/stacks/stacks/storage/framework/core/strings/src/helpers.ts
-function toString(v) {
+var toString = function(v) {
   return Object.prototype.toString.call(v);
-}
+};
+var __defProp2 = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp2(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var exports_string = {};
+__export(exports_string, {
+  truncate: () => {
+    {
+      return truncate;
+    }
+  },
+  toString: () => {
+    {
+      return toString;
+    }
+  },
+  titleCase: () => {
+    {
+      return titleCase;
+    }
+  },
+  template: () => {
+    {
+      return template;
+    }
+  },
+  str: () => {
+    {
+      return str;
+    }
+  },
+  split: () => {
+    {
+      return split;
+    }
+  },
+  snakeCase: () => {
+    {
+      return snakeCase;
+    }
+  },
+  slug: () => {
+    {
+      return slug;
+    }
+  },
+  slash: () => {
+    {
+      return slash;
+    }
+  },
+  singular: () => {
+    {
+      return singular2;
+    }
+  },
+  sentenceCase: () => {
+    {
+      return sentenceCase;
+    }
+  },
+  random: () => {
+    {
+      return random;
+    }
+  },
+  plural: () => {
+    {
+      return plural2;
+    }
+  },
+  pathCase: () => {
+    {
+      return pathCase;
+    }
+  },
+  pascalCase: () => {
+    {
+      return pascalCase;
+    }
+  },
+  paramCase: () => {
+    {
+      return kebabCase;
+    }
+  },
+  noCase: () => {
+    {
+      return noCase;
+    }
+  },
+  kebabCase: () => {
+    {
+      return kebabCase;
+    }
+  },
+  isSingular: () => {
+    {
+      return isSingular2;
+    }
+  },
+  isPlural: () => {
+    {
+      return isPlural2;
+    }
+  },
+  ensureSuffix: () => {
+    {
+      return ensureSuffix;
+    }
+  },
+  ensurePrefix: () => {
+    {
+      return ensurePrefix;
+    }
+  },
+  dotCase: () => {
+    {
+      return dotCase;
+    }
+  },
+  detectNewline: () => {
+    {
+      return detectNewline;
+    }
+  },
+  detectIndent: () => {
+    {
+      return detectIndent;
+    }
+  },
+  constantCase: () => {
+    {
+      return constantCase;
+    }
+  },
+  capitalize: () => {
+    {
+      return capitalize;
+    }
+  },
+  capitalCase: () => {
+    {
+      return capitalCase;
+    }
+  },
+  camelCase: () => {
+    {
+      return camelCase;
+    }
+  },
+  addUncountableRule: () => {
+    {
+      return addUncountableRule2;
+    }
+  },
+  addSingularRule: () => {
+    {
+      return addSingularRule2;
+    }
+  },
+  addPluralRule: () => {
+    {
+      return addPluralRule2;
+    }
+  },
+  addIrregularRule: () => {
+    {
+      return addIrregularRule2;
+    }
+  },
+  Str: () => {
+    {
+      return Str;
+    }
+  }
+});
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+var plural2 = (...args) => pluralize.plural(...args);
+var singular2 = (...args) => pluralize.singular(...args);
+var isPlural2 = (...args) => pluralize.isPlural(...args);
+var isSingular2 = (...args) => pluralize.isSingular(...args);
+var addPluralRule2 = (...args) => pluralize.addPluralRule(...args);
+var addSingularRule2 = (...args) => pluralize.addSingularRule(...args);
+var addIrregularRule2 = (...args) => pluralize.addIrregularRule(...args);
+var addUncountableRule2 = (...args) => pluralize.addUncountableRule(...args);
+var Str = {
+  slash(str) {
+    return slash(str);
+  },
+  ensurePrefix(prefix, str) {
+    return ensurePrefix(prefix, str);
+  },
+  ensureSuffix(suffix, str) {
+    return ensureSuffix(suffix, str);
+  },
+  template(str, ...args) {
+    return template(str, ...args);
+  },
+  truncate(str, length, end = "...") {
+    return truncate(str, length, end);
+  },
+  random(length = 16) {
+    return random(length);
+  },
+  capitalize(str) {
+    return capitalize(str);
+  },
+  slug(str) {
+    return slug(str);
+  },
+  detectIndent(str) {
+    return detectIndent(str);
+  },
+  detectNewline(str) {
+    return detectNewline(str);
+  },
+  camelCase(str) {
+    return camelCase(str);
+  },
+  capitalCase(str) {
+    return capitalCase(str);
+  },
+  constantCase(str) {
+    return constantCase(str);
+  },
+  dotCase(str) {
+    return dotCase(str);
+  },
+  noCase(str) {
+    return noCase(str);
+  },
+  paramCase(str) {
+    return kebabCase(str);
+  },
+  pascalCase(str) {
+    return pascalCase(str);
+  },
+  pathCase(str) {
+    return pathCase(str);
+  },
+  sentenceCase(str) {
+    return sentenceCase(str);
+  },
+  snakeCase(str) {
+    return snakeCase(str);
+  },
+  titleCase(str) {
+    return titleCase(str);
+  },
+  kebabCase(str) {
+    return kebabCase(str);
+  },
+  plural(str) {
+    return plural2(str);
+  },
+  singular(str) {
+    return singular2(str);
+  },
+  isPlural(str) {
+    return isPlural2(str);
+  },
+  isSingular(str) {
+    return isSingular2(str);
+  },
+  addPluralRule(rule, repl) {
+    return addPluralRule2(rule, repl);
+  },
+  addSingularRule(rule, repl) {
+    return addSingularRule2(rule, repl);
+  },
+  addIrregularRule(single, plural3) {
+    return addIrregularRule2(single, plural3);
+  },
+  addUncountableRule(word) {
+    return addUncountableRule2(word);
+  }
+};
+var str = Str;
+
 // src/helpers.ts
 function getTypeName(v) {
   if (v === null)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/types",
   "type": "module",
-  "version": "0.58.27",
+  "version": "0.58.43",
   "description": "The Stacks framework types.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -55,32 +55,32 @@
     "@stacksjs/validation": "workspace:*",
     "@types/aws4": "^1.11.6",
     "@types/bcryptjs": "^2.4.6",
-    "@types/crypto-js": "^4.2.1",
+    "@types/bun": "^1.0.4",
+    "@types/crypto-js": "^4.2.2",
     "@types/eslint": "^8.56.2",
     "@types/fs-extra": "^11.0.4",
     "@types/markdown-it-link-attributes": "^3.0.4",
     "@types/minimatch": "^5.1.2",
-    "@types/node": "^20.11.0",
+    "@types/node": "^20.11.10",
     "@types/nprogress": "^0.2.3",
-    "@vinejs/vine": "^1.7.0",
-    "bun-types": "canary",
+    "@vinejs/vine": "^1.7.1",
     "cac": "^6.7.14",
     "markdown-it": "^14.0.0",
-    "meilisearch": "^0.36.0",
+    "meilisearch": "^0.37.0",
     "neverthrow": "^6.1.0",
     "ora": "^8.0.1",
-    "unocss": "^0.58.3",
-    "unplugin-auto-import": "^0.17.3",
+    "unocss": "^0.58.4",
+    "unplugin-auto-import": "^0.17.5",
     "unplugin-vue-components": "^0.26.0",
-    "vite": "^5.0.11",
-    "vite-plugin-inspect": "^0.8.1",
-    "vite-plugin-pwa": "^0.17.4",
+    "vite": "^5.0.12",
+    "vite-plugin-inspect": "^0.8.3",
+    "vite-plugin-pwa": "^0.17.5",
     "vite-ssg": "^0.23.6",
-    "vitepress": "1.0.0-rc.36",
-    "vue": "^3.4.13"
+    "vitepress": "1.0.0-rc.40",
+    "vue": "^3.4.15"
   },
   "devDependencies": {
-    "aws-cdk-lib": "^2.121.1",
+    "aws-cdk-lib": "^2.124.0",
     "typescript": "^5.3.3"
   }
 }