@gmickel/gno 1.46.0 → 2.0.0

package/vendor/converters/officeparser/dist/cli.js

@@ -0,0 +1,381 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * officeparser CLI
+ *
+ * Allows running officeparser from the command line:
+ *   npx officeparser file.docx
+ *   officeparser file.docx --to=text
+ *   officeparser file.docx --ocr --extractAttachments
+ *
+ * Options (--key=value, --key value, or bare flags):
+ *   --to=json|text|md|html|csv|rtf|pdf|epub|chunks  Convert AST to specified format (default: json)
+ *   --output=path             Save result to a file
+ *   --fileType=docx|xlsx|...  Override file type detection
+ *   --ocr                     Enable OCR for images (default: false)
+ *   --ocrConfig.language=eng  OCR language (default: eng)
+ *   --extractAttachments      Extract embedded attachments (default: false)
+ *   --ignoreNotes             Ignore footnotes/endnotes/speaker notes (default: false)
+ *   --ignoreComments          Ignore inline comments (default: false)
+ *   --ignoreHeadersAndFooters Ignore headers and footers (default: false)
+ *   --ignoreSlideMasters      Ignore slide masters (default: false)
+ *   --ignoreInternalLinks     Ignore internal links (default: false)
+ *   --includeRawContent       Include raw content in AST (default: false)
+ *   --serializeRawContent     Include stringified XML in metadata (default: true)
+ *   --preserveXmlWhitespace   Keep raw formatting space (default: false)
+ *   --includeBreakNodes       Include break nodes (DOCX only, default: false)
+ *   --verbose                 Show full error stack traces and warning logs
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const OfficeParser_js_1 = require("./OfficeParser.js");
+const OfficeGenerator_js_1 = require("./OfficeGenerator.js");
+const fs = __importStar(require("fs"));
+const args = process.argv.slice(2);
+let fileArg;
+let showHelp = false;
+let toFlagOption;
+let formatFlagOption;
+let toTextOption;
+let verbose = false;
+let outputFile;
+// Parser and Generator configuration objects that will be populated by command line options.
+const config = {};
+const generatorConfig = {};
+// Known boolean configurations to validate user input against.
+const knownParserBooleans = new Set([
+    'ocr', 'extractAttachments', 'ignoreNotes', 'ignoreComments',
+    'ignoreHeadersAndFooters', 'ignoreSlideMasters', 'ignoreInternalLinks',
+    'includeRawContent', 'serializeRawContent', 'preserveXmlWhitespace', 'includeBreakNodes'
+]);
+const knownGeneratorBooleans = new Set([
+    'includeFormatting', 'generateIds', 'renderMetadata', 'includeImages', 'includeCharts', 'ignoreInternalLinks'
+]);
+// Prefixes used to identify configurations targeted for the generator instead of the parser.
+const generatorPrefixes = [
+    'generatorConfig.', 'htmlConfig.', 'csvConfig.', 'textConfig.', 'mdConfig.', 'pdfConfig.', 'rtfConfig.', 'chunksConfig.'
+];
+// Trackers to detect if deprecated/legacy options were used to log helpful warnings.
+let usedFormat = false;
+let usedToText = false;
+let usedOcrLanguage = false;
+let usedPutNotesAtLast = false;
+let usedOutputErrorToConsole = false;
+// Parse the arguments list
+for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    // Help flags trigger immediate termination of parsing and print help
+    if (arg === '-h' || arg === '--help') {
+        showHelp = true;
+        break;
+    }
+    if (arg.startsWith('--')) {
+        let cleanKey;
+        let val;
+        // Support --key=value syntax
+        if (arg.includes('=')) {
+            const idx = arg.indexOf('=');
+            cleanKey = arg.slice(2, idx);
+            val = arg.slice(idx + 1);
+        }
+        // Support negation shorthand: --no-ocr sets ocr to false
+        else if (arg.startsWith('--no-')) {
+            cleanKey = arg.slice(5);
+            val = 'false';
+        }
+        // Support space-separated options or bare flags
+        else {
+            cleanKey = arg.slice(2);
+            const isKnownBoolean = knownParserBooleans.has(cleanKey) ||
+                knownGeneratorBooleans.has(cleanKey) ||
+                cleanKey === 'verbose' ||
+                cleanKey === 'toText' ||
+                cleanKey === 'outputErrorToConsole';
+            const isNextBool = i + 1 < args.length &&
+                (args[i + 1].toLowerCase() === 'true' || args[i + 1].toLowerCase() === 'false');
+            // If the next arg is not another option flag, treat it as the value (e.g., --to html)
+            // But if this is a known boolean, only consume the next argument if it is a valid boolean string.
+            if (i + 1 < args.length && !args[i + 1].startsWith('-') && (!isKnownBoolean || isNextBool)) {
+                val = args[i + 1];
+                i++;
+            }
+            // Bare presence implies true (e.g., --ocr is true)
+            else {
+                val = 'true';
+            }
+        }
+        // Parse boolean strings to raw boolean types
+        const lowerValue = val.toLowerCase();
+        const boolValue = lowerValue === 'true' ? true : (lowerValue === 'false' ? false : undefined);
+        // Map core CLI options to variables
+        if (cleanKey === 'to') {
+            toFlagOption = val;
+        }
+        else if (cleanKey === 'format') {
+            formatFlagOption = val;
+            usedFormat = true;
+        }
+        else if (cleanKey === 'output') {
+            outputFile = val;
+        }
+        else if (cleanKey === 'toText') {
+            toTextOption = boolValue !== undefined ? boolValue : true;
+            usedToText = true;
+        }
+        else if (cleanKey === 'verbose') {
+            verbose = boolValue !== undefined ? boolValue : true;
+        }
+        else if (cleanKey === 'ocrLanguage') {
+            config.ocrLanguage = val;
+            usedOcrLanguage = true;
+        }
+        else if (cleanKey === 'putNotesAtLast') {
+            config.putNotesAtLast = boolValue !== undefined ? boolValue : true;
+            usedPutNotesAtLast = true;
+        }
+        else if (cleanKey === 'outputErrorToConsole') {
+            verbose = boolValue !== undefined ? boolValue : true;
+            usedOutputErrorToConsole = true;
+        }
+        else {
+            // Check if the flag belongs to generatorConfig or a specific sub-generator (e.g., htmlConfig)
+            const isGeneratorOption = knownGeneratorBooleans.has(cleanKey) || generatorPrefixes.some(pref => cleanKey.startsWith(pref));
+            const target = isGeneratorOption ? generatorConfig : config;
+            let path = cleanKey;
+            // Strip generatorConfig prefix to flatten it onto the generatorConfig object
+            if (isGeneratorOption && cleanKey.startsWith('generatorConfig.')) {
+                path = cleanKey.slice('generatorConfig.'.length);
+            }
+            // Support nested dot-notation parsing (e.g., --ocrConfig.language=fra)
+            if (path.includes('.')) {
+                const parts = path.split('.');
+                let current = target;
+                for (let j = 0; j < parts.length - 1; j++) {
+                    const part = parts[j];
+                    if (!current[part])
+                        current[part] = {};
+                    current = current[part];
+                }
+                const lastPart = parts[parts.length - 1];
+                current[lastPart] = boolValue !== undefined ? boolValue : val;
+            }
+            // Flat key assignment
+            else {
+                if (boolValue !== undefined) {
+                    target[path] = boolValue;
+                }
+                else if (knownParserBooleans.has(path) || (isGeneratorOption && knownGeneratorBooleans.has(path))) {
+                    console.warn(`Invalid boolean value for --${cleanKey}: ${val}. Using default.`);
+                }
+                else {
+                    target[path] = val;
+                }
+            }
+        }
+    }
+    else {
+        // First positional argument that is not a flag is treated as the input file path
+        if (!fileArg) {
+            fileArg = arg;
+        }
+    }
+}
+if (fileArg && !showHelp) {
+    // Resolve output format prioritizing: --to > --format > --toText
+    let outputFormat;
+    if (toFlagOption) {
+        outputFormat = toFlagOption;
+    }
+    else if (formatFlagOption) {
+        outputFormat = formatFlagOption;
+    }
+    else if (toTextOption === true) {
+        outputFormat = 'text';
+    }
+    // Display warning messages for any deprecated CLI options used
+    if (usedFormat) {
+        console.warn('Warning: --format is deprecated. Use --to instead.');
+    }
+    if (usedToText) {
+        console.warn('Warning: --toText is deprecated. Use --to=text instead.');
+    }
+    if (usedOcrLanguage) {
+        console.warn('Warning: --ocrLanguage is deprecated. Use --ocrConfig.language instead.');
+    }
+    if (usedPutNotesAtLast) {
+        console.warn('Warning: --putNotesAtLast is deprecated and will be ignored by all parsers.');
+    }
+    if (usedOutputErrorToConsole) {
+        console.warn('Warning: --outputErrorToConsole is deprecated. Use --verbose instead.');
+    }
+    // Intercept parser warning callbacks to format and print issues when verbose is enabled
+    const originalOnWarning = config.onWarning;
+    config.onWarning = (issue) => {
+        if (verbose) {
+            const severity = issue.type === 'error' ? 'Error' : 'Warning';
+            console.error(`[OfficeParser ${severity}] [${issue.code}]: ${issue.message}`);
+            if (issue.details) {
+                console.error(issue.details);
+            }
+        }
+        if (originalOnWarning)
+            originalOnWarning(issue);
+    };
+    // Propagate newlineDelimiter and csvDelimiter if configured flatly but not in generator sub-configs
+    if (config.newlineDelimiter !== undefined) {
+        if (!generatorConfig.textConfig)
+            generatorConfig.textConfig = {};
+        if (generatorConfig.textConfig.newlineDelimiter === undefined) {
+            generatorConfig.textConfig.newlineDelimiter = config.newlineDelimiter;
+        }
+    }
+    if (config.csvDelimiter !== undefined) {
+        if (!generatorConfig.csvConfig)
+            generatorConfig.csvConfig = {};
+        if (generatorConfig.csvConfig.columnDelimiter === undefined) {
+            generatorConfig.csvConfig.columnDelimiter = config.csvDelimiter;
+        }
+    }
+    // Run the main parser
+    OfficeParser_js_1.OfficeParser.parseOffice(fileArg, config)
+        .then(async (ast) => {
+        let output;
+        // Generate JSON output or convert AST using OfficeGenerator
+        if (outputFormat === 'json') {
+            output = JSON.stringify(ast, null, 2);
+        }
+        else if (outputFormat) {
+            const result = await OfficeGenerator_js_1.OfficeGenerator.generate(ast, outputFormat, generatorConfig);
+            if (Array.isArray(result.value)) {
+                output = JSON.stringify(result.value, null, 2);
+            }
+            else {
+                output = result.value;
+            }
+        }
+        else {
+            output = JSON.stringify(ast, null, 2);
+        }
+        // Write generated output to output file or print to standard output
+        if (outputFile) {
+            if (output instanceof Uint8Array) {
+                fs.writeFileSync(outputFile, output);
+            }
+            else {
+                fs.writeFileSync(outputFile, output, 'utf8');
+            }
+            if (verbose)
+                console.log(`Output written to ${outputFile}`);
+        }
+        else {
+            if (output instanceof Uint8Array) {
+                process.stdout.write(output);
+            }
+            else {
+                process.stdout.write(output + '\n');
+            }
+        }
+        // Ensure OCR workers are terminated for clean CLI exit
+        if (config.ocr) {
+            await OfficeParser_js_1.OfficeParser.terminateOcr();
+        }
+    })
+        .catch(async (err) => {
+        // Handle and display parsing error messages
+        console.error(`Error parsing file "${fileArg}":`);
+        if (verbose) {
+            console.error(err);
+        }
+        else {
+            console.error(err.message || err);
+            console.error('Use --verbose for full stack trace.');
+        }
+        // Ensure OCR workers are terminated even on error to prevent process hang
+        if (config.ocr) {
+            await OfficeParser_js_1.OfficeParser.terminateOcr();
+        }
+        process.exit(1);
+    });
+}
+else {
+    console.log('Usage: officeparser <file> [options]');
+    console.log('');
+    console.log('Options:');
+    console.log('  --to=json|text|md|html|pdf|csv|rtf|epub|chunks  Target conversion format (default: json)');
+    console.log('  --output=file.ext                           Save output to file instead of stdout');
+    console.log('  --fileType=docx|xlsx|pptx|odt|...           Explicitly override input file type detection');
+    console.log('  --ocr                                       Enable OCR for images (default: false)');
+    console.log('  --ocrConfig.language=eng                    OCR language (default: eng)');
+    console.log('  --extractAttachments                        Extract embedded attachments (default: false)');
+    console.log('  --ignoreNotes                               Ignore footnotes/endnotes/speaker notes (default: false)');
+    console.log('  --ignoreComments                            Ignore inline comments (default: false)');
+    console.log('  --ignoreHeadersAndFooters                   Ignore headers and footers (default: false)');
+    console.log('  --ignoreSlideMasters                        Ignore slide masters (default: false)');
+    console.log('  --ignoreInternalLinks                       Ignore internal links (default: false)');
+    console.log('  --includeRawContent                         Include raw content in AST (default: false)');
+    console.log('  --serializeRawContent                       Serialize raw XML content (default: true)');
+    console.log('  --preserveXmlWhitespace                     Keep raw formatting space (default: false)');
+    console.log('  --includeBreakNodes                         Include break nodes (DOCX only, default: false)');
+    console.log('  --verbose                                   Show full error stack traces and warning logs');
+    console.log('  --newlineDelimiter=string                   Delimiter string between blocks/lines (default: \\n)');
+    console.log('  --csvDelimiter=char                         Custom CSV delimiter (default: ,)');
+    console.log('  --htmlParserConfig.preserveIframes          Keep non-YouTube <iframe> embeds (dropped by default)');
+    console.log('');
+    console.log('High-Value Generator Options:');
+    console.log('  --includeFormatting                         Include font formatting like bold/italic (default: true)');
+    console.log('  --renderMetadata                            Render metadata in output content (default: false)');
+    console.log('  --htmlConfig.containerWidth=value           HTML container width (auto | px | % | vw etc., default: auto)');
+    console.log('  --htmlConfig.sourceAttributes               Carry each rich node\'s source in a data-* attribute (default: false)');
+    console.log('');
+    console.log('Advanced Nested Config Examples:');
+    console.log('  --pdfConfig.format=Letter                   Configure Puppeteer PDF format (A4 | Letter | Legal etc.)');
+    console.log('  --chunksConfig.strategy=fixed-size          Chunking strategy (fixed-size | document-structure | semantic)');
+    console.log('  --mdConfig.dialect=github                   Markdown dialect (extended | github | gitlab | obsidian | pandoc | commonmark)');
+    console.log('  --mdConfig.fallbackToHtml=false              Disable HTML fallback for unsupported Markdown features (default: true)');
+    console.log('  --mdConfig.fallbackToHtml.inlineFormatting   Round-trip inline color/highlight/font-size as <span style> (opt-in, default: false)');
+    console.log('');
+    console.log('Format Syntax:');
+    console.log('  Flags can be written as --flag (presence implies true), --no-flag (negation),');
+    console.log('  --flag=value, or --flag value.');
+    console.log('');
+    console.log('Examples:');
+    console.log('  officeparser document.docx');
+    console.log('  officeparser document.docx --to html --output doc.html');
+    console.log('  officeparser document.docx --to md');
+    console.log('  officeparser report.pdf --ocr --ocrConfig.language eng --to text');
+    console.log('  officeparser data.xlsx --to csv --output data.csv --csvDelimiter ";"');
+    console.log('  officeparser document.docx --extractAttachments --to epub --output document.epub');
+    console.log('  officeparser image_doc --fileType docx --to json');
+}

