samengine 1.9.1 → 1.10.1

package/dist/utils/csv/stringifier.js

@@ -1,130 +0,0 @@
-const DEFAULT_ESCAPE_RULES = {
-    quote: true,
-    newline: true,
-    delimiter: true,
-    backslash: false,
-    nullByte: false,
-};
-const DEFAULT_OPTIONS = {
-    delimiter: ",",
-    quoteChar: '"',
-    lineEnding: "\r\n",
-    escapeRules: DEFAULT_ESCAPE_RULES,
-    alwaysQuote: false,
-    columns: [],
-    writeHeader: true,
-    nullAsEmpty: true,
-};
-/**
- * Serialisiert JavaScript-Objekte zu einem validen CSV-String.
- *
- * Unterstützt:
- *  - RFC 4180 Doppelquote-Escaping: " → ""
- *  - Optionales Backslash-Escaping: \ → \\
- *  - Optionales Null-Byte-Escaping: \0 → \\0
- *  - Automatisches Quoting bei Sonderzeichen
- *  - Konfigurierbare Spaltenreihenfolge
- *  - Wahlweise immer quoten (alwaysQuote)
- */
-export class CSVStringifier {
-    constructor(options = {}) {
-        this.opts = {
-            ...DEFAULT_OPTIONS,
-            ...options,
-            escapeRules: {
-                ...DEFAULT_ESCAPE_RULES,
-                ...(options.escapeRules ?? {}),
-            },
-        };
-        this.escapeRules = this.opts.escapeRules;
-        if (this.opts.delimiter.length !== 1) {
-            throw new Error("delimiter muss genau ein Zeichen lang sein.");
-        }
-        if (this.opts.quoteChar.length !== 1) {
-            throw new Error("quoteChar muss genau ein Zeichen lang sein.");
-        }
-    }
-    /**
-     * Serialisiert ein Array von Objekten zu einem CSV-String.
-     */
-    stringify(records) {
-        if (records.length === 0)
-            return "";
-        const columns = this.opts.columns.length > 0
-            ? this.opts.columns
-            : Object.keys(records[0]);
-        const lines = [];
-        if (this.opts.writeHeader) {
-            lines.push(columns.map((h) => this.escapeField(h)).join(this.opts.delimiter));
-        }
-        for (const record of records) {
-            const row = columns.map((col) => {
-                const value = record[col];
-                if ((value === null || value === undefined) && this.opts.nullAsEmpty) {
-                    return "";
-                }
-                return this.escapeField(String(value ?? ""));
-            });
-            lines.push(row.join(this.opts.delimiter));
-        }
-        return lines.join(this.opts.lineEnding);
-    }
-    /**
-     * Serialisiert ein einzelnes Feld mit korrektem Escaping.
-     * Öffentlich, damit einzelne Werte unabhängig escaped werden können.
-     */
-    escapeField(raw) {
-        const { delimiter, quoteChar, alwaysQuote } = this.opts;
-        const rules = this.escapeRules;
-        let value = raw;
-        let needsQuoting = alwaysQuote;
-        // 1. Backslash escapen (muss vor allen anderen stehen)
-        if (rules.backslash && value.includes("\\")) {
-            value = value.replace(/\\/g, "\\\\");
-            needsQuoting = true;
-        }
-        // 2. Null-Byte escapen
-        if (rules.nullByte && value.includes("\0")) {
-            value = value.replace(/\0/g, "\\0");
-            needsQuoting = true;
-        }
-        // 3. Anführungszeichen escapen (RFC 4180: "" Verdopplung)
-        if (rules.quote && value.includes(quoteChar)) {
-            // Needs ES2021
-            // value = value.replaceAll(quoteChar, quoteChar + quoteChar);
-            value = value.split(quoteChar).join(quoteChar + quoteChar);
-            needsQuoting = true;
-        }
-        // 4. Zeilenumbrüche → brauchen Quoting
-        if (rules.newline && (value.includes("\n") || value.includes("\r"))) {
-            needsQuoting = true;
-        }
-        // 5. Trennzeichen im Wert → braucht Quoting
-        if (rules.delimiter && value.includes(delimiter)) {
-            needsQuoting = true;
-        }
-        if (needsQuoting) {
-            return `${quoteChar}${value}${quoteChar}`;
-        }
-        return value;
-    }
-    /**
-     * Streamt Records zeilenweise als Generator (speicherschonend für große Dateien).
-     */
-    *stream(records, columns) {
-        const { delimiter, lineEnding, writeHeader } = this.opts;
-        if (writeHeader) {
-            yield columns.map((h) => this.escapeField(h)).join(delimiter) + lineEnding;
-        }
-        for (const record of records) {
-            const row = columns.map((col) => {
-                const value = record[col];
-                if ((value === null || value === undefined) && this.opts.nullAsEmpty) {
-                    return "";
-                }
-                return this.escapeField(String(value ?? ""));
-            });
-            yield row.join(delimiter) + lineEnding;
-        }
-    }
-}

