@jacobknightley/fabric-format 0.0.1

package/dist/formatters/sparksql/sql-formatter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * SQL Formatter Wrapper
+ *
+ * Wraps the existing sparkfmt SQL formatter to implement the LanguageFormatter interface.
+ */
+import type { LanguageFormatter, FormatterOptions, FormatResult } from '../types.js';
+/**
+ * SQL formatter for Spark SQL.
+ */
+export declare class SqlFormatter implements LanguageFormatter {
+    readonly language = "sql";
+    readonly displayName = "Spark SQL";
+    isReady(): boolean;
+    initialize(): Promise<void>;
+    format(code: string, options?: FormatterOptions): FormatResult;
+    needsFormatting(code: string, options?: FormatterOptions): boolean;
+}
+/**
+ * Detect if content is SQL.
+ */
+export declare function isSqlCode(cellType: string): boolean;
+/**
+ * Get the SQL formatter instance (creates on first call).
+ */
+export declare function getSqlFormatter(): SqlFormatter;

package/dist/formatters/sparksql/sql-formatter.js

@@ -0,0 +1,56 @@
+/**
+ * SQL Formatter Wrapper
+ *
+ * Wraps the existing sparkfmt SQL formatter to implement the LanguageFormatter interface.
+ */
+import { formatSql, needsFormatting } from './index.js';
+/**
+ * SQL formatter for Spark SQL.
+ */
+export class SqlFormatter {
+    language = 'sql';
+    displayName = 'Spark SQL';
+    isReady() {
+        // SQL formatter is always ready (no async initialization)
+        return true;
+    }
+    async initialize() {
+        // No initialization needed for SQL formatter
+    }
+    format(code, options) {
+        try {
+            // Note: formatSql currently only takes one argument
+            // TODO: Add options support to formatSql in the future
+            const formatted = formatSql(code);
+            const changed = formatted !== code;
+            return { formatted, changed };
+        }
+        catch (error) {
+            return {
+                formatted: code,
+                changed: false,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    needsFormatting(code, options) {
+        return needsFormatting(code);
+    }
+}
+/**
+ * Detect if content is SQL.
+ */
+export function isSqlCode(cellType) {
+    return cellType === 'sql' || cellType === 'sparksql';
+}
+/** Singleton instance */
+let sqlFormatterInstance = null;
+/**
+ * Get the SQL formatter instance (creates on first call).
+ */
+export function getSqlFormatter() {
+    if (!sqlFormatterInstance) {
+        sqlFormatterInstance = new SqlFormatter();
+    }
+    return sqlFormatterInstance;
+}

package/dist/formatters/sparksql/token-utils.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Token Utilities - Grammar-Derived Token Detection
+ *
+ * This module provides utilities for detecting token types based on the ANTLR grammar.
+ * All detection is grammar-driven - NO hardcoded keyword lists.
+ *
+ * Key Functions:
+ * - getTokenType(): Get token type number from symbolic name
+ * - isKeywordToken(): Check if a token is a keyword (grammar-derived)
+ */
+import SqlBaseLexer from './generated/SqlBaseLexer.js';
+/**
+ * Get token type number by symbolic name.
+ * Returns -1 if the name is not found.
+ *
+ * @param name - The symbolic name (e.g., 'SELECT', 'COMMA')
+ * @returns Token type number or -1
+ */
+export declare function getTokenType(name: string): number;
+/**
+ * Get symbolic name for a token type.
+ * Returns null if no symbolic name exists.
+ *
+ * @param tokenType - The token type number
+ * @returns Symbolic name or null
+ */
+export declare function getSymbolicName(tokenType: number): string | null;
+/**
+ * Check if a token is a keyword based on grammar rules.
+ *
+ * Keywords in ANTLR are defined like: SELECT: 'SELECT';
+ * So symbolicNames[tokenType] === tokenText for keywords.
+ *
+ * IMPORTANT: Due to dual-lexing (uppercase for token types, original for text),
+ * we must be careful not to uppercase non-keywords. The tokenType comes from
+ * the uppercase stream, which may misclassify single letters (e.g., X -> BINARY_HEX).
+ *
+ * We ONLY return true if the symbolic name MATCHES the text (case-insensitive).
+ * This ensures we don't uppercase identifiers like 'x' just because X is BINARY_HEX.
+ *
+ * @param tokenType - The token type number
+ * @param tokenText - The original token text
+ * @returns true if the token is a keyword
+ */
+export declare function isKeywordToken(tokenType: number, tokenText: string): boolean;
+/**
+ * Check if a token type represents a comment.
+ *
+ * @param tokenType - The token type number
+ * @returns true if the token is a comment
+ */
+export declare function isCommentToken(tokenType: number): boolean;
+/**
+ * Check if a token type represents whitespace.
+ *
+ * @param tokenType - The token type number
+ * @returns true if the token is whitespace
+ */
+export declare function isWhitespaceToken(tokenType: number): boolean;
+/**
+ * Check if a keyword should be treated like a function (no space before paren).
+ *
+ * @param tokenType - The token type number
+ * @param tokenText - The original token text
+ * @returns true if this is a function-like keyword
+ */
+export declare function isFunctionLikeKeyword(tokenType: number, tokenText: string): boolean;
+export { SqlBaseLexer };

package/dist/formatters/sparksql/token-utils.js

@@ -0,0 +1,155 @@
+/**
+ * Token Utilities - Grammar-Derived Token Detection
+ *
+ * This module provides utilities for detecting token types based on the ANTLR grammar.
+ * All detection is grammar-driven - NO hardcoded keyword lists.
+ *
+ * Key Functions:
+ * - getTokenType(): Get token type number from symbolic name
+ * - isKeywordToken(): Check if a token is a keyword (grammar-derived)
+ */
+// @ts-ignore - Generated ANTLR code
+import SqlBaseLexer from './generated/SqlBaseLexer.js';
+// ============================================================================
+// SYMBOLIC NAME MAPPING (Built from grammar at runtime)
+// ============================================================================
+/**
+ * Map from symbolic name to token type number.
+ * Built once at module load time from the ANTLR lexer.
+ */
+const SYMBOLIC_NAME_TO_TYPE = new Map();
+// Initialize the map from lexer's symbolic names
+for (let i = 0; i < SqlBaseLexer.symbolicNames.length; i++) {
+    const name = SqlBaseLexer.symbolicNames[i];
+    if (name) {
+        SYMBOLIC_NAME_TO_TYPE.set(name, i);
+    }
+}
+// ============================================================================
+// PUBLIC API
+// ============================================================================
+/**
+ * Get token type number by symbolic name.
+ * Returns -1 if the name is not found.
+ *
+ * @param name - The symbolic name (e.g., 'SELECT', 'COMMA')
+ * @returns Token type number or -1
+ */
+export function getTokenType(name) {
+    return SYMBOLIC_NAME_TO_TYPE.get(name) ?? -1;
+}
+/**
+ * Get symbolic name for a token type.
+ * Returns null if no symbolic name exists.
+ *
+ * @param tokenType - The token type number
+ * @returns Symbolic name or null
+ */
+export function getSymbolicName(tokenType) {
+    return SqlBaseLexer.symbolicNames[tokenType] ?? null;
+}
+/**
+ * Check if a token is a keyword based on grammar rules.
+ *
+ * Keywords in ANTLR are defined like: SELECT: 'SELECT';
+ * So symbolicNames[tokenType] === tokenText for keywords.
+ *
+ * IMPORTANT: Due to dual-lexing (uppercase for token types, original for text),
+ * we must be careful not to uppercase non-keywords. The tokenType comes from
+ * the uppercase stream, which may misclassify single letters (e.g., X -> BINARY_HEX).
+ *
+ * We ONLY return true if the symbolic name MATCHES the text (case-insensitive).
+ * This ensures we don't uppercase identifiers like 'x' just because X is BINARY_HEX.
+ *
+ * @param tokenType - The token type number
+ * @param tokenText - The original token text
+ * @returns true if the token is a keyword
+ */
+export function isKeywordToken(tokenType, tokenText) {
+    const symbolicName = SqlBaseLexer.symbolicNames[tokenType];
+    if (!symbolicName)
+        return false;
+    const textUpper = tokenText.toUpperCase();
+    // Direct match: symbolic name equals uppercase text (e.g., SELECT)
+    // This is the ONLY reliable way to detect keywords with dual-lexing
+    if (symbolicName === textUpper)
+        return true;
+    // Handle token name mismatches where the symbolic name differs from the keyword text
+    // These are defined in the grammar like: PERCENTLIT: 'PERCENT';
+    // Maps: keyword text -> symbolic name
+    const tokenNameMismatches = {
+        'PERCENT': 'PERCENTLIT', // PERCENTLIT: 'PERCENT';
+        'MINUS': 'SETMINUS', // SETMINUS: 'MINUS';
+        'IDENTIFIER': 'IDENTIFIER_KW', // IDENTIFIER_KW: 'IDENTIFIER';
+    };
+    if (tokenNameMismatches[textUpper] === symbolicName) {
+        return true;
+    }
+    // Handle keyword aliases where the grammar defines multiple literals for one token.
+    // Example: TEMPORARY: 'TEMPORARY' | 'TEMP'; - when user types 'temp', tokenType is TEMPORARY
+    // Note: DEC, INT, CHAR are separate tokens in the grammar (not aliases), so they're not listed here.
+    const aliasKeywords = {
+        'TEMP': 'TEMPORARY', // TEMPORARY: 'TEMPORARY' | 'TEMP';
+        'REGEXP': 'RLIKE', // RLIKE: 'RLIKE' | 'REGEXP';
+    };
+    if (aliasKeywords[textUpper] && symbolicName === aliasKeywords[textUpper]) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Check if a token type represents a comment.
+ *
+ * @param tokenType - The token type number
+ * @returns true if the token is a comment
+ */
+export function isCommentToken(tokenType) {
+    return tokenType === SqlBaseLexer.SIMPLE_COMMENT ||
+        tokenType === SqlBaseLexer.BRACKETED_COMMENT;
+}
+/**
+ * Check if a token type represents whitespace.
+ *
+ * @param tokenType - The token type number
+ * @returns true if the token is whitespace
+ */
+export function isWhitespaceToken(tokenType) {
+    return tokenType === SqlBaseLexer.WS;
+}
+// ============================================================================
+// FUNCTION-LIKE KEYWORDS
+// ============================================================================
+/**
+ * Keywords that are used like functions: KEYWORD(args)
+ * These need special handling for spacing (no space before opening paren).
+ *
+ * Note: This is a style choice for layout, not grammar-derived.
+ * These keywords take arguments in parentheses like functions do.
+ */
+const FUNCTION_LIKE_KEYWORDS = new Set([
+    'cast', 'try_cast', 'extract', 'position', 'substring', 'trim',
+    'overlay', 'percentile_cont', 'percentile_disc', 'any_value',
+    'first_value', 'last_value', 'nth_value', 'lead', 'lag',
+    'decimal', 'array', 'map', 'struct',
+    // Type constructors
+    'varchar', 'char',
+    // Constraints
+    'unique', 'primary', 'foreign', 'check',
+    // Hive streaming (SELECT TRANSFORM(...) USING ...)
+    'transform',
+    // DDL (CREATE FUNCTION name(...))
+    'function'
+]);
+/**
+ * Check if a keyword should be treated like a function (no space before paren).
+ *
+ * @param tokenType - The token type number
+ * @param tokenText - The original token text
+ * @returns true if this is a function-like keyword
+ */
+export function isFunctionLikeKeyword(tokenType, tokenText) {
+    return isKeywordToken(tokenType, tokenText) &&
+        FUNCTION_LIKE_KEYWORDS.has(tokenText.toLowerCase());
+}
+// Re-export the lexer for use in other modules
+export { SqlBaseLexer };

package/dist/formatters/sparksql/types.d.ts

@@ -0,0 +1,264 @@
+/**
+ * Type Definitions for Spark SQL Formatter
+ *
+ * Central location for all TypeScript interfaces used across the formatter.
+ * This improves code readability and enables better IDE support.
+ */
+/**
+ * Information about a multi-argument function that may need line-width expansion.
+ */
+export interface MultiArgFunctionInfo {
+    closeParenIndex: number;
+    commaIndices: number[];
+    spanLength: number;
+    functionName?: string;
+    charStart: number;
+}
+/**
+ * Nested function position info for expansion checking.
+ */
+export interface NestedFunctionInfo {
+    funcIdx: number;
+    relativeOffset: number;
+}
+/**
+ * Information about a window definition that may need line-width expansion.
+ */
+export interface WindowDefInfo {
+    closeParenIndex: number;
+    orderByTokenIndex: number | null;
+    windowFrameTokenIndex: number | null;
+    spanLength: number;
+    nestedFunctions: NestedFunctionInfo[];
+}
+/**
+ * Information about a PIVOT/UNPIVOT clause that may need expansion.
+ */
+export interface PivotInfo {
+    /** Opening LEFT_PAREN token index */
+    openParenIndex: number;
+    /** Closing RIGHT_PAREN token index */
+    closeParenIndex: number;
+    /** Comma indices in the aggregates list (before FOR) */
+    aggregateCommaIndices: number[];
+    /** FOR keyword token index */
+    forKeywordIndex: number | null;
+    /** IN keyword token index */
+    inKeywordIndex: number | null;
+    /** Comma indices in the IN list */
+    inListCommaIndices: number[];
+    /** Total span length for line width calculation */
+    spanLength: number;
+    /** Whether this is UNPIVOT (vs PIVOT) */
+    isUnpivot: boolean;
+}
+/**
+ * Information about an IN list (WHERE IN or PIVOT IN) for wrapping.
+ */
+export interface InListInfo {
+    /** Opening LEFT_PAREN token index (after IN keyword) */
+    openParenIndex: number;
+    /** Closing RIGHT_PAREN token index */
+    closeParenIndex: number;
+    /** Comma indices in the IN list */
+    commaIndices: number[];
+    /** Whether this is inside a PIVOT clause */
+    isInPivot: boolean;
+}
+/**
+ * Information about a simple query that can stay compact (on one line).
+ * A query is simple if it has single-item clauses and fits within line width.
+ */
+export interface SimpleQueryInfo {
+    /** Token index of the SELECT keyword */
+    selectTokenIndex: number;
+    /** Total span length of the entire query */
+    spanLength: number;
+    /** Subquery depth (0 = main query) */
+    depth: number;
+}
+/**
+ * Complete result from ParseTreeAnalyzer.
+ * Contains all token positions that need special handling during formatting.
+ */
+export interface AnalyzerResult {
+    identifierTokens: Set<number>;
+    functionCallTokens: Set<number>;
+    clauseStartTokens: Set<number>;
+    qualifiedNameTokens: Set<number>;
+    listItemCommas: Set<number>;
+    listFirstItems: Set<number>;
+    multiItemClauses: Set<number>;
+    conditionOperators: Set<number>;
+    multilineConditionClauses: Set<number>;
+    betweenAndTokens: Set<number>;
+    tokenDepthMap: Map<number, number>;
+    subqueryOpenParens: Set<number>;
+    subqueryCloseParens: Set<number>;
+    setOperandParens: Set<number>;
+    aliasInsertPositions: Set<number>;
+    tableAliasAsTokens: Set<number>;
+    joinOnTokens: Set<number>;
+    cteCommas: Set<number>;
+    cteMainSelectTokens: Set<number>;
+    ddlColumnCommas: Set<number>;
+    ddlOpenParens: Set<number>;
+    ddlCloseParens: Set<number>;
+    ddlFirstColumn: Set<number>;
+    ddlMultiColumn: Set<number>;
+    valuesCommas: Set<number>;
+    valuesHasTuples: boolean;
+    setClauseCommas: Set<number>;
+    setKeywordToken: number;
+    multiWhenCaseTokens: Set<number>;
+    caseWhenTokens: Set<number>;
+    caseElseTokens: Set<number>;
+    caseEndTokens: Set<number>;
+    simpleCaseTokens: Set<number>;
+    simpleCaseValueEndTokens: Set<number>;
+    groupingAnalyticsParens: Set<number>;
+    exceptClauseTokens: Set<number>;
+    setConfigTokens: Set<number>;
+    mergeUsingTokens: Set<number>;
+    mergeOnTokens: Set<number>;
+    mergeWhenTokens: Set<number>;
+    lateralViewCommas: Set<number>;
+    groupByAllTokens: Set<number>;
+    multiArgFunctionInfo: Map<number, MultiArgFunctionInfo>;
+    windowDefInfo: Map<number, WindowDefInfo>;
+    pivotInfo: Map<number, PivotInfo>;
+    inListInfo: Map<number, InListInfo>;
+    simpleQueries: Map<number, SimpleQueryInfo>;
+}
+/**
+ * Tracks the current state during token formatting.
+ * Used to determine spacing, newlines, and indentation.
+ */
+export interface FormattingState {
+    subqueryDepth: number;
+    ddlDepth: number;
+    caseDepth: number;
+    insideParens: number;
+    insideFunctionArgs: number;
+    complexTypeDepth: number;
+    currentColumn: number;
+    isFirstNonWsToken: boolean;
+    afterSelectKeyword: boolean;
+    afterGroupByKeyword: boolean;
+    afterOrderByKeyword: boolean;
+    afterWhereKeyword: boolean;
+    afterHavingKeyword: boolean;
+    afterSetKeyword: boolean;
+    afterValuesKeyword: boolean;
+    currentClauseIsMultiItem: boolean;
+    isFirstListItem: boolean;
+    justOutputCommaFirstStyle: boolean;
+    prevWasFunctionName: boolean;
+    prevWasBuiltInFunctionKeyword: boolean;
+    prevTokenText: string;
+    prevTokenType: number;
+    prevTokenWasUnaryOperator: boolean;
+    insideHint: boolean;
+    hintContent: string[];
+    justOutputMultiArgFunctionNewline: boolean;
+    justOutputWindowNewline: boolean;
+    justOutputPivotNewline: boolean;
+    /** Current column where IN list content started (after open paren) */
+    inListContentStartColumn: number | null;
+    /** Whether we're currently inside an IN list */
+    insideInList: boolean;
+    /** Just output an IN list wrap newline - skip space before next token */
+    justOutputInListWrapNewline: boolean;
+    /** Stack of compact query state per subquery level */
+    compactQueryStack: Array<{
+        isCompact: boolean;
+        depth: number;
+    }>;
+}
+/**
+ * Represents an expanded multi-arg function on the stack.
+ */
+export interface ExpandedFunction {
+    closeParenIndex: number;
+    commaIndices: Set<number>;
+    depth: number;
+    openingColumn: number;
+    firstArgIsChainedFunc: boolean;
+    functionName?: string;
+    /** For STACK: indices of commas that should NOT get newlines (every other comma) */
+    skipNewlineCommas?: Set<number>;
+}
+/**
+ * Represents an expanded window definition.
+ */
+export interface ExpandedWindow {
+    closeParenIndex: number;
+    orderByTokenIndex: number | null;
+    windowFrameTokenIndex: number | null;
+    baseDepth: number;
+}
+/**
+ * Represents an expanded PIVOT/UNPIVOT clause.
+ */
+export interface ExpandedPivot {
+    closeParenIndex: number;
+    /** Commas in aggregate list */
+    aggregateCommaIndices: Set<number>;
+    /** FOR keyword index */
+    forKeywordIndex: number | null;
+    /** IN keyword index */
+    inKeywordIndex: number | null;
+    /** Commas in IN list */
+    inListCommaIndices: Set<number>;
+    /** Depth for indentation */
+    depth: number;
+    /** Column where PIVOT started */
+    openingColumn: number;
+}
+/**
+ * Represents a pending comment to be output.
+ */
+export interface PendingComment {
+    text: string;
+    type: number;
+    wasOnOwnLine: boolean;
+    /** True if there was a blank line before this comment (for preserving paragraph breaks) */
+    hadBlankLineBefore: boolean;
+}
+/**
+ * Context information for a single token during formatting.
+ */
+export interface TokenContext {
+    tokenIndex: number;
+    tokenType: number;
+    text: string;
+    symbolicName: string | null;
+    isInIdentifierContext: boolean;
+    isFunctionCall: boolean;
+    isClauseStart: boolean;
+    isListComma: boolean;
+    isConditionOperator: boolean;
+    isBetweenAnd: boolean;
+    isJoinOn: boolean;
+    isSubqueryOpenParen: boolean;
+    isSubqueryCloseParen: boolean;
+    isSetOperandParen: boolean;
+    isCteComma: boolean;
+    isDdlComma: boolean;
+    isDdlOpenParen: boolean;
+    isDdlCloseParen: boolean;
+    isDdlMultiColumn: boolean;
+    isValuesComma: boolean;
+    isSetComma: boolean;
+    isSetKeyword: boolean;
+    isLateralViewComma: boolean;
+    isMultiWhenCase: boolean;
+    isCaseWhen: boolean;
+    isCaseElse: boolean;
+    isCaseEnd: boolean;
+    isMergeUsing: boolean;
+    isMergeOn: boolean;
+    isMergeWhen: boolean;
+    multiArgFuncInfo: MultiArgFunctionInfo | undefined;
+    windowDefInfo: WindowDefInfo | undefined;
+}

package/dist/formatters/sparksql/types.js

@@ -0,0 +1,7 @@
+/**
+ * Type Definitions for Spark SQL Formatter
+ *
+ * Central location for all TypeScript interfaces used across the formatter.
+ * This improves code readability and enables better IDE support.
+ */
+export {};

package/dist/formatters/types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Formatter Types
+ *
+ * Common interfaces for language formatters.
+ * Designed to be extensible for future language support.
+ */
+/** Options that can be passed to any formatter */
+export interface FormatterOptions {
+    /** Maximum line width (default: 140) */
+    lineWidth?: number;
+    /** Additional offset to subtract from line width (e.g., for MAGIC prefixes) */
+    lineWidthOffset?: number;
+    /** Suppress multiline expansion (noqa:expansion) */
+    suppressExpansion?: boolean;
+}
+/** Result of a format operation */
+export interface FormatResult {
+    /** The formatted code */
+    formatted: string;
+    /** Whether the code was changed */
+    changed: boolean;
+    /** Any errors that occurred (null = success) */
+    error?: string;
+}
+/** Common interface for all language formatters */
+export interface LanguageFormatter {
+    /** Language identifier (e.g., 'sql', 'python', 'scala') */
+    readonly language: string;
+    /** Human-readable name */
+    readonly displayName: string;
+    /** Whether the formatter is initialized and ready */
+    isReady(): boolean;
+    /** Initialize the formatter (load WASM, etc.) */
+    initialize(): Promise<void>;
+    /** Format code with optional options */
+    format(code: string, options?: FormatterOptions): FormatResult;
+    /** Check if code needs formatting without modifying it */
+    needsFormatting(code: string, options?: FormatterOptions): boolean;
+}
+/** Configuration for a language formatter */
+export interface FormatterConfig {
+    /** Whether this formatter is enabled */
+    enabled: boolean;
+    /** Formatter-specific options */
+    options: Record<string, unknown>;
+}
+/** Registry of all available formatters */
+export interface FormatterRegistry {
+    /** Get a formatter by language identifier */
+    get(language: string): LanguageFormatter | undefined;
+    /** Register a new formatter */
+    register(formatter: LanguageFormatter): void;
+    /** List all registered language identifiers */
+    languages(): string[];
+    /** Initialize all formatters */
+    initializeAll(): Promise<void>;
+}

package/dist/formatters/types.js

@@ -0,0 +1,7 @@
+/**
+ * Formatter Types
+ *
+ * Common interfaces for language formatters.
+ * Designed to be extensible for future language support.
+ */
+export {};

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * sparkfmt - Spark SQL & Python Formatter
+ *
+ * A unified formatter for Spark SQL and Python code, designed for
+ * Microsoft Fabric notebooks and CI/CD pipelines.
+ *
+ * Architecture:
+ * - formatters/sql/: Core SQL formatting (ANTLR grammar-driven)
+ * - formatters/python/: Python formatting via Ruff WASM
+ * - notebook-formatter.ts: Fabric notebook handling
+ */
+export { formatSql, needsFormatting } from './formatters/sparksql/index.js';
+export { getFormatterRegistry, detectLanguage, SqlFormatter, getSqlFormatter, isSqlCode, PythonFormatter, getPythonFormatter, isPythonCode, type LanguageFormatter, type FormatterOptions, type FormatResult, type FormatterConfig, type FormatterRegistry, } from './formatters/index.js';
+export { formatCell, formatCellSync, initializePythonFormatter, isPythonFormatterReady, type FormatCellResult, type CellType, } from './cell-formatter.js';
+export { parseNotebook, formatNotebook, type NotebookCell, type FabricNotebook, type FormatStats, } from './notebook-formatter.js';
+export { DEFAULT_RUFF_CONFIG, RUFF_WASM_CONFIG, type RuffConfig, type RuffFormatConfig, type WasmInitOptions, } from './formatters/python/index.js';
+export { hasFormatOff, detectCollapseDirectives, hasCollapseDirective, type FormatDirectiveInfo } from './formatters/sparksql/index.js';
+export type { AnalyzerResult, FormattingState, MultiArgFunctionInfo, WindowDefInfo, TokenContext, PendingComment, ExpandedFunction, ExpandedWindow } from './formatters/sparksql/types.js';