package/vendor/converters/officeparser/dist/defaults.d.ts

@@ -0,0 +1,41 @@
+import { DeepRequired, DocumentStructureChunkingConfig, FixedSizeChunkingConfig, FullGeneratorConfig, OfficeParserConfig, SemanticChunkingConfig } from './types.js';
+/**
+ * The default regex used for identifying sentence boundaries.
+ * When this default is used, the generator employs a high-fidelity "robust"
+ * segmenter that accounts for common abbreviations (Mr., Dr., etc.).
+ */
+export declare const DEFAULT_SENTENCE_BOUNDARY_REGEX: RegExp;
+/**
+ * Common abbreviations that should not trigger a sentence split when followed by a period.
+ */
+export declare const DEFAULT_ABBREVIATIONS: string[];
+/**
+ * Default configuration for the OfficeParser.
+ */
+export declare const DEFAULT_OFFICE_PARSER_CONFIG: DeepRequired<OfficeParserConfig>;
+/**
+ * Default configuration for Fixed-Size chunking.
+ */
+export declare const DEFAULT_FIXED_SIZE_CHUNKING_CONFIG: Required<Omit<FixedSizeChunkingConfig, 'embeddingFunction' | 'sentenceBoundaryRegex' | 'abbreviations'>> & {
+    sentenceBoundaryRegex: string | RegExp;
+    abbreviations: string[];
+};
+/**
+ * Default configuration for Document-Structure chunking.
+ */
+export declare const DEFAULT_DOCUMENT_STRUCTURE_CHUNKING_CONFIG: Required<Omit<DocumentStructureChunkingConfig, 'sentenceBoundaryRegex' | 'abbreviations'>> & {
+    sentenceBoundaryRegex: string | RegExp;
+    abbreviations: string[];
+};
+/**
+ * Default configuration for Semantic chunking.
+ * Note: `embeddingFunction` has no meaningful default and must be provided by the user.
+ */
+export declare const DEFAULT_SEMANTIC_CHUNKING_CONFIG: Required<Omit<SemanticChunkingConfig, 'embeddingFunction' | 'sentenceBoundaryRegex' | 'abbreviations'>> & {
+    sentenceBoundaryRegex: string | RegExp;
+    abbreviations: string[];
+};
+/**
+ * Default configuration for the OfficeGenerator.
+ */
+export declare const DEFAULT_GENERATOR_CONFIG: FullGeneratorConfig;