package/dist/utils/csv/types.d.ts

@@ -1,63 +0,0 @@
-/**
- * Regeln, welche Zeichen escaped werden sollen.
- */
-export interface EscapeRules {
-    /** Verdoppelt Anführungszeichen innerhalb von Feldern: " → "" */
-    quote?: boolean;
-    /** Felder mit Zeilenumbrüchen werden gequotet */
-    newline?: boolean;
-    /** Felder, die das Trennzeichen enthalten, werden gequotet */
-    delimiter?: boolean;
-    /** Backslashes werden escaped: \ → \\ */
-    backslash?: boolean;
-    /** Null-Bytes werden escaped: \0 → \\0 */
-    nullByte?: boolean;
-}
-export interface CSVParserOptions {
-    /** Trennzeichen (Standard: ",") */
-    delimiter?: string;
-    /** Anführungszeichen-Zeichen (Standard: '"') */
-    quoteChar?: string;
-    /** Escape-Zeichen für Backslash-Escaping (Standard: kein Backslash-Escape) */
-    escapeChar?: string;
-    /** Erste Zeile als Header interpretieren (Standard: true) */
-    hasHeader?: boolean;
-    /** Führende/nachfolgende Leerzeichen in Feldern trimmen (Standard: false) */
-    trimFields?: boolean;
-    /** Leere Zeilen überspringen (Standard: true) */
-    skipEmptyLines?: boolean;
-    /** Kommentare überspringen (z. B. "#") — leer = deaktiviert */
-    commentChar?: string;
-}
-export interface CSVStringifierOptions {
-    /** Trennzeichen (Standard: ",") */
-    delimiter?: string;
-    /** Anführungszeichen-Zeichen (Standard: '"') */
-    quoteChar?: string;
-    /** Zeilenende (Standard: "\r\n" per RFC 4180) */
-    lineEnding?: "\r\n" | "\n" | "\r";
-    /** Escape-Regeln */
-    escapeRules?: EscapeRules;
-    /** Alle Felder immer quoten, unabhängig vom Inhalt (Standard: false) */
-    alwaysQuote?: boolean;
-    /** Spaltenreihenfolge (Standard: Reihenfolge der Keys im ersten Objekt) */
-    columns?: string[];
-    /** Header-Zeile schreiben (Standard: true) */
-    writeHeader?: boolean;
-    /** Null / undefined als leeres Feld ausgeben (Standard: true) */
-    nullAsEmpty?: boolean;
-}
-export interface ParseResult<T = Record<string, string>> {
-    /** Geparste Datensätze als Array von Objekten */
-    records: T[];
-    /** Header-Zeile (falls hasHeader = true) */
-    headers: string[];
-    /** Rohe Zeilen als String-Arrays (inkl. Header) */
-    rawRows: string[][];
-    /** Warnungen (z. B. ungleich viele Felder) */
-    warnings: ParseWarning[];
-}
-export interface ParseWarning {
-    row: number;
-    message: string;
-}

package/dist/utils/csv/types.js

@@ -1 +0,0 @@
-export {};

package/dist/utils/jsonc-parser.d.ts

@@ -1,4 +0,0 @@
-export type JSONValue = string | number | boolean | null | JSONValue[] | {
-    [key: string]: JSONValue;
-};
-export declare function parseJSONC(input: string): JSONValue;

package/dist/utils/jsonc-parser.js

