@zenoaihq/tson 1.0.2 → 1.1.0

package/dist/index.d.ts

@@ -21,17 +21,27 @@ type TSONObject = {
  * Any valid TSON value
  */
 type TSONValue = TSONPrimitive | TSONArray | TSONObject;
+/**
+ * Schema info for nested object/array structures
+ * - schema: nested schema keys (or null if no schema)
+ * - count: array count (or null if single object)
+ */
+interface SchemaInfo {
+    schema: string[] | null;
+    count: number | null;
+}
 /**
  * Schema map for nested object structures
- * Maps field names to their nested schemas (or null if no schema)
+ * Maps field names to their schema info
  */
-type SchemaMap = Record<string, string[] | null>;
+type SchemaMap = Record<string, SchemaInfo>;
 /**
  * Result of parsing a key with optional schema notation
  */
 interface KeySchema {
     keyName: string;
     schema: string[] | null;
+    count: number | null;
 }
 /**
  * Result of parsing keys with optional row count
@@ -93,6 +103,154 @@ declare function loads(s: string): TSONValue;
  */
 declare function load(filePath: string): Promise<TSONValue>;
 
+/**
+ * TSON Prettify
+ *
+ * Format TSON strings for human readability.
+ * CSV-like format: schema on top, one row/value per line.
+ */
+/**
+ * Format a compact TSON string for human readability.
+ *
+ * Uses CSV-like formatting:
+ * - Schema declaration on first line
+ * - Each row/value on its own line with leading delimiter
+ *
+ * @example
+ * prettify('{@id,name#2|1,Alice|2,Bob}')
+ * // Returns: '{@id,name#2\n|1,Alice\n|2,Bob}'
+ *
+ * @param tsonStr - Compact TSON string
+ * @param indent - Indentation string (default: 2 spaces)
+ * @returns Pretty-formatted TSON string
+ */
+declare function prettify(tsonStr: string, indent?: string): string;
+/**
+ * Remove all formatting from a TSON string.
+ *
+ * @param tsonStr - Pretty-formatted TSON string
+ * @returns Compact single-line TSON string
+ */
+declare function minify(tsonStr: string): string;
+
+/**
+ * TSON File Utilities
+ *
+ * Convenience functions for working with TSON and JSON files.
+ * Includes support for:
+ * - Loading JSON/TSON files
+ * - Saving to TSON with formatting options
+ *
+ * Note: These functions are Node.js only (use dynamic imports for fs).
+ */
+type FormatOption = 'compact' | 'pretty';
+/**
+ * Load a JSON file and return JavaScript data structure.
+ *
+ * @example
+ * const data = await loadJson('data.json');
+ *
+ * @param filepath - Path to JSON file
+ * @returns Parsed JavaScript object
+ */
+declare function loadJson(filepath: string): Promise<unknown>;
+/**
+ * Load a TSON file and return JavaScript data structure.
+ *
+ * @example
+ * const data = await loadTson('data.tson');
+ *
+ * @param filepath - Path to TSON file
+ * @returns Parsed JavaScript object
+ */
+declare function loadTson(filepath: string): Promise<unknown>;
+/**
+ * Save JavaScript data to a TSON file.
+ *
+ * @example
+ * await saveTson(data, 'output.tson');
+ * await saveTson(data, 'output.tson', { format: 'pretty' });
+ *
+ * @param data - JavaScript object to serialize
+ * @param filepath - Output file path
+ * @param options - Formatting options
+ */
+declare function saveTson(data: unknown, filepath: string, options?: {
+    format?: FormatOption;
+    indent?: string;
+}): Promise<void>;
+/**
+ * Save a TSON string directly to file.
+ *
+ * @example
+ * await saveTsonString(tsonData, 'output.tson');
+ * await saveTsonString(tsonData, 'output.tson', { format: 'pretty' });
+ *
+ * @param tsonStr - TSON formatted string
+ * @param filepath - Output file path
+ * @param options - Formatting options
+ */
+declare function saveTsonString(tsonStr: string, filepath: string, options?: {
+    format?: FormatOption | null;
+    indent?: string;
+}): Promise<void>;
+/**
+ * Convert a JSON file to TSON format.
+ *
+ * @example
+ * const tsonStr = await jsonToTson('data.json');
+ * await jsonToTson('data.json', 'data.tson');
+ *
+ * @param inputPath - Path to input JSON file
+ * @param outputPath - Path to output TSON file (optional)
+ * @param options - Formatting options
+ * @returns TSON string representation
+ */
+declare function jsonToTson(inputPath: string, outputPath?: string, options?: {
+    format?: FormatOption;
+}): Promise<string>;
+/**
+ * Convert a TSON file to JSON format.
+ *
+ * @example
+ * const jsonStr = await tsonToJson('data.tson');
+ * await tsonToJson('data.tson', 'data.json');
+ *
+ * @param inputPath - Path to input TSON file
+ * @param outputPath - Path to output JSON file (optional)
+ * @param options - Formatting options
+ * @returns JSON string representation
+ */
+declare function tsonToJson(inputPath: string, outputPath?: string, options?: {
+    indent?: number;
+}): Promise<string>;
+/**
+ * Read a TSON file as raw string (without parsing).
+ *
+ * Useful when you want to prettify/minify without deserializing.
+ *
+ * @param filepath - Path to TSON file
+ * @returns Raw TSON string
+ */
+declare function readTsonString(filepath: string): Promise<string>;
+/**
+ * Prettify a TSON file in place or to a new file.
+ *
+ * @param inputPath - Path to input TSON file
+ * @param outputPath - Path to output file (default: overwrite input)
+ * @param indent - Indentation string (default: 2 spaces)
+ * @returns Prettified TSON string
+ */
+declare function prettifyFile(inputPath: string, outputPath?: string, indent?: string): Promise<string>;
+/**
+ * Minify a TSON file in place or to a new file.
+ *
+ * @param inputPath - Path to input TSON file
+ * @param outputPath - Path to output file (default: overwrite input)
+ * @returns Minified TSON string
+ */
+declare function minifyFile(inputPath: string, outputPath?: string): Promise<string>;
+
 /**
  * TSON Utility Functions
  *
@@ -154,20 +312,28 @@ declare function isUniformObjectArray(data: unknown): data is TSONObject[];
  */
 declare function splitByDelimiter(text: string, delimiter: string): string[];
 /**
- * Parse a key which may include nested schema notation.
+ * Parse a key which may include nested schema notation and optional array count.
+ *
+ * The array count can be specified INSIDE the parentheses to avoid ambiguity:
+ * - `key(@schema#N)` means key is an array of N objects with the given schema
+ * - `key(@schema)` means key is a single object with the given schema
  *
  * Examples:
- *   "name" -> { keyName: "name", schema: null }
- *   "address(@city,zip)" -> { keyName: "address", schema: ["city", "zip"] }
- *   "location(@coords(@lat,lng))" -> { keyName: "location", schema: ["coords(@lat,lng)"] }
+ *   "name" -> { keyName: "name", schema: null, count: null }
+ *   "address(@city,zip)" -> { keyName: "address", schema: ["city", "zip"], count: null }
+ *   "characters(@name,role#2)" -> { keyName: "characters", schema: ["name", "role"], count: 2 }
  */
 declare function parseKeySchema(keyString: string): KeySchema;
 /**
- * Build a mapping of field names to their nested schemas.
+ * Build a mapping of field names to their nested schemas and array counts.
  *
  * Example:
- *   ["id", "address(@city,zip)"]
- *   -> { id: null, address: ["city", "zip"] }
+ *   ["id", "address(@city,zip)", "items(@x,y#2)"]
+ *   -> {
+ *     id: { schema: null, count: null },
+ *     address: { schema: ["city", "zip"], count: null },
+ *     items: { schema: ["x", "y"], count: 2 }
+ *   }
  */
 declare function buildSchemaMap(keys: string[]): SchemaMap;
 /**
@@ -177,4 +343,4 @@ declare function buildSchemaMap(keys: string[]): SchemaMap;
  */
 declare function parseKeys(keysStr: string): ParsedKeys;
 
-export { type KeySchema, type ParsedKeys, type SchemaMap, type TSONArray, type TSONObject, type TSONPrimitive, type TSONValue, buildSchemaMap, dump, dumps, escapeString, formatPrimitive, isUniformObjectArray, load, loads, looksLikeNumber, needsQuoting, parseKeySchema, parseKeys, parsePrimitive, splitByDelimiter, unescapeString };
+export { type KeySchema, type ParsedKeys, type SchemaInfo, type SchemaMap, type TSONArray, type TSONObject, type TSONPrimitive, type TSONValue, buildSchemaMap, dump, dumps, escapeString, formatPrimitive, isUniformObjectArray, jsonToTson, load, loadJson, loadTson, loads, looksLikeNumber, minify, minifyFile, needsQuoting, parseKeySchema, parseKeys, parsePrimitive, prettify, prettifyFile, readTsonString, saveTson, saveTsonString, splitByDelimiter, tsonToJson, unescapeString };

package/dist/index.js

@@ -190,10 +190,10 @@ function splitByDelimiter(text, delimiter) {
 function parseKeySchema(keyString) {
   const trimmed = keyString.trim();
   if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
-    return { keyName: unescapeString(trimmed.slice(1, -1)), schema: null };
+    return { keyName: unescapeString(trimmed.slice(1, -1)), schema: null, count: null };
   }
   if (!trimmed.includes("(")) {
-    return { keyName: trimmed, schema: null };
+    return { keyName: trimmed, schema: null, count: null };
   }
   const parenIdx = trimmed.indexOf("(");
   let keyName = trimmed.slice(0, parenIdx).trim();
@@ -207,14 +207,54 @@ function parseKeySchema(keyString) {
   if (schemaStr.startsWith("@")) {
     schemaStr = schemaStr.slice(1);
   }
+  let nestedCount = null;
+  const hashIdx = findTrailingHash(schemaStr);
+  if (hashIdx !== -1) {
+    const countPart = schemaStr.slice(hashIdx + 1).trim();
+    const parsedCount = parseInt(countPart, 10);
+    if (!isNaN(parsedCount)) {
+      nestedCount = parsedCount;
+      schemaStr = schemaStr.slice(0, hashIdx).trim();
+    }
+  }
   const schemaKeys = splitByDelimiter(schemaStr, ",");
-  return { keyName, schema: schemaKeys };
+  return { keyName, schema: schemaKeys, count: nestedCount };
+}
+function findTrailingHash(schemaStr) {
+  let inQuotes = false;
+  let depthParen = 0;
+  for (let i = schemaStr.length - 1; i >= 0; i--) {
+    const char = schemaStr[i];
+    if (char === '"') {
+      let backslashCount = 0;
+      for (let j = i - 1; j >= 0; j--) {
+        if (schemaStr[j] === "\\") {
+          backslashCount++;
+        } else {
+          break;
+        }
+      }
+      if (backslashCount % 2 === 0) {
+        inQuotes = !inQuotes;
+      }
+    }
+    if (!inQuotes) {
+      if (char === ")") {
+        depthParen++;
+      } else if (char === "(") {
+        depthParen--;
+      } else if (char === "#" && depthParen === 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
 }
 function buildSchemaMap(keys) {
   const schemaMap = {};
   for (const key of keys) {
-    const { keyName, schema } = parseKeySchema(key);
-    schemaMap[keyName] = schema;
+    const { keyName, schema, count } = parseKeySchema(key);
+    schemaMap[keyName] = { schema, count };
   }
   return schemaMap;
 }
@@ -329,7 +369,9 @@ function serializeTabular(arr) {
       keyStr = `"${escapeString(keyStr)}"`;
     }
     if (key in nestedSchemas) {
-      const schemaKeys = nestedSchemas[key];
+      const schemaInfo = nestedSchemas[key];
+      const schemaKeys = schemaInfo.schema;
+      const nestedCount = schemaInfo.count;
       const formattedSchemaKeys = schemaKeys.map((sk) => {
         if (needsQuoting(sk)) {
           return `"${escapeString(sk)}"`;
@@ -337,7 +379,11 @@ function serializeTabular(arr) {
         return sk;
       });
       const schemaStr = formattedSchemaKeys.join(",");
-      keyStr = `${keyStr}(@${schemaStr})`;
+      if (nestedCount !== null) {
+        keyStr = `${keyStr}(@${schemaStr}#${nestedCount})`;
+      } else {
+        keyStr = `${keyStr}(@${schemaStr})`;
+      }
     }
     keyParts.push(keyStr);
   }
@@ -348,7 +394,12 @@ function serializeTabular(arr) {
     for (const key of keys) {
       const value = obj[key];
       if (key in nestedSchemas) {
-        valueParts.push(serializeSchematizedObject(value, nestedSchemas[key]));
+        const schemaInfo = nestedSchemas[key];
+        if (schemaInfo.count !== null) {
+          valueParts.push(serializeSchematizedArray(value, schemaInfo.schema));
+        } else {
+          valueParts.push(serializeSchematizedObject(value, schemaInfo.schema));
+        }
       } else {
         valueParts.push(serializeValue(value));
       }
@@ -362,19 +413,49 @@ function detectNestedSchemas(arr, keys) {
   const nestedSchemas = {};
   for (const key of keys) {
     const values = arr.map((obj) => obj[key]);
-    if (!values.every((v) => typeof v === "object" && v !== null && !Array.isArray(v))) {
-      continue;
-    }
-    if (values.length === 0) {
+    if (values.every((v) => typeof v === "object" && v !== null && !Array.isArray(v))) {
+      if (values.length === 0) {
+        continue;
+      }
+      const firstKeys = Object.keys(values[0]);
+      const allSame = values.slice(1).every((v) => {
+        const objKeys = Object.keys(v);
+        return objKeys.length === firstKeys.length && objKeys.every((k, i) => k === firstKeys[i]);
+      });
+      if (allSame) {
+        nestedSchemas[key] = { schema: firstKeys, count: null };
+      }
       continue;
     }
-    const firstKeys = Object.keys(values[0]);
-    const allSame = values.slice(1).every((v) => {
-      const objKeys = Object.keys(v);
-      return objKeys.length === firstKeys.length && objKeys.every((k, i) => k === firstKeys[i]);
-    });
-    if (allSame) {
-      nestedSchemas[key] = firstKeys;
+    if (values.every((v) => Array.isArray(v))) {
+      if (values.length === 0) {
+        continue;
+      }
+      let allUniform = true;
+      let firstSchema = null;
+      let arrayCount = null;
+      for (const v of values) {
+        const arr2 = v;
+        if (!isUniformObjectArray(arr2)) {
+          allUniform = false;
+          break;
+        }
+        if (arr2.length === 0) {
+          continue;
+        }
+        const vSchema = Object.keys(arr2[0]);
+        const vCount = arr2.length;
+        if (firstSchema === null) {
+          firstSchema = vSchema;
+          arrayCount = vCount;
+        } else if (vSchema.length !== firstSchema.length || !vSchema.every((k, i) => k === firstSchema[i]) || vCount !== arrayCount) {
+          allUniform = false;
+          break;
+        }
+      }
+      if (allUniform && firstSchema !== null) {
+        nestedSchemas[key] = { schema: firstSchema, count: arrayCount };
+      }
     }
   }
   return nestedSchemas;
@@ -390,6 +471,16 @@ function serializeSchematizedObject(obj, schema) {
   }
   return "{" + valueParts.join(",") + "}";
 }
+function serializeSchematizedArray(arr, schema) {
+  if (arr.length === 0) {
+    return "[]";
+  }
+  const objParts = [];
+  for (const obj of arr) {
+    objParts.push(serializeSchematizedObject(obj, schema));
+  }
+  return "[" + objParts.join(",") + "]";
+}
 
 // src/deserializer.ts
 function loads(s) {
@@ -442,8 +533,14 @@ function parseKeyedObject(content) {
   }
   const keysPart = parts[0];
   const { keys, count } = parseKeys(keysPart);
+  if (keys.length === 0 && count !== null) {
+    return Array.from({ length: count }, () => ({}));
+  }
   const schemaMap = buildSchemaMap(keys);
   const fieldNames = keys.map((k) => parseKeySchema(k).keyName);
+  if (keys.length === 0) {
+    return {};
+  }
   if (parts.length === 1) {
     throw new Error("Invalid object format: missing values");
   }
@@ -466,9 +563,11 @@ function parseSingleObject(fieldNames, valuesStr, schemaMap) {
   for (let i = 0; i < fieldNames.length; i++) {
     const fieldName = fieldNames[i];
     const valueStr = values[i];
-    const schema = schemaMap[fieldName];
+    const schemaInfo = schemaMap[fieldName];
+    const schema = schemaInfo?.schema;
+    const count = schemaInfo?.count;
     if (schema) {
-      obj[fieldName] = parseSchematizedValue(valueStr, schema);
+      obj[fieldName] = parseSchematizedValue(valueStr, schema, count);
     } else {
       obj[fieldName] = parseValue(valueStr);
     }
@@ -491,7 +590,36 @@ function parseTabularArray(fieldNames, rowParts, schemaMap, expectedCount) {
   }
   return result;
 }
-function parseSchematizedValue(valueStr, schema) {
+function parseSchematizedValue(valueStr, schema, expectedCount = null) {
+  const trimmed = valueStr.trim();
+  if (expectedCount !== null) {
+    return parseSchematizedArray(trimmed, schema, expectedCount);
+  }
+  return parseSingleSchematizedObject(trimmed, schema);
+}
+function parseSchematizedArray(valueStr, schema, expectedCount) {
+  const trimmed = valueStr.trim();
+  if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) {
+    throw new Error(`Schematized array must be wrapped in brackets: ${valueStr}`);
+  }
+  const content = trimmed.slice(1, -1).trim();
+  if (content.length === 0) {
+    return [];
+  }
+  const parts = splitByDelimiter(content, ",");
+  if (parts.length !== expectedCount) {
+    throw new Error(
+      `Array count mismatch: expected ${expectedCount} objects but got ${parts.length}`
+    );
+  }
+  const result = [];
+  for (const part of parts) {
+    const obj = parseSingleSchematizedObject(part.trim(), schema);
+    result.push(obj);
+  }
+  return result;
+}
+function parseSingleSchematizedObject(valueStr, schema) {
   const trimmed = valueStr.trim();
   if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
     throw new Error(`Schematized value must be wrapped in braces: ${valueStr}`);
@@ -511,12 +639,14 @@ function parseSchematizedValue(valueStr, schema) {
   const obj = {};
   for (let i = 0; i < fieldNames.length; i++) {
     const fieldName = fieldNames[i];
-    const valueStr2 = values[i];
-    const nestedSchema = nestedSchemaMap[fieldName];
+    const valStr = values[i];
+    const schemaInfo = nestedSchemaMap[fieldName];
+    const nestedSchema = schemaInfo?.schema;
+    const nestedCount = schemaInfo?.count;
     if (nestedSchema) {
-      obj[fieldName] = parseSchematizedValue(valueStr2, nestedSchema);
+      obj[fieldName] = parseSchematizedValue(valStr, nestedSchema, nestedCount);
     } else {
-      obj[fieldName] = parseValue(valueStr2);
+      obj[fieldName] = parseValue(valStr);
     }
   }
   return obj;
@@ -540,6 +670,203 @@ function parseArray(text) {
   return result;
 }
 
-export { buildSchemaMap, dump, dumps, escapeString, formatPrimitive, isUniformObjectArray, load, loads, looksLikeNumber, needsQuoting, parseKeySchema, parseKeys, parsePrimitive, splitByDelimiter, unescapeString };
+// src/prettify.ts
+function prettify(tsonStr, indent = "  ") {
+  if (!tsonStr || !tsonStr.trim()) {
+    return tsonStr;
+  }
+  return prettifyValue(tsonStr.trim(), indent, 0);
+}
+function minify(tsonStr) {
+  if (!tsonStr) {
+    return tsonStr;
+  }
+  const lines = tsonStr.split("\n");
+  const result = [];
+  for (const line of lines) {
+    result.push(line.trim());
+  }
+  return result.join("");
+}
+function prettifyValue(text, indent, depth) {
+  text = text.trim();
+  if (!text) {
+    return text;
+  }
+  if (text.startsWith("{@")) {
+    return prettifyObject(text, indent, depth);
+  }
+  if (text.startsWith("{")) {
+    return text;
+  }
+  if (text.startsWith("[")) {
+    return prettifyArray(text, indent, depth);
+  }
+  return text;
+}
+function prettifyObject(text, indent, depth) {
+  if (!text.startsWith("{@") || !text.endsWith("}")) {
+    return text;
+  }
+  const content = text.slice(2, -1);
+  if (!content) {
+    return "{@}";
+  }
+  const parts = splitTopLevel(content, "|");
+  if (parts.length === 0) {
+    return text;
+  }
+  const schema = parts[0];
+  const valueRows = parts.slice(1);
+  const nextIndent = indent.repeat(depth + 1);
+  if (valueRows.length === 0) {
+    return `{@${schema}}`;
+  }
+  const lines = [`{@${schema}`];
+  for (const row of valueRows) {
+    lines.push(`${nextIndent}|${row}`);
+  }
+  lines[lines.length - 1] = lines[lines.length - 1] + "}";
+  return lines.join("\n");
+}
+function prettifyArray(text, indent, depth) {
+  if (!text.startsWith("[") || !text.endsWith("]")) {
+    return text;
+  }
+  const content = text.slice(1, -1);
+  if (!content) {
+    return "[]";
+  }
+  const elements = splitTopLevel(content, ",");
+  if (elements.length <= 1) {
+    return text;
+  }
+  const nextIndent = indent.repeat(depth + 1);
+  const lines = [];
+  for (let i = 0; i < elements.length; i++) {
+    const prettified = prettifyValue(elements[i].trim(), indent, depth + 1);
+    if (i === 0) {
+      lines.push(`[${prettified}`);
+    } else {
+      lines.push(`${nextIndent},${prettified}`);
+    }
+  }
+  lines[lines.length - 1] = lines[lines.length - 1] + "]";
+  return lines.join("\n");
+}
+function splitTopLevel(text, delimiter) {
+  const parts = [];
+  const current = [];
+  let depth = 0;
+  let inString = false;
+  let escapeNext = false;
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    if (escapeNext) {
+      current.push(char);
+      escapeNext = false;
+      continue;
+    }
+    if (char === "\\") {
+      current.push(char);
+      escapeNext = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      current.push(char);
+      continue;
+    }
+    if (inString) {
+      current.push(char);
+      continue;
+    }
+    if (char === "{" || char === "[") {
+      depth++;
+      current.push(char);
+    } else if (char === "}" || char === "]") {
+      depth--;
+      current.push(char);
+    } else if (char === delimiter && depth === 0) {
+      parts.push(current.join(""));
+      current.length = 0;
+    } else {
+      current.push(char);
+    }
+  }
+  if (current.length > 0) {
+    parts.push(current.join(""));
+  }
+  return parts;
+}
+
+// src/fileio.ts
+async function loadJson(filepath) {
+  const fs = await import('fs/promises');
+  const content = await fs.readFile(filepath, "utf-8");
+  return JSON.parse(content);
+}
+async function loadTson(filepath) {
+  const fs = await import('fs/promises');
+  const content = await fs.readFile(filepath, "utf-8");
+  return loads(content);
+}
+async function saveTson(data, filepath, options = {}) {
+  const fs = await import('fs/promises');
+  let tsonStr = dumps(data);
+  if (options.format === "pretty") {
+    tsonStr = prettify(tsonStr, options.indent || "  ");
+  }
+  await fs.writeFile(filepath, tsonStr, "utf-8");
+}
+async function saveTsonString(tsonStr, filepath, options = {}) {
+  const fs = await import('fs/promises');
+  if (options.format === "pretty") {
+    tsonStr = prettify(tsonStr, options.indent || "  ");
+  } else if (options.format === "compact") {
+    tsonStr = minify(tsonStr);
+  }
+  await fs.writeFile(filepath, tsonStr, "utf-8");
+}
+async function jsonToTson(inputPath, outputPath, options = {}) {
+  const data = await loadJson(inputPath);
+  let tsonStr = dumps(data);
+  if (options.format === "pretty") {
+    tsonStr = prettify(tsonStr);
+  }
+  if (outputPath) {
+    await saveTsonString(tsonStr, outputPath);
+  }
+  return tsonStr;
+}
+async function tsonToJson(inputPath, outputPath, options = {}) {
+  const data = await loadTson(inputPath);
+  const jsonStr = JSON.stringify(data, null, options.indent ?? 2);
+  if (outputPath) {
+    const fs = await import('fs/promises');
+    await fs.writeFile(outputPath, jsonStr, "utf-8");
+  }
+  return jsonStr;
+}
+async function readTsonString(filepath) {
+  const fs = await import('fs/promises');
+  return fs.readFile(filepath, "utf-8");
+}
+async function prettifyFile(inputPath, outputPath, indent = "  ") {
+  const tsonStr = await readTsonString(inputPath);
+  const prettyStr = prettify(tsonStr, indent);
+  const target = outputPath || inputPath;
+  await saveTsonString(prettyStr, target);
+  return prettyStr;
+}
+async function minifyFile(inputPath, outputPath) {
+  const tsonStr = await readTsonString(inputPath);
+  const compactStr = minify(tsonStr);
+  const target = outputPath || inputPath;
+  await saveTsonString(compactStr, target);
+  return compactStr;
+}
+
+export { buildSchemaMap, dump, dumps, escapeString, formatPrimitive, isUniformObjectArray, jsonToTson, load, loadJson, loadTson, loads, looksLikeNumber, minify, minifyFile, needsQuoting, parseKeySchema, parseKeys, parsePrimitive, prettify, prettifyFile, readTsonString, saveTson, saveTsonString, splitByDelimiter, tsonToJson, unescapeString };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map