package/vendor/converters/officeparser/dist/defaults.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_GENERATOR_CONFIG = exports.DEFAULT_SEMANTIC_CHUNKING_CONFIG = exports.DEFAULT_DOCUMENT_STRUCTURE_CHUNKING_CONFIG = exports.DEFAULT_FIXED_SIZE_CHUNKING_CONFIG = exports.DEFAULT_OFFICE_PARSER_CONFIG = exports.DEFAULT_ABBREVIATIONS = exports.DEFAULT_SENTENCE_BOUNDARY_REGEX = void 0;
+const PDFJS_VERSION = '6.1.200';
+const DEFAULT_PDF_WORKER_SRC = typeof __SLIM__ !== 'undefined' && __SLIM__ ? '' : `https://cdn.jsdelivr.net/npm/pdfjs-dist@${PDFJS_VERSION}/build/pdf.worker.min.mjs`;
+/**
+ * The default regex used for identifying sentence boundaries.
+ * When this default is used, the generator employs a high-fidelity "robust"
+ * segmenter that accounts for common abbreviations (Mr., Dr., etc.).
+ */
+exports.DEFAULT_SENTENCE_BOUNDARY_REGEX = /[.!?。！？]/;
+/**
+ * Common abbreviations that should not trigger a sentence split when followed by a period.
+ */
+exports.DEFAULT_ABBREVIATIONS = ['Mr', 'Dr', 'Ms', 'Inc', 'Ltd', 'Prof', 'Sr', 'Jr', 'vs', 'etc'];
+/** Default timeout values for OCR */
+const DEFAULT_OCR_TIMEOUT = {
+    autoTerminate: 10000,
+    workerLoad: 60000,
+    recognition: 30000,
+};
+/**
+ * Default configuration for OCR.
+ */
+const DEFAULT_OCR_CONFIG = {
+    language: 'eng',
+    workerPath: '',
+    corePath: '',
+    langPath: '',
+    // Preferred: consolidated timeout object.  New code should always read from here.
+    timeout: DEFAULT_OCR_TIMEOUT,
+    // Kept for backward compatibility.  When timeout.autoTerminate is set (as above),
+    // the ocrUtils resolution logic will prefer timeout.autoTerminate over this flat field.
+    autoTerminateTimeout: DEFAULT_OCR_TIMEOUT.autoTerminate,
+    abortSignal: null,
+};
+/**
+ * Default configuration for HTML/XHTML parsing. `preserveAttributes` is off so that the AST is
+ * byte-identical to previous releases unless a caller opts in - see `HtmlParserConfig`.
+ */
+const DEFAULT_HTML_PARSER_CONFIG = {
+    preserveAttributes: false,
+    preserveIframes: false,
+    embedFolkForms: false,
+};
+/**
+ * Default configuration for the OfficeParser.
+ */
+exports.DEFAULT_OFFICE_PARSER_CONFIG = {
+    outputErrorToConsole: false,
+    onWarning: () => { },
+    newlineDelimiter: '\n',
+    ignoreNotes: false,
+    ignoreComments: false,
+    ignoreHeadersAndFooters: false,
+    ignoreSlideMasters: false,
+    putNotesAtLast: false,
+    extractAttachments: false,
+    includeRawContent: false,
+    ocr: false,
+    ocrLanguage: 'eng',
+    ocrConfig: DEFAULT_OCR_CONFIG,
+    abortSignal: null,
+    serializeRawContent: true,
+    preserveXmlWhitespace: false,
+    pdfWorkerSrc: DEFAULT_PDF_WORKER_SRC,
+    includeBreakNodes: false,
+    ignoreInternalLinks: false,
+    fileType: null,
+    csvDelimiter: ',',
+    decompressionLimits: {
+        maxUncompressedBytes: 512 * 1024 * 1024,
+        maxZipEntries: 10000,
+        maxTableCells: 1000000,
+    },
+    htmlParserConfig: DEFAULT_HTML_PARSER_CONFIG,
+};
+/**
+ * Default configuration for HTML generation.
+ */
+const DEFAULT_HTML_GENERATOR_CONFIG = {
+    standalone: true,
+    chartJsSrc: typeof __SLIM__ !== 'undefined' && __SLIM__ ? '' : 'https://cdn.jsdelivr.net/npm/chart.js',
+    containerWidth: 'auto',
+    customCss: '',
+    injections: {
+        headStart: '',
+        headEnd: '',
+        bodyStart: '',
+        bodyEnd: '',
+    },
+    sourceAttributes: false,
+    gatedEmbeds: false,
+};
+/**
+ * Default configuration for PDF generation.
+ */
+const DEFAULT_PDF_GENERATOR_CONFIG = {
+    format: 'A4',
+    width: '',
+    height: '',
+    landscape: false,
+    printBackground: true,
+    scale: 1,
+    margin: {
+        top: 0,
+        right: 0,
+        bottom: 0,
+        left: 0
+    },
+    displayHeaderFooter: false,
+    headerTemplate: '',
+    footerTemplate: '',
+    launchOptions: {
+        headless: true,
+        args: ['--no-sandbox', '--disable-setuid-sandbox']
+    },
+    timeout: 30000,
+};
+/**
+ * Default configuration for CSV generation.
+ */
+const DEFAULT_CSV_GENERATOR_CONFIG = {
+    sheets: '',
+    mergeSheets: true,
+    columnDelimiter: ',',
+};
+/**
+ * Default configuration for Markdown generation.
+ */
+const DEFAULT_MD_GENERATOR_CONFIG = {
+    fallbackToHtml: true,
+    dialect: 'extended',
+};
+/**
+ * Default configuration for plain text generation.
+ */
+const DEFAULT_TEXT_GENERATOR_CONFIG = {
+    newlineDelimiter: '\n',
+    preserveLayout: true,
+    renderNotes: true,
+};
+/**
+ * Default configuration for Fixed-Size chunking.
+ */
+exports.DEFAULT_FIXED_SIZE_CHUNKING_CONFIG = {
+    strategy: 'fixed-size',
+    chunkSize: 1000,
+    chunkOverlap: 200,
+    separators: ['\n\n', '\n', ' ', ''],
+    stripWhitespace: true,
+    includeMetadata: true,
+    addStartIndex: false,
+    lengthFunction: (text) => text.length,
+    sentenceBoundaryRegex: exports.DEFAULT_SENTENCE_BOUNDARY_REGEX,
+    abbreviations: exports.DEFAULT_ABBREVIATIONS,
+};
+/**
+ * Default configuration for Document-Structure chunking.
+ */
+exports.DEFAULT_DOCUMENT_STRUCTURE_CHUNKING_CONFIG = {
+    strategy: 'document-structure',
+    splitBy: 'paragraph',
+    maxChunkSize: 1000,
+    tableSplitStrategy: 'row',
+    stripWhitespace: true,
+    includeMetadata: true,
+    addStartIndex: false,
+    lengthFunction: (text) => text.length,
+    sentenceBoundaryRegex: exports.DEFAULT_SENTENCE_BOUNDARY_REGEX,
+    abbreviations: exports.DEFAULT_ABBREVIATIONS,
+};
+/**
+ * Default configuration for Semantic chunking.
+ * Note: `embeddingFunction` has no meaningful default and must be provided by the user.
+ */
+exports.DEFAULT_SEMANTIC_CHUNKING_CONFIG = {
+    strategy: 'semantic',
+    similarityThreshold: 0.8,
+    maxChunkSize: 2000,
+    bufferSize: 1,
+    embeddingBatchSize: 50,
+    stripWhitespace: true,
+    includeMetadata: true,
+    addStartIndex: false,
+    lengthFunction: (text) => text.length,
+    sentenceBoundaryRegex: exports.DEFAULT_SENTENCE_BOUNDARY_REGEX,
+    abbreviations: exports.DEFAULT_ABBREVIATIONS,
+    timeout: 10000,
+};
+/**
+ * The resolved default chunking config (uses document-structure as default strategy).
+ */
+const DEFAULT_CHUNKING_CONFIG = exports.DEFAULT_DOCUMENT_STRUCTURE_CHUNKING_CONFIG;
+/**
+ * Default configuration for the OfficeGenerator.
+ */
+exports.DEFAULT_GENERATOR_CONFIG = {
+    onNode: () => { },
+    onWarning: () => { },
+    styleMap: [],
+    includeFormatting: true,
+    generateIds: true,
+    renderMetadata: false,
+    metadataOverrides: {},
+    ignoreDefaultStyleMap: false,
+    includeImages: true,
+    includeCharts: true,
+    ignoreInternalLinks: false,
+    abortSignal: null,
+    htmlConfig: DEFAULT_HTML_GENERATOR_CONFIG,
+    mdConfig: DEFAULT_MD_GENERATOR_CONFIG,
+    pdfConfig: DEFAULT_PDF_GENERATOR_CONFIG,
+    csvConfig: DEFAULT_CSV_GENERATOR_CONFIG,
+    textConfig: DEFAULT_TEXT_GENERATOR_CONFIG,
+    rtfConfig: {},
+    chunksConfig: DEFAULT_CHUNKING_CONFIG,
+};