yini-cli 1.2.1-beta → 1.3.1-beta

package/README.md

@@ -5,7 +5,7 @@
 
 *YINI is an INI-inspired and human-readable text format for representing structured information. It is designed to be clear, predictable, and easy for humans to read and write. It supports nesting, comments, and a formally defined syntax. It is suitable for configuration files, application settings, and general data-storage use cases.*
 
-[![npm version](https://img.shields.io/npm/v/yini-cli.svg)](https://www.npmjs.com/package/yini-cli) [![All Test Suites](https://github.com/YINI-lang/yini-cli/actions/workflows/run-all-tests.yml/badge.svg)](https://github.com/YINI-lang/yini-cli/actions/workflows/run-all-tests.yml) [![Regression Tests](https://github.com/YINI-lang/yini-cli/actions/workflows/run-regression-tests.yml/badge.svg)](https://github.com/YINI-lang/yini-cli/actions/workflows/run-regression-tests.yml) [![CLI Test CI](https://github.com/YINI-lang/yini-cli/actions/workflows/run-cli-test.yml/badge.svg)](https://github.com/YINI-lang/yini-cli/actions/workflows/run-cli-test.yml)
+[![npm version](https://img.shields.io/npm/v/yini-cli.svg)](https://www.npmjs.com/package/yini-cli) [![All Test Suites](https://github.com/YINI-lang/yini-cli/actions/workflows/run-all-tests.yml/badge.svg)](https://github.com/YINI-lang/yini-cli/actions/workflows/run-all-tests.yml) [![Regression Tests](https://github.com/YINI-lang/yini-cli/actions/workflows/run-regression-tests.yml/badge.svg)](https://github.com/YINI-lang/yini-cli/actions/workflows/run-regression-tests.yml) [![CLI Test CI](https://github.com/YINI-lang/yini-cli/actions/workflows/run-cli-test.yml/badge.svg)](https://github.com/YINI-lang/yini-cli/actions/workflows/run-cli-test.yml) [![npm downloads](https://img.shields.io/npm/dm/yini-cli)](https://www.npmjs.com/package/yini-cli)
 
 This tool is designed for teams and developers working with human-edited configuration files who require explicit structure without indentation-based semantics.
 

package/dist/commands/parseCommand.d.ts

@@ -7,6 +7,8 @@ export interface IParseCommandOptions extends IGlobalOptions {
     json?: boolean;
     compact?: boolean;
     js?: boolean;
+    yaml?: boolean;
+    xml?: boolean;
     output?: string;
     bestEffort?: boolean;
     overwrite?: boolean;

package/dist/commands/parseCommand.js

@@ -1,8 +1,25 @@
+// src/commands/parseCommand.ts
 import fs from 'node:fs';
 import path from 'node:path';
 import YINI from 'yini-parser';
-import { debugPrint, printObject, toPrettyJS, toPrettyJSON, } from '../utils/print.js';
+import { getSerializer } from '../serializers/index.js';
+import { debugPrint, printObject } from '../utils/print.js';
 // -------------------------------------------------------------------------
+const reportAction = (action, file, reason) => {
+    let txt = '';
+    if (reason) {
+        txt = `${action.padEnd(6)} "${file}" (${reason})`;
+    }
+    else {
+        txt = `${action.padEnd(6)} "${file}"`;
+    }
+    if (action === 'skip') {
+        console.warn(txt);
+    }
+    else {
+        console.log(txt);
+    }
+};
 /*
     TODO / SHOULD-DO:
 
@@ -41,64 +58,94 @@ import { debugPrint, printObject, toPrettyJS, toPrettyJSON, } from '../utils/pri
 export const parseFile = (file, commandOptions) => {
     const outputFile = commandOptions.output || '';
     // const isStrictMode = !!commandOptions.strict
-    const outputStyle = resolveOutputStyle(commandOptions);
+    const outputFormat = resolveOutputFormat(commandOptions);
     debugPrint('file = ' + file);
     debugPrint('output = ' + commandOptions.output);
     debugPrint('commandOptions:');
     printObject(commandOptions);
-    doParseFile(file, commandOptions, outputStyle, outputFile);
+    doParseFile(file, commandOptions, outputFormat, outputFile);
 };
-const resolveOutputStyle = (options) => {
+const resolveOutputFormat = (options) => {
     if (options.js && options.compact) {
         throw new Error('--js and --compact cannot be combined.');
     }
     if (options.compact)
-        return 'JSON-compact';
+        return 'json-compact';
     if (options.js)
-        return 'JS-style';
+        return 'js';
+    if (options.yaml)
+        return 'yaml';
+    if (options.xml)
+        return 'xml';
     if (options.pretty) {
         console.warn('Warning: --pretty is deprecated. Use --json instead.');
     }
-    return 'Pretty-JSON';
+    return 'json';
 };
-const renderOutput = (parsed, style) => {
+/*
+const renderOutput = (parsed: unknown, style: TOutputStyle): string => {
     switch (style) {
         case 'JS-style':
-            return toPrettyJS(parsed);
+            return toPrettyJS(parsed)
+
         case 'JSON-compact':
-            return JSON.stringify(parsed);
+            return JSON.stringify(parsed)
+
         case 'Pretty-JSON':
         default:
-            return toPrettyJSON(parsed);
+            return toPrettyJSON(parsed)
     }
-};
-const doParseFile = (file, commandOptions, outputStyle, outputFile = '') => {
-    // let strictMode = !!commandOptions.strict
+}
+*/
+const doParseFile = (file, commandOptions, outputFormat, outputFile = '') => {
     let preferredFailLevel = commandOptions.bestEffort
         ? 'ignore-errors'
         : 'auto';
     let includeMetaData = false;
     debugPrint('File = ' + file);
-    debugPrint('outputStyle = ' + outputStyle);
+    debugPrint('outputFormat = ' + outputFormat);
     const parseOptions = {
         strictMode: commandOptions.strict ?? false,
-        failLevel: preferredFailLevel,
-        includeMetadata: includeMetaData,
+        failLevel: commandOptions.bestEffort ? 'ignore-errors' : 'auto',
+        includeMetadata: false,
     };
     // If --best-effort then override fail-level.
-    if (commandOptions.bestEffort) {
-        parseOptions.failLevel = 'ignore-errors';
-    }
+    // if (commandOptions.bestEffort) {
+    //     parseOptions.failLevel = 'ignore-errors'
+    // }
     try {
         const parsed = YINI.parseFile(file, parseOptions);
-        const output = renderOutput(parsed, outputStyle);
+        const serializer = getSerializer(outputFormat);
+        const output = serializer.serialize(parsed);
         if (outputFile) {
             const resolved = path.resolve(outputFile);
-            enforceWritePolicy(file, resolved, commandOptions.overwrite);
+            const canWrite = enforceWritePolicy(file, resolved, commandOptions.overwrite);
+            if (!canWrite) {
+                if (commandOptions.verbose) {
+                    console.log(`skip    Skipping write to "${resolved}"`);
+                }
+                return;
+            }
+            // Double check, if the file was actually changed by comparing the contents.
+            if (fs.existsSync(resolved) && fs.statSync(resolved).isFile()) {
+                const existing = fs.readFileSync(resolved, 'utf-8');
+                // Only write the output file if the content actually changed.
+                // Prevents constantly showing meaningless rewrites, in some cases.
+                if (existing === output) {
+                    if (commandOptions.verbose) {
+                        // console.log(
+                        //     `skip    Output unchanged. Skipping write: "${resolved}"`,
+                        // )
+                        reportAction('skip', resolved, 'output unchanged');
+                    }
+                    return;
+                }
+            }
             // Write JSON output to file instead of stdout.
             fs.writeFileSync(resolved, output, 'utf-8');
             if (commandOptions.verbose) {
-                console.log(`Output written to file: "${outputFile}"`);
+                // console.log(`write    Output written to file: "${outputFile}"`)
+                reportAction('write', resolved);
             }
         }
         else {
@@ -113,19 +160,27 @@ const doParseFile = (file, commandOptions, outputStyle, outputFile = '') => {
 };
 const enforceWritePolicy = (srcPath, destPath, overwrite) => {
     if (!fs.existsSync(destPath)) {
-        return; // File does not exist, OK to write.
+        return true; // File does not exist, OK to write.
     }
     const srcStat = fs.statSync(srcPath);
     const destStat = fs.statSync(destPath);
-    const destIsNewer = destStat.mtimeMs >= srcStat.mtimeMs;
+    // Only strictly newer triggers skip overwrite.
+    const destIsNewer = destStat.mtimeMs > srcStat.mtimeMs;
     if (overwrite === true) {
-        return; // Explicit overwrite, OK.
+        return true; // Explicit overwrite, OK.
     }
     if (overwrite === false) {
         throw new Error(`File "${destPath}" already exists. Overwriting disabled (--no-overwrite).`);
     }
     // Default policy (overwrite undefined).
     if (destIsNewer) {
-        throw new Error(`Destination file "${destPath}" is newer than source. Use --overwrite to force.`);
+        // console.warn(
+        //     // `Destination file "${destPath}" is newer than source. Use --overwrite to force.`,
+        //     //`Warning: destination file "${destPath}" is newer than source. Skipping write. Use --overwrite to force.`,
+        //     `Warning: destination "${destPath}" is newer than source "${srcPath}". Skipping write. Use --overwrite to force.`,
+        // )
+        reportAction('skip', destPath, `newer than source "${srcPath}"`);
+        return false;
     }
+    return true;
 };

package/dist/index.js

@@ -75,6 +75,8 @@ const parseCmd = program
     .option('--json', 'Output as formatted JSON (default).')
     .option('--compact', 'Output compact JSON (no whitespace).')
     .option('--js', 'Output as JavaScript.')
+    .option('--yaml', 'Output as YAML.')
+    .option('--xml', 'Output as XML.')
     // File handling options.
     .option('-o, --output <file>', 'Write output to <file>. By default, an existing file is only overwritten if it is older than the input YINI file.')
     .option('--overwrite', 'Always overwrite the output file, even if it is newer than the input YINI file.')

package/dist/serializers/index.d.ts

@@ -0,0 +1,3 @@
+import { Serializer } from './types.js';
+export type TOutputFormat = 'json' | 'json-compact' | 'js' | 'yaml' | 'xml';
+export declare function getSerializer(format: TOutputFormat): Serializer;

package/dist/serializers/index.js

@@ -0,0 +1,53 @@
+// src/serializers/index.ts
+/*
+
+NOTE:
+
+Supported formats are a small, intentionally selected set of commonly
+used output formats:
+
+- JSON:     Output as formatted JSON (default) for easy reading and broad
+            compatibility with tools and APIs.
+- compact:  Output compact JSON (no whitespace) for efficient piping,
+            scripting, and smaller output size.
+- JS:       Output as JavaScript for direct use in Node.js or embedding the
+            result as a JavaScript object.
+- YAML:     Output as YAML for environments and tools that commonly use
+            YAML-based configuration.
+- XML:      Output as XML for interoperability with systems and tooling that
+            rely on XML formats.
+
+These formats cover the most common scenarios for inspecting parsed YINI data
+and exchanging it with other tools and systems.
+
+The CLI focuses on providing a small number of widely useful formats while
+keeping the command simple and predictable.
+
+Additional conversions can be implemented in separate tools built on top of
+the YINI CLI — for example a dedicated utility such as yini-convert.
+
+This keeps the core CLI focused while allowing additional functionality to be
+added in complementary tools if needed.
+
+*/
+import { JsonSerializer } from './jsonSerializer.js';
+import { JSSerializer } from './jSSerializer.js';
+import { XmlSerializer } from './xmlSerializer.js';
+import { YamlSerializer } from './yamlSerializer.js';
+export function getSerializer(format) {
+    switch (format) {
+        case 'json':
+        case 'json-compact':
+            return new JsonSerializer(format);
+        case 'js':
+            return new JSSerializer();
+        case 'yaml':
+            return new YamlSerializer();
+        case 'xml':
+            return new XmlSerializer();
+        default: {
+            const exhaustiveCheck = format;
+            throw new Error(`Unsupported output format: ${exhaustiveCheck}`);
+        }
+    }
+}

package/dist/serializers/jSSerializer.d.ts

@@ -0,0 +1,18 @@
+import { Serializer } from './types.js';
+export type ToPrettyJSOptions = {
+    indent?: number;
+    exportDefault?: boolean;
+    trailingSemicolon?: boolean;
+};
+export declare class JSSerializer implements Serializer {
+    readonly format = "json";
+    serialize(data: unknown): string;
+}
+/**
+ * A clean and stable toPrettyJS(..) without relying on util.inspect(..).
+ * - Deterministic output (unlike util.inspect, which can vary across Node versions).
+ * - Exactly 4 spaces.
+ * - Clean single quotes.
+ * - Proper escaping, and safe quoting of non-identifier keys.
+ */
+export declare function getPrettyJS(value: unknown, opts?: ToPrettyJSOptions): string;

package/dist/serializers/jSSerializer.js

@@ -0,0 +1,84 @@
+export class JSSerializer {
+    constructor() {
+        this.format = 'json';
+    }
+    serialize(data) {
+        return getPrettyJS(data);
+    }
+}
+/**
+ * A clean and stable toPrettyJS(..) without relying on util.inspect(..).
+ * - Deterministic output (unlike util.inspect, which can vary across Node versions).
+ * - Exactly 4 spaces.
+ * - Clean single quotes.
+ * - Proper escaping, and safe quoting of non-identifier keys.
+ */
+export function getPrettyJS(value, opts = {}) {
+    const indent = opts.indent ?? 4;
+    const exportDefault = opts.exportDefault ?? false;
+    const trailingSemicolon = opts.trailingSemicolon ?? exportDefault;
+    const pad = (level) => ' '.repeat(level * indent);
+    const isPlainObject = (v) => v !== null &&
+        typeof v === 'object' &&
+        Object.getPrototypeOf(v) === Object.prototype;
+    const isValidIdentifier = (key) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key);
+    const escapeString = (s) => s
+        .replace(/\\/g, '\\\\')
+        .replace(/'/g, "\\'")
+        .replace(/\r/g, '\\r')
+        .replace(/\n/g, '\\n')
+        .replace(/\t/g, '\\t')
+        .replace(/\u2028/g, '\\u2028')
+        .replace(/\u2029/g, '\\u2029');
+    const formatKey = (key) => isValidIdentifier(key) ? key : `'${escapeString(key)}'`;
+    const format = (v, level) => {
+        if (v === null)
+            return 'null';
+        const t = typeof v;
+        if (t === 'string')
+            return `'${escapeString(v)}'`;
+        if (t === 'number')
+            return Number.isFinite(v) ? String(v) : 'null';
+        if (t === 'boolean')
+            return v ? 'true' : 'false';
+        if (t === 'bigint')
+            return `${v}n`;
+        if (t === 'undefined')
+            return 'undefined';
+        if (t === 'function')
+            return '[Function]';
+        if (t === 'symbol')
+            return 'Symbol()';
+        if (v instanceof Date)
+            return `'${v.toISOString()}'`;
+        if (Array.isArray(v)) {
+            if (v.length === 0)
+                return '[]';
+            const inner = v
+                .map((item) => `${pad(level + 1)}${format(item, level + 1)}`)
+                .join(',\n');
+            return `[\n${inner}\n${pad(level)}]`;
+        }
+        if (isPlainObject(v)) {
+            const keys = Object.keys(v);
+            if (keys.length === 0)
+                return '{}';
+            const inner = keys
+                .map((k) => `${pad(level + 1)}${formatKey(k)}: ${format(v[k], level + 1)}`)
+                .join(',\n');
+            return `{\n${inner}\n${pad(level)}}`;
+        }
+        // Fallback for Map/Set/class instances etc.
+        try {
+            // JSON fallback keeps it stable-ish for "weird" objects
+            return `'${escapeString(JSON.stringify(v))}'`;
+        }
+        catch {
+            return "'[Unserializable]'";
+        }
+    };
+    const body = format(value, 0);
+    if (!exportDefault)
+        return body;
+    return `export default ${body}${trailingSemicolon ? ';' : ''}\n`;
+}

package/dist/serializers/jsonSerializer.d.ts

@@ -0,0 +1,7 @@
+import { Serializer } from './types.js';
+export declare class JsonSerializer implements Serializer {
+    readonly format: 'json' | 'json-compact';
+    constructor(format?: 'json' | 'json-compact');
+    serialize(data: unknown): string;
+}
+export declare const getPrettyJSON: (obj: unknown) => string;

package/dist/serializers/jsonSerializer.js

@@ -0,0 +1,14 @@
+export class JsonSerializer {
+    constructor(format = 'json') {
+        this.format = format;
+    }
+    serialize(data) {
+        return this.format === 'json'
+            ? getPrettyJSON(data)
+            : JSON.stringify(data); // Compact.
+    }
+}
+export const getPrettyJSON = (obj) => {
+    const str = JSON.stringify(obj, null, 4);
+    return str;
+};

package/dist/serializers/types.d.ts

@@ -0,0 +1,4 @@
+export interface Serializer {
+    readonly format: string;
+    serialize(data: unknown): string;
+}

package/dist/serializers/types.js

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

package/dist/serializers/xmlSerializer.d.ts

@@ -0,0 +1,5 @@
+import { Serializer } from './types.js';
+export declare class XmlSerializer implements Serializer {
+    readonly format = "xml";
+    serialize(data: unknown): string;
+}

package/dist/serializers/xmlSerializer.js

@@ -0,0 +1,12 @@
+// src/serializers/xmlSerializer.ts
+import { create } from 'xmlbuilder2';
+export class XmlSerializer {
+    constructor() {
+        this.format = 'xml';
+    }
+    serialize(data) {
+        const plainJSON = JSON.parse(JSON.stringify(data));
+        const doc = create({ version: '1.0' }).ele({ yini: plainJSON });
+        return doc.end({ prettyPrint: true });
+    }
+}

package/dist/serializers/yamlSerializer.d.ts

@@ -0,0 +1,5 @@
+import { Serializer } from './types.js';
+export declare class YamlSerializer implements Serializer {
+    readonly format = "yaml";
+    serialize(data: unknown): string;
+}

package/dist/serializers/yamlSerializer.js

@@ -0,0 +1,9 @@
+import YAML from 'yaml';
+export class YamlSerializer {
+    constructor() {
+        this.format = 'yaml';
+    }
+    serialize(data) {
+        return YAML.stringify(data);
+    }
+}

package/dist/utils/print.d.ts

@@ -1,8 +1,4 @@
-type ToPrettyJSOptions = {
-    indent?: number;
-    exportDefault?: boolean;
-    trailingSemicolon?: boolean;
-};
+import { ToPrettyJSOptions } from '../serializers/jSSerializer.js';
 export declare const debugPrint: (str?: any) => void;
 export declare const devPrint: (str?: any) => void;
 export declare const toJSON: (obj: any) => string;
@@ -19,12 +15,4 @@ export declare const printJSON: (obj: any, isForce?: boolean) => void;
  * @note This function relies on util.inspect(..).
  */
 export declare const printObject: (obj: any, isForce?: boolean, isColors?: boolean) => void;
-/**
- * A clean and stable toPrettyJS(..) without relying on util.inspect(..).
- * - Deterministic output (unlike util.inspect, which can vary across Node versions).
- * - Exactly 4 spaces.
- * - Clean single quotes.
- * - Proper escaping, and safe quoting of non-identifier keys.
- */
 export declare function toPrettyJS(value: unknown, opts?: ToPrettyJSOptions): string;
-export {};

package/dist/utils/print.js

@@ -4,6 +4,13 @@
  */
 import util from 'util';
 import { isDebug, isDev, isProdEnv, isTestEnv } from '../config/env.js';
+import { getPrettyJSON } from '../serializers/jsonSerializer.js';
+import { getPrettyJS } from '../serializers/jSSerializer.js';
+// type ToPrettyJSOptions = {
+//     indent?: number // default: 4
+//     exportDefault?: boolean // default: false  -> if true: "export default ...;"
+//     trailingSemicolon?: boolean // default: true when exportDefault
+// }
 export const debugPrint = (str = '') => {
     isDebug() && console.debug('DEBUG: ' + str);
 };
@@ -15,8 +22,9 @@ export const toJSON = (obj) => {
     return str;
 };
 export const toPrettyJSON = (obj) => {
-    const str = JSON.stringify(obj, null, 4);
-    return str;
+    // const str = JSON.stringify(obj, null, 4)
+    // return str
+    return getPrettyJSON(obj);
 };
 /** Pretty-prints a JavaScript object as formatted JSON to the console.
  * Strict JSON, all keys are enclosed in ", etc.
@@ -43,79 +51,79 @@ export const printObject = (obj, isForce = false, isColors = true) => {
     }
     console.log(util.inspect(obj, { depth: null, colors: isColors }));
 };
-/**
- * A clean and stable toPrettyJS(..) without relying on util.inspect(..).
- * - Deterministic output (unlike util.inspect, which can vary across Node versions).
- * - Exactly 4 spaces.
- * - Clean single quotes.
- * - Proper escaping, and safe quoting of non-identifier keys.
- */
+// /**
+//  * A clean and stable toPrettyJS(..) without relying on util.inspect(..).
+//  * - Deterministic output (unlike util.inspect, which can vary across Node versions).
+//  * - Exactly 4 spaces.
+//  * - Clean single quotes.
+//  * - Proper escaping, and safe quoting of non-identifier keys.
+//  */
+// export function toPrettyJS(
+//     value: unknown,
+//     opts: ToPrettyJSOptions = {},
+// ): string {
+//     const indent = opts.indent ?? 4
+//     const exportDefault = opts.exportDefault ?? false
+//     const trailingSemicolon = opts.trailingSemicolon ?? exportDefault
+//     const pad = (level: number) => ' '.repeat(level * indent)
+//     const isPlainObject = (v: any): v is Record<string, unknown> =>
+//         v !== null &&
+//         typeof v === 'object' &&
+//         Object.getPrototypeOf(v) === Object.prototype
+//     const isValidIdentifier = (key: string) =>
+//         /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)
+//     const escapeString = (s: string) =>
+//         s
+//             .replace(/\\/g, '\\\\')
+//             .replace(/'/g, "\\'")
+//             .replace(/\r/g, '\\r')
+//             .replace(/\n/g, '\\n')
+//             .replace(/\t/g, '\\t')
+//             .replace(/\u2028/g, '\\u2028')
+//             .replace(/\u2029/g, '\\u2029')
+//     const formatKey = (key: string) =>
+//         isValidIdentifier(key) ? key : `'${escapeString(key)}'`
+//     const format = (v: unknown, level: number): string => {
+//         if (v === null) return 'null'
+//         const t = typeof v
+//         if (t === 'string') return `'${escapeString(v as string)}'`
+//         if (t === 'number') return Number.isFinite(v) ? String(v) : 'null'
+//         if (t === 'boolean') return v ? 'true' : 'false'
+//         if (t === 'bigint') return `${v}n`
+//         if (t === 'undefined') return 'undefined'
+//         if (t === 'function') return '[Function]'
+//         if (t === 'symbol') return 'Symbol()'
+//         if (v instanceof Date) return `'${v.toISOString()}'`
+//         if (Array.isArray(v)) {
+//             if (v.length === 0) return '[]'
+//             const inner = v
+//                 .map((item) => `${pad(level + 1)}${format(item, level + 1)}`)
+//                 .join(',\n')
+//             return `[\n${inner}\n${pad(level)}]`
+//         }
+//         if (isPlainObject(v)) {
+//             const keys = Object.keys(v)
+//             if (keys.length === 0) return '{}'
+//             const inner = keys
+//                 .map(
+//                     (k) =>
+//                         `${pad(level + 1)}${formatKey(k)}: ${format((v as any)[k], level + 1)}`,
+//                 )
+//                 .join(',\n')
+//             return `{\n${inner}\n${pad(level)}}`
+//         }
+//         // Fallback for Map/Set/class instances etc.
+//         try {
+//             // JSON fallback keeps it stable-ish for "weird" objects
+//             return `'${escapeString(JSON.stringify(v))}'`
+//         } catch {
+//             return "'[Unserializable]'"
+//         }
+//     }
+//     const body = format(value, 0)
+//     if (!exportDefault) return body
+//     return `export default ${body}${trailingSemicolon ? ';' : ''}\n`
+// }
 export function toPrettyJS(value, opts = {}) {
-    const indent = opts.indent ?? 4;
-    const exportDefault = opts.exportDefault ?? false;
-    const trailingSemicolon = opts.trailingSemicolon ?? exportDefault;
-    const pad = (level) => ' '.repeat(level * indent);
-    const isPlainObject = (v) => v !== null &&
-        typeof v === 'object' &&
-        Object.getPrototypeOf(v) === Object.prototype;
-    const isValidIdentifier = (key) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key);
-    const escapeString = (s) => s
-        .replace(/\\/g, '\\\\')
-        .replace(/'/g, "\\'")
-        .replace(/\r/g, '\\r')
-        .replace(/\n/g, '\\n')
-        .replace(/\t/g, '\\t')
-        .replace(/\u2028/g, '\\u2028')
-        .replace(/\u2029/g, '\\u2029');
-    const formatKey = (key) => isValidIdentifier(key) ? key : `'${escapeString(key)}'`;
-    const format = (v, level) => {
-        if (v === null)
-            return 'null';
-        const t = typeof v;
-        if (t === 'string')
-            return `'${escapeString(v)}'`;
-        if (t === 'number')
-            return Number.isFinite(v) ? String(v) : 'null';
-        if (t === 'boolean')
-            return v ? 'true' : 'false';
-        if (t === 'bigint')
-            return `${v}n`;
-        if (t === 'undefined')
-            return 'undefined';
-        if (t === 'function')
-            return '[Function]';
-        if (t === 'symbol')
-            return 'Symbol()';
-        if (v instanceof Date)
-            return `'${v.toISOString()}'`;
-        if (Array.isArray(v)) {
-            if (v.length === 0)
-                return '[]';
-            const inner = v
-                .map((item) => `${pad(level + 1)}${format(item, level + 1)}`)
-                .join(',\n');
-            return `[\n${inner}\n${pad(level)}]`;
-        }
-        if (isPlainObject(v)) {
-            const keys = Object.keys(v);
-            if (keys.length === 0)
-                return '{}';
-            const inner = keys
-                .map((k) => `${pad(level + 1)}${formatKey(k)}: ${format(v[k], level + 1)}`)
-                .join(',\n');
-            return `{\n${inner}\n${pad(level)}}`;
-        }
-        // Fallback for Map/Set/class instances etc.
-        try {
-            // JSON fallback keeps it stable-ish for "weird" objects
-            return `'${escapeString(JSON.stringify(v))}'`;
-        }
-        catch {
-            return "'[Unserializable]'";
-        }
-    };
-    const body = format(value, 0);
-    if (!exportDefault)
-        return body;
-    return `export default ${body}${trailingSemicolon ? ';' : ''}\n`;
+    return getPrettyJS(value);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "yini-cli",
-    "version": "1.2.1-beta",
-    "description": "CLI tool for YINI text-based format - an INI-like config format with real structure, comments, nested sections, no YAML foot-guns, and less noise than JSON.",
+    "version": "1.3.1-beta",
+    "description": "CLI tool for validating and converting YINI configuration files - an INI-like format with real structure, nested sections and strict or lenient modes.",
     "keywords": [
         "yini",
         "cli",
@@ -72,7 +72,9 @@
     "author": "Marko K. Seppänen",
     "dependencies": {
         "commander": "^14.0.1",
-        "yini-parser": "^1.3.2-beta"
+        "xmlbuilder2": "^4.0.3",
+        "yaml": "^2.8.2",
+        "yini-parser": "^1.4.0-beta"
     },
     "devDependencies": {
         "@eslint/js": "^9.31.0",