@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/analytics.d.ts

@@ -0,0 +1,40 @@
+import type { CustomDirective, StxOptions } from './types';
+/**
+ * Analytics Module
+ *
+ * Provides automatic analytics script injection for various providers:
+ * - Fathom Analytics (privacy-focused)
+ * - Google Analytics (GA4)
+ * - Plausible Analytics (privacy-focused, open source)
+ * - Self-hosted analytics (using dynamodb-tooling)
+ * - Custom analytics scripts
+ *
+ * ## Configuration
+ *
+ * Analytics can be configured in `stx.config.ts`:
+ * ```typescript
+ * export default {
+ *   analytics: {
+ *     enabled: true,
+ *     driver: 'fathom',
+ *     fathom: {
+ *       siteId: 'ABCDEFGH',
+ *       honorDnt: true,
+ *     }
+ *   }
+ * }
+ * ```
+ */
+/**
+ * Generate analytics tracking script based on configuration
+ */
+export declare function generateAnalyticsScript(options: StxOptions): string;
+/**
+ * Inject analytics script into HTML
+ * Scripts are injected just before </head> for optimal loading
+ */
+export declare function injectAnalytics(html: string, options: StxOptions): string;
+/**
+ * Custom @analytics directive for explicit placement
+ */
+export declare const analyticsDirective: CustomDirective;

package/dist/analytics.js

