feat: init

node_modules/@nuxt/vite-builder/dist/_chunks/libs/@vue/shared.d.mts

@@ -0,0 +1,119 @@
+//#region ../../node_modules/.pnpm/@vue+shared@3.5.27/node_modules/@vue/shared/dist/shared.d.ts
+/**
+ * Patch flags are optimization hints generated by the compiler.
+ * when a block with dynamicChildren is encountered during diff, the algorithm
+ * enters "optimized mode". In this mode, we know that the vdom is produced by
+ * a render function generated by the compiler, so the algorithm only needs to
+ * handle updates explicitly marked by these patch flags.
+ *
+ * Patch flags can be combined using the | bitwise operator and can be checked
+ * using the & operator, e.g.
+ *
+ * ```js
+ * const flag = TEXT | CLASS
+ * if (flag & TEXT) { ... }
+ * ```
+ *
+ * Check the `patchElement` function in '../../runtime-core/src/renderer.ts' to see how the
+ * flags are handled during diff.
+ */
+declare enum PatchFlags {
+  /**
+   * Indicates an element with dynamic textContent (children fast path)
+   */
+  TEXT = 1,
+  /**
+   * Indicates an element with dynamic class binding.
+   */
+  CLASS = 2,
+  /**
+   * Indicates an element with dynamic style
+   * The compiler pre-compiles static string styles into static objects
+   * + detects and hoists inline static objects
+   * e.g. `style="color: red"` and `:style="{ color: 'red' }"` both get hoisted
+   * as:
+   * ```js
+   * const style = { color: 'red' }
+   * render() { return e('div', { style }) }
+   * ```
+   */
+  STYLE = 4,
+  /**
+   * Indicates an element that has non-class/style dynamic props.
+   * Can also be on a component that has any dynamic props (includes
+   * class/style). when this flag is present, the vnode also has a dynamicProps
+   * array that contains the keys of the props that may change so the runtime
+   * can diff them faster (without having to worry about removed props)
+   */
+  PROPS = 8,
+  /**
+   * Indicates an element with props with dynamic keys. When keys change, a full
+   * diff is always needed to remove the old key. This flag is mutually
+   * exclusive with CLASS, STYLE and PROPS.
+   */
+  FULL_PROPS = 16,
+  /**
+   * Indicates an element that requires props hydration
+   * (but not necessarily patching)
+   * e.g. event listeners & v-bind with prop modifier
+   */
+  NEED_HYDRATION = 32,
+  /**
+   * Indicates a fragment whose children order doesn't change.
+   */
+  STABLE_FRAGMENT = 64,
+  /**
+   * Indicates a fragment with keyed or partially keyed children
+   */
+  KEYED_FRAGMENT = 128,
+  /**
+   * Indicates a fragment with unkeyed children.
+   */
+  UNKEYED_FRAGMENT = 256,
+  /**
+   * Indicates an element that only needs non-props patching, e.g. ref or
+   * directives (onVnodeXXX hooks). since every patched vnode checks for refs
+   * and onVnodeXXX hooks, it simply marks the vnode so that a parent block
+   * will track it.
+   */
+  NEED_PATCH = 512,
+  /**
+   * Indicates a component with dynamic slots (e.g. slot that references a v-for
+   * iterated value, or dynamic slot names).
+   * Components with this flag are always force updated.
+   */
+  DYNAMIC_SLOTS = 1024,
+  /**
+   * Indicates a fragment that was created only because the user has placed
+   * comments at the root level of a template. This is a dev-only flag since
+   * comments are stripped in production.
+   */
+  DEV_ROOT_FRAGMENT = 2048,
+  /**
+   * SPECIAL FLAGS -------------------------------------------------------------
+   * Special flags are negative integers. They are never matched against using
+   * bitwise operators (bitwise matching should only happen in branches where
+   * patchFlag > 0), and are mutually exclusive. When checking for a special
+   * flag, simply check patchFlag === FLAG.
+   */
+  /**
+   * Indicates a cached static vnode. This is also a hint for hydration to skip
+   * the entire sub tree since static content never needs to be updated.
+   */
+  CACHED = -1,
+  /**
+   * A special flag that indicates that the diffing algorithm should bail out
+   * of optimized mode. For example, on block fragments created by renderSlot()
+   * when encountering non-compiler generated slots (i.e. manually written
+   * render functions, which should always be fully diffed)
+   * OR manually cloneVNodes
+   */
+  BAIL = -2
+}
+declare function generateCodeFrame(source: string, start?: number, end?: number): string;
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type LooseRequired<T> = { [P in keyof (T & Required<T>)]: T[P] };
+type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+//#endregion
+export { UnionToIntersection as a, Prettify as i, LooseRequired as n, generateCodeFrame as o, PatchFlags as r, IfAny as t };