@@ -1,166 +0,0 @@
-// jsonc-parser.ts
-// JSON with comments (// and /* */) parser in TypeScript
-export function parseJSONC(input) {
-    let i = 0;
-    function error(msg) {
-        throw new SyntaxError(`${msg} at position ${i}`);
-    }
-    function peek(offset = 0) {
-        return input[i + offset];
-    }
-    function consume() {
-        return input[i++];
-    }
-    function skipWhitespaceAndComments() {
-        while (i < input.length) {
-            // whitespace
-            if (/\s/.test(peek())) {
-                i++;
-                continue;
-            }
-            // line comment //
-            if (peek() === '/' && peek(1) === '/') {
-                i += 2;
-                while (i < input.length && peek() !== '\n')
-                    i++;
-                continue;
-            }
-            // block comment /* */
-            if (peek() === '/' && peek(1) === '*') {
-                i += 2;
-                while (i < input.length && !(peek() === '*' && peek(1) === '/')) {
-                    i++;
-                }
-                if (i >= input.length)
-                    error("Unterminated block comment");
-                i += 2;
-                continue;
-            }
-            break;
-        }
-    }
-    function parseValue() {
-        skipWhitespaceAndComments();
-        const ch = peek();
-        if (ch === '"')
-            return parseString();
-        if (ch === '{')
-            return parseObject();
-        if (ch === '[')
-            return parseArray();
-        if (ch === '-' || /[0-9]/.test(ch))
-            return parseNumber();
-        if (input.startsWith("true", i)) {
-            i += 4;
-            return true;
-        }
-        if (input.startsWith("false", i)) {
-            i += 5;
-            return false;
-        }
-        if (input.startsWith("null", i)) {
-            i += 4;
-            return null;
-        }
-        error("Unexpected token");
-    }
-    function parseString() {
-        consume(); // "
-        let result = "";
-        while (i < input.length) {
-            const ch = consume();
-            if (ch === '"')
-                return result;
-            if (ch === '\\') {
-                const next = consume();
-                if (next === 'n')
-                    result += '\n';
-                else if (next === 't')
-                    result += '\t';
-                else if (next === 'r')
-                    result += '\r';
-                else
-                    result += next;
-            }
-            else {
-                result += ch;
-            }
-        }
-        error("Unterminated string");
-    }
-    function parseNumber() {
-        let num = "";
-        while (/[-+0-9.eE]/.test(peek())) {
-            num += consume();
-        }
-        const value = Number(num);
-        if (Number.isNaN(value))
-            error("Invalid number");
-        return value;
-    }
-    function parseArray() {
-        consume(); // [
-        const arr = [];
-        skipWhitespaceAndComments();
-        if (peek() === ']') {
-            consume();
-            return arr;
-        }
-        while (true) {
-            arr.push(parseValue());
-            skipWhitespaceAndComments();
-            const ch = consume();
-            if (ch === ']')
-                break;
-            if (ch !== ',')
-                error("Expected ',' or ']'");
-            skipWhitespaceAndComments();
-            if (peek() === ']') {
-                consume();
-                break;
-            }
-        }
-        return arr;
-    }
-    function parseObject() {
-        consume(); // {
-        const obj = {};
-        skipWhitespaceAndComments();
-        if (peek() === '}') {
-            consume();
-            return obj;
-        }
-        while (true) {
-            skipWhitespaceAndComments();
-            const key = parseKey();
-            skipWhitespaceAndComments();
-            if (consume() !== ':')
-                error("Expected ':'");
-            const value = parseValue();
-            obj[key] = value;
-            skipWhitespaceAndComments();
-            const ch = consume();
-            if (ch === '}')
-                break;
-            if (ch !== ',')
-                error("Expected ',' or '}'");
-            skipWhitespaceAndComments();
-            if (peek() === '}') {
-                consume();
-                break;
-            }
-        }
-        return obj;
-    }
-    function parseKey() {
-        skipWhitespaceAndComments();
-        if (peek() === '"')
-            return parseString();
-        error("Keys must be strings in JSONC");
-    }
-    const result = parseValue();
-    skipWhitespaceAndComments();
-    if (i < input.length)
-        error("Unexpected trailing input");
-    return result;
-}

package/dist/utils/markdown.d.ts

@@ -1,41 +0,0 @@
-/**
- * markdown-parser.ts
- * Ein vollständiger Markdown → HTML Parser in TypeScript.
- * Unterstützt: Überschriften, Absätze, Fett/Kursiv/Durchgestrichen,
- * Inline-Code, Code-Blöcke (mit Sprach-Tag), Blockquotes (verschachtelt),
- * geordnete & ungeordnete Listen (verschachtelt), Aufgabenlisten,
- * horizontale Linien, Links, Bilder, Tabellen, Fußnoten, HTML-Entities.
- */
-export interface ParseOptions {
-    /** Fügt target="_blank" rel="noopener noreferrer" zu externen Links hinzu */
-    externalLinks?: boolean;
-    /** Bricht einfache Zeilenumbrüche in <br> um */
-    breaks?: boolean;
-    /** Gibt typographische Anführungszeichen zurück (Smartquotes) */
-    smartypants?: boolean;
-    /** Sanitisiert rohes HTML im Quelltext */
-    sanitize?: boolean;
-}
-/**
- * Konvertiert Markdown-Text in HTML.
- *
- * @param markdown  Eingabe-Markdown
- * @param options   Optionale Parser-Einstellungen
- * @returns         Gerendertes HTML
- *
- * @example
- * ```ts
- * import { parse } from "./markdown-parser";
- * const html = parse("# Hallo Welt\n\nDas ist **Markdown**.");
- * ```
- */
-export declare function parse(markdown: string, options?: ParseOptions): string;
-/**
- * Gibt ein vollständiges HTML-Dokument zurück (optional mit eigenem CSS).
- */
-export declare function parseToDocument(markdown: string, options?: ParseOptions & {
-    title?: string;
-    css?: string;
-    header?: string;
-}): string;
-export declare function exportcss(): string;