@@ -0,0 +1,159 @@
+export function generateAnalyticsScript(options) {
+  const analytics = options.analytics;
+  if (!analytics?.enabled)
+    return "";
+  switch (analytics.driver) {
+    case "fathom":
+      return generateFathomScript(analytics);
+    case "google-analytics":
+      return generateGoogleAnalyticsScript(analytics);
+    case "plausible":
+      return generatePlausibleScript(analytics);
+    case "self-hosted":
+      return generateSelfHostedScript(analytics);
+    case "custom":
+      return generateCustomScript(analytics);
+    default:
+      return "";
+  }
+}
+function generateFathomScript(config) {
+  const fathom = config.fathom;
+  if (!fathom?.siteId)
+    return "";
+  const scriptUrl = fathom.scriptUrl || "https://cdn.usefathom.com/script.js", defer = fathom.defer !== !1 ? " defer" : "", dataAttrs = [`data-site="${escapeAttr(fathom.siteId)}"`];
+  if (fathom.honorDnt)
+    dataAttrs.push('data-honor-dnt="true"');
+  if (fathom.spa)
+    dataAttrs.push('data-spa="auto"');
+  if (fathom.canonical)
+    dataAttrs.push(`data-canonical="${escapeAttr(fathom.canonical)}"`);
+  if (fathom.auto === !1)
+    dataAttrs.push('data-auto="false"');
+  return `
+<!-- Fathom Analytics -->
+<script src="${escapeAttr(scriptUrl)}" ${dataAttrs.join(" ")}${defer}></script>
+`;
+}
+function generateGoogleAnalyticsScript(config) {
+  const ga = config.googleAnalytics;
+  if (!ga?.measurementId)
+    return "";
+  const measurementId = escapeAttr(ga.measurementId), debugMode = ga.debug ? `gtag('config', '${measurementId}', { 'debug_mode': true });` : "";
+  return `
+<!-- Google Analytics -->
+<script async src="https://www.googletagmanager.com/gtag/js?id=${measurementId}"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', '${measurementId}');
+  ${debugMode}
+</script>
+`;
+}
+function generatePlausibleScript(config) {
+  const plausible = config.plausible;
+  if (!plausible?.domain)
+    return "";
+  const scriptUrl = plausible.scriptUrl || "https://plausible.io/js/script.js", _dataAttrs = [`data-domain="${escapeAttr(plausible.domain)}"`];
+  let finalScriptUrl = scriptUrl;
+  const extensions = [];
+  if (plausible.trackLocalhost)
+    extensions.push("local");
+  if (plausible.hashMode)
+    extensions.push("hash");
+  if (extensions.length > 0 && scriptUrl === "https://plausible.io/js/script.js")
+    finalScriptUrl = `https://plausible.io/js/script.${extensions.join(".")}.js`;
+  return `
+<!-- Plausible Analytics -->
+<script defer data-domain="${escapeAttr(plausible.domain)}" src="${escapeAttr(finalScriptUrl)}"></script>
+`;
+}
+function generateSelfHostedScript(config) {
+  const selfHosted = config.selfHosted;
+  if (!selfHosted?.siteId || !selfHosted?.apiEndpoint)
+    return "";
+  const siteId = escapeAttr(selfHosted.siteId), apiEndpoint = escapeAttr(selfHosted.apiEndpoint), honorDnt = selfHosted.honorDnt ? 'if(n.doNotTrack==="1")return;' : "", hashTracking = selfHosted.trackHashChanges ? "w.addEventListener('hashchange',pv);" : "", outboundTracking = selfHosted.trackOutboundLinks ? `
+  d.addEventListener('click',function(e){
+    var a=e.target.closest('a');
+    if(a&&a.hostname!==location.hostname){
+      t('outbound',{url:a.href});
+    }
+  });` : "";
+  return `
+<!-- Self-Hosted Analytics -->
+<script data-site="${siteId}" data-api="${apiEndpoint}" defer>
+(function(){
+  'use strict';
+  var d=document,w=window,n=navigator,s=d.currentScript;
+  var site=s.dataset.site,api=s.dataset.api;
+  ${honorDnt}
+  var q=[],sid=Math.random().toString(36).slice(2);
+  function t(e,p){
+    var x=new XMLHttpRequest();
+    x.open('POST',api+'/collect',true);
+    x.setRequestHeader('Content-Type','application/json');
+    x.send(JSON.stringify({
+      s:site,sid:sid,e:e,p:p||{},
+      u:location.href,r:d.referrer,t:d.title,
+      sw:screen.width,sh:screen.height
+    }));
+  }
+  function pv(){t('pageview');}
+  ${hashTracking}
+  ${outboundTracking}
+  if(d.readyState==='complete')pv();
+  else w.addEventListener('load',pv);
+  w.stxAnalytics={track:function(n,v){t('event',{name:n,value:v});}};
+})();
+</script>
+`;
+}
+function generateCustomScript(config) {
+  const custom = config.custom;
+  if (!custom)
+    return "";
+  if (custom.inlineScript)
+    return `
+<!-- Custom Analytics -->
+<script>
+${custom.inlineScript}
+</script>
+`;
+  if (!custom.scriptUrl)
+    return "";
+  const attrs = [];
+  if (custom.scriptId)
+    attrs.push(`id="${escapeAttr(custom.scriptId)}"`);
+  if (custom.attributes)
+    for (const [key, value] of Object.entries(custom.attributes))
+      attrs.push(`${escapeAttr(key)}="${escapeAttr(value)}"`);
+  return `
+<!-- Custom Analytics -->
+<script${attrs.length > 0 ? ` ${attrs.join(" ")}` : ""} src="${escapeAttr(custom.scriptUrl)}" defer></script>
+`;
+}
+export function injectAnalytics(html, options) {
+  const analyticsScript = generateAnalyticsScript(options);
+  if (!analyticsScript)
+    return html;
+  if (!html.includes("</head>")) {
+    const anBodyIdx = html.lastIndexOf("</body>");
+    if (anBodyIdx !== -1)
+      return html.slice(0, anBodyIdx) + analyticsScript + html.slice(anBodyIdx);
+    return html + analyticsScript;
+  }
+  return html.replace("</head>", `${analyticsScript}</head>`);
+}
+function escapeAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+export const analyticsDirective = {
+  name: "analytics",
+  hasEndTag: !1,
+  handler: async (_content, _params, context, _filePath) => {
+    const options = context.__stx_config || {};
+    return generateAnalyticsScript(options);
+  }
+};

