@stacksjs/stx 0.2.155 → 0.2.156

package/dist/validator.d.ts

@@ -1,3 +1,27 @@
+/**
+ * Template Validation
+ *
+ * Provides validation utilities for stx templates before processing.
+ * Checks for common syntax errors, structural issues, and potential security problems.
+ */
+/**
+ * Template validation error
+ */
+export interface TemplateValidationError {
+    type: 'syntax' | 'directive' | 'expression' | 'structure';
+    message: string;
+    line?: number;
+    column?: number;
+    suggestion?: string;
+}
+/**
+ * Template validation result
+ */
+export interface TemplateValidationResult {
+    valid: boolean;
+    errors: TemplateValidationError[];
+    warnings: TemplateValidationError[];
+}
 /**
  * Validate a template before processing
  *
@@ -27,7 +51,10 @@ export declare function validateTemplate(template: string): TemplateValidationRe
  * @param position - Character position
  * @returns Line and column numbers (1-indexed)
  */
-export declare function getPositionInfo(template: string, position: number): { line: number, column: number };
+export declare function getPositionInfo(template: string, position: number): {
+    line: number;
+    column: number;
+};
 /**
  * Validate a specific directive's syntax
  *
@@ -36,7 +63,6 @@ export declare function getPositionInfo(template: string, position: number): { l
  * @param params - Parameters passed to the directive
  * @returns Validation errors, if any
  */
-// eslint-disable-next-line pickier/no-unused-vars
 export declare function validateDirective(directiveName: string, content: string, params: string[]): TemplateValidationError[];
 /**
  * Check if a template has any directives
@@ -52,27 +78,3 @@ export declare function hasDirectives(template: string): boolean;
  * @returns Array of directive names (without @ prefix)
  */
 export declare function extractDirectiveNames(template: string): string[];
-/**
- * Template Validation
- *
- * Provides validation utilities for stx templates before processing.
- * Checks for common syntax errors, structural issues, and potential security problems.
- */
-/**
- * Template validation error
- */
-export declare interface TemplateValidationError {
-  type: 'syntax' | 'directive' | 'expression' | 'structure'
-  message: string
-  line?: number
-  column?: number
-  suggestion?: string
-}
-/**
- * Template validation result
- */
-export declare interface TemplateValidationResult {
-  valid: boolean
-  errors: TemplateValidationError[]
-  warnings: TemplateValidationError[]
-}

package/dist/variable-extractor.d.ts

@@ -13,6 +13,47 @@ export declare function stripTypeScript(scriptContent: string): string;
  * Bun and Node.
  */
 export declare function isModuleResolutionFailure(message: string): boolean;
+/**
+ * Whether a script failed because it named something that does not exist.
+ *
+ * The same category as a module that will not resolve, and worth the same
+ * unconditional warning for the same reason: it is never the legitimate case
+ * the silence exists for. A page that uses only client APIs fails here on
+ * `document` or `window`, which is expected and quiet - but those are the
+ * *only* names it fails on, and a script that trips over anything else has a
+ * bug in it.
+ *
+ * A missing binding is particularly cruel because optional chaining does not
+ * help. `foo?.bar` guards an undefined *property*; an undefined *identifier* is
+ * a ReferenceError before the chain is reached, so a script that carefully
+ * writes `someContext?.value` still throws and still takes every variable in
+ * the file down with it. A page then renders its empty-state branch and reads
+ * as a correct answer rather than as a failure, which is exactly the shape that
+ * is expensive to find.
+ */
+export declare function isMissingBindingFailure(message: string): boolean;
+/**
+ * Extract variables from script content and add them to context
+ *
+ * @param scriptContent - The JavaScript/TypeScript code from a <script> tag
+ * @param context - The context object to populate with extracted variables
+ * @param filePath - Path to the file (for error messages)
+ */
+export interface ExtractVariablesOptions {
+    /**
+     * Don't overwrite a context key that already has a value. Use this
+     * when extracting from a LAYOUT or PARTIAL `<script server>` so the
+     * child page's identifier wins — layouts can declare stubs/defaults
+     * (`const user = { avatarInitials: 'JD' }`) without clobbering the
+     * full object the page set on the same name.
+     *
+     * Off by default: page-level extraction (in render.ts) still
+     * overrides caller-supplied context values, matching pre-flag
+     * behaviour. Only the layout/partial extraction path in process.ts
+     * passes this flag on.
+     */
+    preserveExisting?: boolean;
+}
 export declare function extractVariables(scriptContent: string, context: Record<string, unknown>, filePath: string, options?: ExtractVariablesOptions): Promise<void>;
 /**
  * Convert ES module syntax to CommonJS
@@ -55,7 +96,11 @@ export declare function convertToCommonJS(scriptContent: string, filePath?: stri
  * Returns null when the line is not a simple declaration, which leaves the
  * destructuring and multi-line paths below to handle it as before.
  */