package/dist/analyzer.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Analyze an stx template file
+ */
+export declare function analyzeTemplate(filePath: string): Promise<AnalysisResult>;
+/**
+ * Analyze multiple templates
+ */
+// eslint-disable-next-line pickier/no-unused-vars
+export declare function analyzeProject(patterns?: string[], cwd?: string): Promise<{
+  results: AnalysisResult[]
+  summary: ProjectSummary
+}>;
+/**
+ * stx Template Analyzer - Analyze templates for performance, best practices, and potential issues
+ */
+export declare interface AnalysisResult {
+  file: string
+  metrics: TemplateMetrics
+  issues: Issue[]
+  suggestions: Suggestion[]
+  performance: PerformanceMetrics
+}
+export declare interface TemplateMetrics {
+  lines: number
+  characters: number
+  directives: DirectiveCount
+  expressions: number
+  components: number
+  layouts: number
+  scriptLines: number
+  complexity: number
+}
+export declare interface DirectiveCount {
+  conditionals: number
+  loops: number
+  includes: number
+  custom: number
+  total: number
+}
+export declare interface Issue {
+  type: 'error' | 'warning' | 'info'
+  category: 'performance' | 'security' | 'maintainability' | 'accessibility' | 'syntax'
+  message: string
+  line?: number
+  column?: number
+  suggestion?: string
+}
+export declare interface Suggestion {
+  type: 'optimization' | 'best-practice' | 'refactor'
+  message: string
+  impact: 'low' | 'medium' | 'high'
+  effort: 'low' | 'medium' | 'high'
+}
+export declare interface PerformanceMetrics {
+  estimatedRenderTime: number
+  complexityScore: number
+  cacheability: 'high' | 'medium' | 'low'
+  recommendations: string[]
+}
+export declare interface ProjectSummary {
+  totalFiles: number
+  totalLines: number
+  avgComplexity: number
+  totalIssues: number
+  issuesByCategory: Record<string, number>
+  performanceScore: number
+  recommendations: string[]
+}

package/dist/analyzer.js