-export declare function splitDeclaration(line: string): { type: string, name: string, value: string } | null;
+export declare function splitDeclaration(line: string): {
+    type: string;
+    name: string;
+    value: string;
+} | null;
 /**
  * Extract script content from an HTML template
  *
@@ -63,8 +108,8 @@ export declare function splitDeclaration(line: string): { type: string, name: st
  * @returns Object with script content and template without script tags
  */
 export declare function extractScriptFromTemplate(template: string): {
-  scriptContent: string
-  templateWithoutScript: string
+    scriptContent: string;
+    templateWithoutScript: string;
 };
 /**
  * Check if script content has any variables to extract
@@ -73,13 +118,3 @@ export declare function extractScriptFromTemplate(template: string): {
  * @returns Whether variables are present
  */
 export declare function hasVariables(scriptContent: string): boolean;
-/**
- * Extract variables from script content and add them to context
- *
- * @param scriptContent - The JavaScript/TypeScript code from a <script> tag
- * @param context - The context object to populate with extracted variables
- * @param filePath - Path to the file (for error messages)
- */
-export declare interface ExtractVariablesOptions {
-  preserveExisting?: boolean
-}

package/dist/variable-extractor.js

@@ -213,6 +213,11 @@ export function stripTypeScript(scriptContent) {
 export function isModuleResolutionFailure(message) {
   return /cannot find module|could not resolve|module not found|failed to resolve/i.test(message);
 }
+export function isMissingBindingFailure(message) {
+  if (!/is not defined|can't find variable/i.test(message))
+    return !1;
+  return !/\b(document|window|navigator|localStorage|sessionStorage|self)\b/.test(message);
+}
 export async function extractVariables(scriptContent, context, filePath, options = {}) {
   if (!scriptContent.trim())
     return;
@@ -313,6 +318,13 @@ export async function extractVariables(scriptContent, context, filePath, options
     if (config.title !== void 0 || config.description !== void 0)
       useSeoMeta({ title: config.title, description: config.description });
   }
+  function defineClientPayload(payload) {
+    if (!payload || typeof payload !== "object")
+      return;
+    const declared = context.__stxClientPayload ?? {};
+    Object.assign(declared, payload);
+    context.__stxClientPayload = declared;
+  }
   const useRoute = () => {
     const serveCtx = context.__stxServeContext, search = context.__stxServeSearch ?? serveCtx?.search ?? "", path = serveCtx?.path ?? "";
     return {
@@ -464,11 +476,11 @@ export async function extractVariables(scriptContent, context, filePath, options
       scriptContextKeys.push(filteredContextKeys[i]);
       scriptContextValues.push(filteredContextValues[i]);
     }
-    const result = await Function("module", "exports", "require", "props", "$props", "defineProps", "withDefaults", "state", "derived", "effect", "batch", "onMount", "onDestroy", "definePageMeta", "useRoute", "useRouter", "useHead", "useSeoMeta", "ref", "reactive", "computed", "watch", "onMounted", "onUnmounted", "nextTick", "defineEmits", "defineExpose", "defineSlots", "provide", "inject", "useColorMode", "useDark", "useMediaQuery", "useScrollLock", "usePreferredDark", "usePreferredLight", "usePreferredReducedMotion", "usePreferredContrast", "window", "document", "console", "confirm", "alert", "fetch", "params", ...propArgNames, ...scriptContextKeys, `return (async () => {
+    const result = await Function("module", "exports", "require", "props", "$props", "defineProps", "withDefaults", "defineClientPayload", "state", "derived", "effect", "batch", "onMount", "onDestroy", "definePageMeta", "useRoute", "useRouter", "useHead", "useSeoMeta", "ref", "reactive", "computed", "watch", "onMounted", "onUnmounted", "nextTick", "defineEmits", "defineExpose", "defineSlots", "provide", "inject", "useColorMode", "useDark", "useMediaQuery", "useScrollLock", "usePreferredDark", "usePreferredLight", "usePreferredReducedMotion", "usePreferredContrast", "window", "document", "console", "confirm", "alert", "fetch", "params", ...propArgNames, ...scriptContextKeys, `return (async () => {
         ${convertedScript}
         ${reSyncCode}
         return module.exports
-      })()`)(module, exports, requireFn, propsObj, $props, defineProps, withDefaults, state, derived, effect, batch, onMount, onDestroy, definePageMeta, useRoute, useRouter, useHead, useSeoMeta, ref, reactive, computed, watch, onMounted, onUnmounted, nextTick, defineEmits, defineExpose, defineSlots, provide, inject, useColorMode, useDark, useMediaQuery, useScrollLock, usePreferredDark, usePreferredLight, usePreferredReducedMotion, usePreferredContrast, windowProxy, mockDocument, mockConsole, mockWindow.confirm, mockWindow.alert, mockWindow.fetch, paramsObj, ...propArgValues, ...scriptContextValues);
+      })()`)(module, exports, requireFn, propsObj, $props, defineProps, withDefaults, defineClientPayload, state, derived, effect, batch, onMount, onDestroy, definePageMeta, useRoute, useRouter, useHead, useSeoMeta, ref, reactive, computed, watch, onMounted, onUnmounted, nextTick, defineEmits, defineExpose, defineSlots, provide, inject, useColorMode, useDark, useMediaQuery, useScrollLock, usePreferredDark, usePreferredLight, usePreferredReducedMotion, usePreferredContrast, windowProxy, mockDocument, mockConsole, mockWindow.confirm, mockWindow.alert, mockWindow.fetch, paramsObj, ...propArgValues, ...scriptContextValues);
     if (options.preserveExisting) {
       for (const [key, value] of Object.entries(result))
         if (!(key in context) || context[key] === void 0)
@@ -482,6 +494,8 @@ export async function extractVariables(scriptContent, context, filePath, options
     const msg = primaryError instanceof Error ? primaryError.message : String(primaryError);
     if (isModuleResolutionFailure(msg))
       console.warn(`[stx] server <script> in ${filePath ?? "<unknown>"} imports a module that does not resolve, so every variable in that script is undefined. Cause: ${msg}`);
+    else if (isMissingBindingFailure(msg))
+      console.warn(`[stx] server <script> in ${filePath ?? "<unknown>"} names something that does not exist, so every variable in that script is undefined. Optional chaining does not help here: an undefined identifier throws before the chain is reached. Cause: ${msg}`);
     else if (process.env.STX_DEBUG)
       console.warn(`[stx] server <script> did not execute in ${filePath ?? "<unknown>"} \u2014 falling back to static extraction. Cause: ${msg}`);
     try {
@@ -1111,8 +1125,17 @@ function isValueComplete(value) {
   }
   return depth.paren === 0 && depth.bracket === 0 && depth.brace === 0 && inString === null;
 }
+function findFunctionBodyBrace(functionLine) {
+  const parenPos = functionLine.indexOf("(");
+  if (parenPos === -1)
+    return functionLine.indexOf("{");
+  const paramsEnd = findMatchingDelimiter(functionLine, "(", ")", parenPos);
+  if (paramsEnd === -1)
+    return -1;
+  return functionLine.indexOf("{", paramsEnd);
+}
 function needsMultilineFunctionReading(functionLine) {
-  const bracePos = functionLine.indexOf("{");
+  const bracePos = findFunctionBodyBrace(functionLine);
   if (bracePos === -1)
     return !0;
   return findMatchingDelimiter(functionLine, "{", "}", bracePos) === -1;
@@ -1139,7 +1162,7 @@ ${lines[i]}`;
 function readMultilineFunction(lines, startIndex, initialFunction) {
   let functionCode = initialFunction, i = startIndex + 1;
   while (i < lines.length) {
-    const bracePos = functionCode.indexOf("{");
+    const bracePos = findFunctionBodyBrace(functionCode);
     if (bracePos !== -1) {
       if (findMatchingDelimiter(functionCode, "{", "}", bracePos) !== -1)
         break;

package/dist/view-composers.d.ts

@@ -1,3 +1,83 @@
+/**
+ * View Composers Module
+ *
+ * Similar to Laravel's View Composers, this module allows registering callbacks
+ * that automatically run whenever a specific view (or views matching a pattern)
+ * is rendered. Use this to inject data into templates without manually passing
+ * it every time.
+ *
+ * ## Use Cases
+ *
+ * - Inject user data into all views
+ * - Add navigation data to layout templates
+ * - Load settings for specific page types
+ * - Populate dropdown options across forms
+ *
+ * ## Registration Methods
+ *
+ * ### Exact Match
+ * ```typescript
+ * import { composer } from 'stx'
+ *
+ * // Match by exact view name
+ * composer('dashboard', async (context) => {
+ *   context.stats = await fetchDashboardStats()
+ * })
+ *
+ * // Match by full file path
+ * composer('/views/admin/users.stx', (context) => {
+ *   context.roles = ['admin', 'editor', 'viewer']
+ * })
+ * ```
+ *
+ * ### Pattern Match
+ * ```typescript
+ * import { composerPattern } from 'stx'
+ *
+ * // Match all admin views
+ * composerPattern(/^admin/, (context) => {
+ *   context.isAdmin = true
+ * })
+ *
+ * // Match with string pattern (converted to RegExp)
+ * composerPattern('.*\\.settings\\.', (context) => {
+ *   context.settingsMenu = loadSettingsMenu()
+ * })
+ * ```
+ *
+ * ## Execution Order
+ *
+ * 1. Exact match composers (by full file path)
+ * 2. Exact match composers (by view name only)
+ * 3. Pattern match composers (in registration order)
+ *
+ * All composers for a matching view run in sequence.
+ * Async composers are awaited before the next runs.
+ *
+ * ## Important Notes
+ *
+ * - Composers modify the context object directly (no return value needed)
+ * - Composers are global and persist for the application lifetime
+ * - Use `clearComposers()` to reset in tests
+ *
+ * @module view-composers
+ */
+/**
+ * Callback function type for view composers.
+ *
+ * @param context - The template context object (modify this directly)
+ * @param filePath - Full path to the template file being rendered
+ * @returns void or a Promise that resolves to void
+ *
+ * @example
+ * ```typescript
+ * const myComposer: ViewComposerCallback = async (context, filePath) => {
+ *   context.user = await getCurrentUser()
+ *   context.viewPath = filePath
+ * }
+ * ```
+ */
+export type ViewComposerCallback = (context: Record<string, any>, filePath: string) => void | Promise<void>;
 /**
  * Register a composer for a specific view.
  *
@@ -89,84 +169,3 @@ export declare function runComposers(filePath: string, context: Record<string, a
  * ```
  */
 export declare function clearComposers(): void;
-/**
- * View Composers Module
- *
- * Similar to Laravel's View Composers, this module allows registering callbacks
- * that automatically run whenever a specific view (or views matching a pattern)
- * is rendered. Use this to inject data into templates without manually passing
- * it every time.
- *
- * ## Use Cases
- *
- * - Inject user data into all views
- * - Add navigation data to layout templates
- * - Load settings for specific page types
- * - Populate dropdown options across forms
- *
- * ## Registration Methods
- *
- * ### Exact Match
- * ```typescript
- * import { composer } from 'stx'
- *
- * // Match by exact view name
- * composer('dashboard', async (context) => {
- *   context.stats = await fetchDashboardStats()
- * })
- *
- * // Match by full file path
- * composer('/views/admin/users.stx', (context) => {
- *   context.roles = ['admin', 'editor', 'viewer']
- * })
- * ```
- *
- * ### Pattern Match
- * ```typescript
- * import { composerPattern } from 'stx'
- *
- * // Match all admin views
- * composerPattern(/^admin/, (context) => {
- *   context.isAdmin = true
- * })
- *
- * // Match with string pattern (converted to RegExp)
- * composerPattern('.*\\.settings\\.', (context) => {
- *   context.settingsMenu = loadSettingsMenu()
- * })
- * ```
- *
- * ## Execution Order
- *
- * 1. Exact match composers (by full file path)
- * 2. Exact match composers (by view name only)
- * 3. Pattern match composers (in registration order)
- *
- * All composers for a matching view run in sequence.
- * Async composers are awaited before the next runs.
- *
- * ## Important Notes
- *
- * - Composers modify the context object directly (no return value needed)
- * - Composers are global and persist for the application lifetime
- * - Use `clearComposers()` to reset in tests
- *
- * @module view-composers
- */
-/**
- * Callback function type for view composers.
- *
- * @param context - The template context object (modify this directly)
- * @param filePath - Full path to the template file being rendered
- * @returns void or a Promise that resolves to void
- *
- * @example
- * ```typescript
- * const myComposer: ViewComposerCallback = async (context, filePath) => {
- *   context.user = await getCurrentUser()
- *   context.viewPath = filePath
- * }
- * ```
- */
-// eslint-disable-next-line pickier/no-unused-vars
-export type ViewComposerCallback = (context: Record<string, any>, filePath: string) => void | Promise<void>;

package/dist/virtual-scrolling.d.ts

@@ -1,3 +1,69 @@
+/**
+ * Virtual Scrolling Module
+ *
+ * Provides efficient rendering of large lists using windowing/virtualization.
+ * Only renders items that are visible in the viewport, dramatically improving
+ * performance for lists with thousands of items.
+ *
+ * @example
+ * ```html
+ * @virtualList(items, { itemHeight: 50, containerHeight: 400 })
+ *   <div class="item">{{ item.name }}</div>
+ * @endvirtualList
+ * ```
+ */
+export interface VirtualListOptions {
+    /** Height of each item in pixels */
+    itemHeight: number;
+    /** Height of the container in pixels */
+    containerHeight: number;
+    /** Number of items to render outside the visible area (buffer) */
+    overscan?: number;
+    /** Unique key property for items */
+    keyProperty?: string;
+    /** Enable dynamic item heights */
+    dynamicHeight?: boolean;
+    /** Estimated item height for dynamic heights */
+    estimatedItemHeight?: number;
+    /** Scroll behavior: 'auto' | 'smooth' */
+    scrollBehavior?: 'auto' | 'smooth';
+    /** Direction: 'vertical' | 'horizontal' */
+    direction?: 'vertical' | 'horizontal';
+    /** CSS class for the container */
+    containerClass?: string;
+    /** CSS class for the viewport */
+    viewportClass?: string;
+    /** CSS class for each item wrapper */
+    itemClass?: string;
+}
+export interface VirtualListState {
+    /** Start index of visible items */
+    startIndex: number;
+    /** End index of visible items */
+    endIndex: number;
+    /** Current scroll position */
+    scrollTop: number;
+    /** Total height of all items */
+    totalHeight: number;
+    /** Visible items */
+    visibleItems: unknown[];
+    /** Item heights cache for dynamic heights */
+    itemHeights: Map<number, number>;
+}
+export interface VirtualScrollInstance {
+    /** Scroll to a specific index */
+    scrollToIndex: (index: number, behavior?: ScrollBehavior) => void;
+    /** Scroll to a specific offset */
+    scrollToOffset: (offset: number, behavior?: ScrollBehavior) => void;
+    /** Get current scroll state */
+    getState: () => VirtualListState;
+    /** Force recalculation of visible items */
+    refresh: () => void;
+    /** Update items */
+    setItems: (items: unknown[]) => void;
+    /** Destroy the instance */
+    destroy: () => void;
+}
 /**
  * Creates a virtual scroll instance for a list of items
  */
@@ -14,94 +80,48 @@ export declare function generateVirtualListCSS(): string;
  * Hook to create a reactive virtual list
  */
 export declare function useVirtualList<T>(items: () => T[], options: VirtualListOptions): {
-  visibleItems: () => T[]
-  totalHeight: () => number
-  containerProps: () => Record<string, unknown>
-  itemProps: (index: number) => Record<string, unknown>
-  scrollToIndex: (index: number) => void
+    visibleItems: () => T[];
+    totalHeight: () => number;
+    containerProps: () => Record<string, unknown>;
+    itemProps: (index: number) => Record<string, unknown>;
+    scrollToIndex: (index: number) => void;
 };
+export interface InfiniteScrollOptions extends VirtualListOptions {
+    /** Threshold in pixels before end to trigger load more */
+    threshold?: number;
+    /** Callback when more items should be loaded */
+    onLoadMore?: () => Promise<void>;
+    /** Whether more items are available */
+    hasMore?: boolean;
+    /** Loading state */
+    isLoading?: boolean;
+}
 /**
  * Process @infiniteList directives for infinite scrolling
  */
 export declare function processInfiniteListDirectives(template: string, context?: Record<string, unknown>, _filePath?: string): string;
+export interface VirtualGridOptions {
+    /** Number of columns */
+    columns: number;
+    /** Row height in pixels */
+    rowHeight: number;
+    /** Container height in pixels */
+    containerHeight: number;
+    /** Gap between items */
+    gap?: number;
+    /** Overscan rows */
+    overscan?: number;
+}
 /**
  * Process @virtualGrid directives for grid virtualization
  */
 export declare function processVirtualGridDirectives(template: string, context?: Record<string, unknown>, _filePath?: string): string;
-/* eslint-disable prefer-const, style/max-statements-per-line, no-super-linear-backtracking, regexp/no-unused-capturing-group */
-/**
- * Virtual Scrolling Module
- *
- * Provides efficient rendering of large lists using windowing/virtualization.
- * Only renders items that are visible in the viewport, dramatically improving
- * performance for lists with thousands of items.
- *
- * @example
- * ```html
- * @virtualList(items, { itemHeight: 50, containerHeight: 400 })
- *   <div class="item">{{ item.name }}</div>
- * @endvirtualList
- * ```
- */
-// ============================================================================
-// Types
-// ============================================================================
-export declare interface VirtualListOptions {
-  itemHeight: number
-  containerHeight: number
-  overscan?: number
-  keyProperty?: string
-  dynamicHeight?: boolean
-  estimatedItemHeight?: number
-  scrollBehavior?: 'auto' | 'smooth'
-  direction?: 'vertical' | 'horizontal'
-  containerClass?: string
-  viewportClass?: string
-  itemClass?: string
-}
-export declare interface VirtualListState {
-  startIndex: number
-  endIndex: number
-  scrollTop: number
-  totalHeight: number
-  visibleItems: unknown[]
-  itemHeights: Map<number, number>
-}
-export declare interface VirtualScrollInstance {
-  scrollToIndex: (index: number, behavior?: ScrollBehavior) => void
-  scrollToOffset: (offset: number, behavior?: ScrollBehavior) => void
-  getState: () => VirtualListState
-  refresh: () => void
-  setItems: (items: unknown[]) => void
-  destroy: () => void
-}
-// ============================================================================
-// Infinite Scroll Support
-// ============================================================================
-export declare interface InfiniteScrollOptions extends VirtualListOptions {
-  threshold?: number
-  onLoadMore?: () => Promise<void>
-  hasMore?: boolean
-  isLoading?: boolean
-}
-// ============================================================================
-// Grid Virtualization
-// ============================================================================
-export declare interface VirtualGridOptions {
-  columns: number
-  rowHeight: number
-  containerHeight: number
-  gap?: number
-  overscan?: number
-}
-// ============================================================================
-// Exports
-// ============================================================================
-export default {
-  createVirtualList,
-  processVirtualListDirectives,
-  processInfiniteListDirectives,
-  processVirtualGridDirectives,
-  generateVirtualListCSS,
-  useVirtualList,
+declare const _default: {
+    createVirtualList: typeof createVirtualList;
+    processVirtualListDirectives: typeof processVirtualListDirectives;
+    processInfiniteListDirectives: typeof processInfiniteListDirectives;
+    processVirtualGridDirectives: typeof processVirtualGridDirectives;
+    generateVirtualListCSS: typeof generateVirtualListCSS;
+    useVirtualList: typeof useVirtualList;
 };
+export default _default;

package/dist/vue-template.d.ts

@@ -1,3 +1,26 @@
+/**
+ * Vue Template Directive Transformer
+ *
+ * Pre-processing transform that converts Vue template syntax into existing stx directives.
+ * This runs early in the processing pipeline, before any directive processing,
+ * allowing users to write Vue-style templates that leverage stx's existing infrastructure.
+ *
+ * Supported Vue directives:
+ * - v-if, v-else-if, v-else → @if/@elseif/@else/@endif
+ * - v-for → @foreach/@endforeach
+ * - v-show → @show attribute
+ * - v-model → @model (native) or :modelValue + @update:modelValue (components)
+ * - v-bind: / : → @bind: attribute
+ * - v-on: / @ (in Vue context) → @ event directives
+ * - v-html → {!! expr !!}
+ * - v-text → {{ expr }}
+ * - v-pre → data-stx-skip
+ * - v-once → @once/@endonce wrapper
+ * - v-cloak → preserved, removed by runtime
+ * - v-memo → data-stx-memo attribute
+ *
+ * @module vue-template
+ */
 /**
  * Check if template contains any Vue-style directives.
  * Quick check to avoid unnecessary processing.

package/dist/web-components/css-scoping.d.ts

@@ -1,3 +1,22 @@
+/**
+ * CSS Scoping for Web Components
+ *
+ * Provides utilities for scoping CSS styles to specific components
+ * to prevent style leakage in Shadow DOM and for component isolation.
+ */
+/**
+ * Options for CSS scoping
+ */
+export interface CssScopingOptions {
+    /** Prefix to add to selectors */
+    prefix?: string;
+    /** Whether to preserve :host selectors */
+    preserveHost?: boolean;
+    /** Whether to scope keyframe names */
+    scopeKeyframes?: boolean;
+    /** Whether to scope CSS custom properties */
+    scopeCustomProperties?: boolean;
+}
 /**
  * Generate a unique component ID based on hash
  */
@@ -24,8 +43,8 @@ export declare function scopeCss(css: string, componentId: string, options?: Css
  * @returns Object with CSS content and template without style tags
  */
 export declare function extractStyleFromTemplate(template: string): {
-  css: string
-  templateWithoutStyle: string
+    css: string;
+    templateWithoutStyle: string;
 };
 /**
  * Inject scoped CSS into a template
@@ -43,12 +62,3 @@ export declare function injectScopedCss(template: string, scopedCss: string, pos
  * @returns CSS suitable for Shadow DOM
  */
 export declare function generateShadowDomCss(css: string): string;
-/**
- * Options for CSS scoping
- */
-export declare interface CssScopingOptions {
-  prefix?: string
-  preserveHost?: boolean
-  scopeKeyframes?: boolean
-  scopeCustomProperties?: boolean
-}