@@ -0,0 +1,240 @@
+export async function analyzeTemplate(filePath) {
+  try {
+    const content = await Bun.file(filePath).text(), metrics = calculateMetrics(content), issues = findIssues(content, filePath), suggestions = generateSuggestions(content, metrics), performance = analyzePerformance(content, metrics);
+    return {
+      file: filePath,
+      metrics,
+      issues,
+      suggestions,
+      performance
+    };
+  } catch (error) {
+    throw Error(`Failed to analyze template ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function calculateMetrics(content) {
+  const lines = content.split(`
+`), scriptMatch = content.match(/<script\b[^>]*>([\s\S]*?)<\/script>/i), scriptLines = (scriptMatch ? scriptMatch[1] : "").split(`
+`).length, directives = {
+    conditionals: (content.match(/@(if|unless|elseif|else|endif|endunless)\b/g) || []).length,
+    loops: (content.match(/@(foreach|for|endforeach|endfor|while|endwhile)\b/g) || []).length,
+    includes: (content.match(/@(include|component|extends|section|yield)\b/g) || []).length,
+    custom: 0,
+    total: 0
+  };
+  directives.total = directives.conditionals + directives.loops + directives.includes + directives.custom;
+  const regularExpressions = (content.match(/\{\{[\s\S]*?\}\}/g) || []).length, rawExpressions = (content.match(/\{!![\s\S]*?!!\}/g) || []).length, directiveExpressions = (content.match(/@(?:if|unless|elseif|foreach|for|while)\s*\([^)]+\)/g) || []).length, expressions = regularExpressions + rawExpressions + directiveExpressions, components = (content.match(/<[A-Z][^>]*>/g) || []).length, layouts = (content.match(/@(?:layout|extends)\(/g) || []).length;
+  let maxNestingDepth = 0, currentDepth = 0;
+  for (const line of lines)
+    if (/@(?:if|unless|foreach|for|while|section)\b/.test(line) && !/@end/.test(line) && !/@else/.test(line)) {
+      currentDepth++;
+      maxNestingDepth = Math.max(maxNestingDepth, currentDepth);
+    } else if (/@end(?:if|unless|foreach|for|while|section)\b/.test(line))
+      currentDepth--;
+  const nestingBonus = maxNestingDepth >= 4 ? 3 : 0, complexity = Math.min(10, Math.ceil(directives.total * 0.5 + expressions * 0.1 + components * 0.3 + (scriptLines > 10 ? scriptLines * 0.05 : 0) + nestingBonus));
+  return {
+    lines: lines.length,
+    characters: content.length,
+    directives,
+    expressions,
+    components,
+    layouts,
+    scriptLines,
+    complexity
+  };
+}
+function findIssues(content, _filePath) {
+  const issues = [], unmatchedIfs = findUnmatchedDirectives(content, "if", "endif");
+  if (unmatchedIfs > 0)
+    issues.push({
+      type: "error",
+      category: "syntax",
+      message: `Found ${unmatchedIfs} unmatched @if directive(s)`,
+      suggestion: "Ensure every @if has a corresponding @endif"
+    });
+  const unmatchedForeachs = findUnmatchedDirectives(content, "foreach", "endforeach");
+  if (unmatchedForeachs > 0)
+    issues.push({
+      type: "error",
+      category: "syntax",
+      message: `Found ${unmatchedForeachs} unmatched @foreach directive(s)`,
+      suggestion: "Ensure every @foreach has a corresponding @endforeach"
+    });
+  const nestedLoops = content.match(/@foreach[\s\S]*?@foreach[\s\S]*?@endforeach[\s\S]*?@endforeach/g);
+  if (nestedLoops && nestedLoops.length > 0)
+    issues.push({
+      type: "warning",
+      category: "performance",
+      message: "Nested loops detected which may impact performance",
+      suggestion: "Consider preprocessing data or using more efficient data structures"
+    });
+  const rawOutputs = (content.match(/\{!![\s\S]*?!!\}/g) || []).length;
+  if (rawOutputs > 0)
+    issues.push({
+      type: "warning",
+      category: "security",
+      message: `Found ${rawOutputs} raw output expression(s) {!! !!}`,
+      suggestion: "Ensure raw outputs are properly sanitized to prevent XSS"
+    });
+  const images = content.match(/<img[^>]*>/g);
+  if (images) {
+    const imagesWithoutAlt = images.filter((img) => !img.includes("alt="));
+    if (imagesWithoutAlt.length > 0)
+      issues.push({
+        type: "warning",
+        category: "accessibility",
+        message: `Found ${imagesWithoutAlt.length} image(s) without alt attributes`,
+        suggestion: "Add alt attributes to all images for screen reader accessibility"
+      });
+  }
+  const longLines = content.split(`
+`).filter((line) => line.length > 120);
+  if (longLines.length > 0)
+    issues.push({
+      type: "info",
+      category: "maintainability",
+      message: `Found ${longLines.length} line(s) longer than 120 characters`,
+      suggestion: "Consider breaking long lines for better readability"
+    });
+  const inlineStyles = (content.match(/style\s*=\s*["'][^"']*["']/g) || []).length;
+  if (inlineStyles > 3)
+    issues.push({
+      type: "info",
+      category: "maintainability",
+      message: `Found ${inlineStyles} inline style attributes`,
+      suggestion: "Consider moving styles to CSS classes for better maintainability"
+    });
+  return issues;
+}
+function generateSuggestions(content, metrics) {
+  const suggestions = [];
+  if (metrics.complexity > 7)
+    suggestions.push({
+      type: "refactor",
+      message: "Template complexity is high. Consider breaking into smaller components.",
+      impact: "high",
+      effort: "medium"
+    });
+  else if (metrics.complexity > 5 && metrics.directives.total > 8)
+    suggestions.push({
+      type: "optimization",
+      message: "Template has moderate complexity. Consider component extraction for reusability.",
+      impact: "medium",
+      effort: "low"
+    });
+  if (metrics.lines > 100 && metrics.components === 0)
+    suggestions.push({
+      type: "refactor",
+      message: "Large template with no components. Consider extracting reusable parts into components.",
+      impact: "medium",
+      effort: "medium"
+    });
+  if (metrics.expressions > 20)
+    suggestions.push({
+      type: "optimization",
+      message: "Many template expressions detected. Consider preprocessing some data in the script section.",
+      impact: "medium",
+      effort: "low"
+    });
+  const nestedLoops = content.match(/@foreach[\s\S]*?@foreach[\s\S]*?@endforeach[\s\S]*?@endforeach/g);
+  if (nestedLoops && nestedLoops.length > 0)
+    suggestions.push({
+      type: "optimization",
+      message: "Nested loops detected. Consider preprocessing data or optimizing data structures.",
+      impact: "high",
+      effort: "medium"
+    });
+  if (metrics.directives.total === 0 && metrics.expressions < 5)
+    suggestions.push({
+      type: "optimization",
+      message: "Template appears static. Consider enabling aggressive caching.",
+      impact: "high",
+      effort: "low"
+    });
+  if (metrics.scriptLines > 50)
+    suggestions.push({
+      type: "refactor",
+      message: "Large script section. Consider moving complex logic to external modules.",
+      impact: "medium",
+      effort: "medium"
+    });
+  return suggestions;
+}
+function analyzePerformance(content, metrics) {
+  let estimatedRenderTime = 1;
+  estimatedRenderTime += metrics.directives.conditionals * 0.1;
+  estimatedRenderTime += metrics.directives.loops * 0.5;
+  estimatedRenderTime += metrics.directives.includes * 2;
+  estimatedRenderTime += metrics.expressions * 0.05;
+  estimatedRenderTime += metrics.components * 1;
+  if (metrics.scriptLines > 10)
+    estimatedRenderTime += metrics.scriptLines * 0.1;
+  let cacheability;
+  if (metrics.expressions === 0 && metrics.directives.total === 0)
+    cacheability = "high";
+  else if (metrics.expressions < 5 && metrics.directives.total < 3)
+    cacheability = "medium";
+  else
+    cacheability = "low";
+  const recommendations = [];
+  if (estimatedRenderTime > 10)
+    recommendations.push("Consider optimizing template complexity");
+  if (cacheability === "low" && metrics.directives.total > 5)
+    recommendations.push("Reduce dynamic content for better caching");
+  if (metrics.components === 0 && metrics.lines > 40)
+    recommendations.push("Extract components to improve reusability and performance");
+  return {
+    estimatedRenderTime: Math.round(estimatedRenderTime * 100) / 100,
+    complexityScore: metrics.complexity,
+    cacheability,
+    recommendations
+  };
+}
+function findUnmatchedDirectives(content, startDirective, endDirective) {
+  const contentWithoutComments = content.replace(/<!--[\s\S]*?-->/g, ""), starts = (contentWithoutComments.match(new RegExp(`@${startDirective}\\b`, "g")) || []).length, ends = (contentWithoutComments.match(new RegExp(`@${endDirective}\\b`, "g")) || []).length;
+  return Math.abs(starts - ends);
+}
+export async function analyzeProject(patterns = ["**/*.stx"], cwd) {
+  const results = [], allFiles = [];
+  for (const pattern of patterns) {
+    const files = await Array.fromAsync(new Bun.Glob(pattern).scan({
+      cwd: cwd || process.cwd(),
+      onlyFiles: !0,
+      absolute: !0
+    }));
+    allFiles.push(...files.filter((f) => f.endsWith(".stx")));
+  }
+  for (const file of allFiles)
+    try {
+      const result = await analyzeTemplate(file);
+      results.push(result);
+    } catch (error) {
+      console.warn(`Failed to analyze ${file}:`, error);
+    }
+  const summary = generateProjectSummary(results);
+  return { results, summary };
+}
+function generateProjectSummary(results) {
+  const totalFiles = results.length, totalLines = results.reduce((sum, r) => sum + r.metrics.lines, 0), avgComplexity = totalFiles > 0 ? results.reduce((sum, r) => sum + r.metrics.complexity, 0) / totalFiles : 0, totalIssues = results.reduce((sum, r) => sum + r.issues.length, 0), issuesByCategory = {};
+  results.forEach((r) => {
+    r.issues.forEach((issue) => {
+      issuesByCategory[issue.category] = (issuesByCategory[issue.category] || 0) + 1;
+    });
+  });
+  const avgRenderTime = totalFiles > 0 ? results.reduce((sum, r) => sum + r.performance.estimatedRenderTime, 0) / totalFiles : 0, performanceScore = Math.max(1, Math.min(10, Math.round(10 - avgRenderTime / 2 - avgComplexity / 2))), recommendations = [];
+  if (avgComplexity > 6)
+    recommendations.push("Project has high average complexity. Consider refactoring complex templates.");
+  if (totalIssues > totalFiles * 2)
+    recommendations.push("High number of issues detected. Run detailed analysis on individual files.");
+  if (issuesByCategory.security > 0)
+    recommendations.push("Security issues found. Review raw output usage and input sanitization.");
+  return {
+    totalFiles,
+    totalLines,
+    avgComplexity: Math.round(avgComplexity * 100) / 100,
+    totalIssues,
+    issuesByCategory,
+    performanceScore,
+    recommendations
+  };
+}

package/dist/animation.d.ts

@@ -0,0 +1,123 @@
+import type { CustomDirective, StxOptions } from './types';
+/**
+ * Available transition types that can be used with @transition directive
+ */
+export declare enum TransitionType {
+    Fade = "fade",
+    Slide = "slide",
+    Scale = "scale",
+    Flip = "flip",
+    Rotate = "rotate",
+    Custom = "custom"
+}
+/**
+ * Available transition directions that can be used with @transition directive
+ */
+export declare enum TransitionDirection {
+    In = "in",
+    Out = "out",
+    Both = "both"
+}
+/**
+ * Available ease functions for transitions
+ */
+export declare enum TransitionEase {
+    Linear = "linear",
+    Ease = "ease",
+    EaseIn = "ease-in",
+    EaseOut = "ease-out",
+    EaseInOut = "ease-in-out",
+    Spring = "spring"
+}
+/**
+ * Default transition options
+ */
+export declare const DEFAULT_TRANSITION_OPTIONS: {
+    duration: number;
+    delay: number;
+    ease: string;
+    direction: string;
+};
+/**
+ * Transition directive for applying transitions to elements
+ */
+export declare const transitionDirective: CustomDirective;
+/**
+ * Scroll animation directive for triggering animations on scroll
+ */
+export declare const scrollAnimateDirective: CustomDirective;
+/**
+ * Animation group directive for coordinating multiple animations
+ */
+export declare const animationGroupDirective: CustomDirective;
+/**
+ * Motion preferences directive for controlling animation preferences
+ */
+export declare const motionDirective: CustomDirective;
+/**
+ * Process animation directives in the template
+ */
+export declare function processAnimationDirectives(template: string, context: Record<string, any>, filePath: string, options: StxOptions): string;
+/** Keyframe definition */
+export interface Keyframe {
+    offset?: number;
+    properties: Record<string, string | number>;
+    easing?: string;
+}
+/** Animation timeline entry */
+export interface TimelineEntry {
+    selector: string;
+    keyframes: Keyframe[];
+    options: KeyframeAnimationOptions;
+}
+/** Keyframe animation options */
+export interface KeyframeAnimationOptions {
+    duration: number;
+    delay?: number;
+    easing?: string;
+    iterations?: number | 'infinite';
+    direction?: 'normal' | 'reverse' | 'alternate' | 'alternate-reverse';
+    fill?: 'none' | 'forwards' | 'backwards' | 'both';
+}
+/** Spring animation config */
+export interface SpringConfig {
+    stiffness: number;
+    damping: number;
+    mass: number;
+    velocity?: number;
+}
+/** Preset spring configurations */
+export declare const SPRING_PRESETS: Record<string, SpringConfig>;
+/**
+ * @keyframe directive for custom keyframe animations
+ */
+export declare const keyframeDirective: CustomDirective;
+/**
+ * @stagger directive for staggered child animations
+ */
+export declare const staggerDirective: CustomDirective;
+/**
+ * @spring directive for spring physics animations
+ */
+export declare const springDirective: CustomDirective;
+/**
+ * Create an animation timeline for coordinated animations
+ */
+export declare function createAnimationTimeline(entries: TimelineEntry[]): string;
+/**
+ * Generate CSS for a custom animation
+ */
+export declare function generateAnimationCSS(name: string, keyframes: Keyframe[], options: KeyframeAnimationOptions): string;
+/**
+ * Parse animation shorthand string
+ * Format: "duration [delay] [easing] [iterations] [direction] [fill]"
+ */
+export declare function parseAnimationShorthand(shorthand: string): KeyframeAnimationOptions;
+/**
+ * Generate client-side animation runtime
+ */
+export declare function generateAnimationRuntime(): string;
+/**
+ * Register animation directives
+ */
+export declare function registerAnimationDirectives(options: StxOptions): StxOptions;