convert-csv-to-json 4.2.0 → 4.3.0

package/src/csvToJson.js

@@ -1,3 +1,4 @@
+/* globals FileOperationError */
 "use strict";
 
 const fileUtils = require('./util/fileUtils');
@@ -15,28 +16,60 @@ const CRLF = '\r\n';
 const LF = '\n';
 const CR = '\r';
 
+/**
+ * Main CSV to JSON converter class
+ * Provides chainable API for configuring and converting CSV data
+ */
 class CsvToJson {
 
+  /**
+   * Enable or disable automatic type formatting for values
+   * When enabled, numeric strings are converted to numbers, 'true'/'false' to booleans
+   * @param {boolean} active - Whether to format values by type
+   * @returns {this} For method chaining
+   */
   formatValueByType(active) {
     this.printValueFormatByType = active;
     return this;
   }
 
+  /**
+   * Enable or disable support for RFC 4180 quoted fields
+   * When enabled, fields wrapped in double quotes can contain delimiters and newlines
+   * @param {boolean} active - Whether to support quoted fields
+   * @returns {this} For method chaining
+   */
   supportQuotedField(active) {
     this.isSupportQuotedField = active;
     return this;
   }
 
+  /**
+   * Set the field delimiter character
+   * @param {string} delimiter - Character(s) to use as field separator (default: ',')
+   * @returns {this} For method chaining
+   */
   fieldDelimiter(delimiter) {
     this.delimiter = delimiter;
     return this;
   }
 
+  /**
+   * Configure whitespace handling in header field names
+   * @param {boolean} active - If true, removes all whitespace from header names; if false, only trims edges
+   * @returns {this} For method chaining
+   */
   trimHeaderFieldWhiteSpace(active) {
     this.isTrimHeaderFieldWhiteSpace = active;
     return this;
   }
 
+  /**
+   * Set the row index where CSV headers are located
+   * @param {number} indexHeaderValue - Zero-based row index containing headers
+   * @returns {this} For method chaining
+   * @throws {ConfigurationError} If not a valid number
+   */
   indexHeader(indexHeaderValue) {
     if (isNaN(indexHeaderValue)) {
       throw ConfigurationError.invalidHeaderIndex(indexHeaderValue);
@@ -46,11 +79,28 @@ class CsvToJson {
   }
 
 
+  /**
+   * Configure sub-array parsing for special field values
+   * Fields bracketed by delimiter and containing separator are parsed into arrays
+   * @param {string} delimiter - Bracket character (default: '*')
+   * @param {string} separator - Item separator within brackets (default: ',')
+   * @returns {this} For method chaining
+   * @example
+   * // Input: "*val1,val2,val3*"  
+   * // Output: ["val1", "val2", "val3"]
+   * .parseSubArray('*', ',')
+   */
   parseSubArray(delimiter = '*',separator = ',') {
     this.parseSubArrayDelimiter = delimiter;
     this.parseSubArraySeparator = separator;
+    return this;
   }
 
+  /**
+   * Set file encoding for reading CSV files
+   * @param {string} encoding - Node.js supported encoding (e.g., 'utf8', 'latin1', 'ascii')
+   * @returns {this} For method chaining
+   */
   encoding(encoding){
     this.encoding = encoding;
     return this;
@@ -69,11 +119,30 @@ class CsvToJson {
     return this;
   }
 
+  /**
+   * Read a CSV file and write the parsed JSON to an output file
+   * @param {string} fileInputName - Path to input CSV file
+   * @param {string} fileOutputName - Path to output JSON file
+   * @throws {FileOperationError} If file read or write fails
+   * @throws {CsvFormatError} If CSV is malformed
+   */
   generateJsonFileFromCsv(fileInputName, fileOutputName) {
     let jsonStringified = this.getJsonFromCsvStringified(fileInputName);
     fileUtils.writeFile(jsonStringified, fileOutputName);
   }
 
+  /**
+   * Read a CSV file and return parsed data as stringified JSON
+   * @param {string} fileInputName - Path to input CSV file
+   * @returns {string} JSON stringified array of objects
+   * @throws {FileOperationError} If file read fails
+   * @throws {CsvFormatError} If CSV is malformed
+   * @throws {JsonValidationError} If JSON generation fails
+   * @example
+   * const csvToJson = require('convert-csv-to-json');
+   * const jsonString = csvToJson.getJsonFromCsvStringified('resource/input.csv');
+   * console.log(jsonString);
+   */
   getJsonFromCsvStringified(fileInputName) {
     let json = this.getJsonFromCsv(fileInputName);
     let jsonStringified = JSON.stringify(json, undefined, 1);
@@ -81,15 +150,47 @@ class CsvToJson {
     return jsonStringified;
   }
 
+  /**
+   * Read a CSV file and return parsed data as JSON array of objects
+   * @param {string} fileInputName - Path to input CSV file
+   * @returns {Array<object>} Array of objects representing CSV rows
+   * @throws {FileOperationError} If file read fails
+   * @throws {CsvFormatError} If CSV is malformed
+   * @example
+   * const csvToJson = require('convert-csv-to-json');
+   * const rows = csvToJson.getJsonFromCsv('resource/input.csv');
+   * console.log(rows);
+   */
   getJsonFromCsv(fileInputName) {
     let parsedCsv = fileUtils.readFile(fileInputName, this.encoding);
     return this.csvToJson(parsedCsv);
   }
 
+  /**
+   * Parse CSV string content and return as JSON array of objects
+   * @param {string} csvString - CSV content as string
+   * @returns {Array<object>} Array of objects representing CSV rows
+   * @throws {CsvFormatError} If CSV is malformed
+   * @example
+   * const csvToJson = require('convert-csv-to-json');
+   * const rows = csvToJson.csvStringToJson('name,age\nAlice,30');
+   * console.log(rows); // [{ name: 'Alice', age: '30' }]
+   */
   csvStringToJson(csvString) {
     return this.csvToJson(csvString);
   }
 
+  /**
+   * Parse CSV string content and return as stringified JSON
+   * @param {string} csvString - CSV content as string
+   * @returns {string} JSON stringified array of objects
+   * @throws {CsvFormatError} If CSV is malformed
+   * @throws {JsonValidationError} If JSON generation fails
+   * @example
+   * const csvToJson = require('convert-csv-to-json');
+   * const jsonString = csvToJson.csvStringToJsonStringified('name,age\nAlice,30');
+   * console.log(jsonString);
+   */
   csvStringToJsonStringified(csvString) {
     let json = this.csvStringToJson(csvString);
     let jsonStringified = JSON.stringify(json, undefined, 1);
@@ -97,6 +198,14 @@ class CsvToJson {
     return jsonStringified;
   }
 
+  /**
+   * Core CSV parsing logic - converts CSV string to JSON array
+   * Handles quoted fields per RFC 4180 when configured
+   * Applies row mapping and filtering when configured
+   * @param {string} parsedCsv - Raw CSV content as string
+   * @returns {Array<object>} Array of objects with CSV data
+   * @private
+   */
   csvToJson(parsedCsv) {
   	this.validateInputConfig();
     
@@ -230,6 +339,11 @@ class CsvToJson {
     return 0;
   }
 
+  /**
+   * Get the configured field delimiter, or default if not set
+   * @returns {string} Field delimiter character
+   * @private
+   */
   getFieldDelimiter() {
     if (this.delimiter) {
       return this.delimiter;
@@ -237,6 +351,11 @@ class CsvToJson {
     return DEFAULT_FIELD_DELIMITER;
   }
 
+  /**
+   * Get the configured header row index, or default (0) if not set
+   * @returns {number} Header row index
+   * @private
+   */
   getIndexHeader(){
     if(this.indexHeaderValue !== null && !isNaN(this.indexHeaderValue)){
         return this.indexHeaderValue;
@@ -244,6 +363,14 @@ class CsvToJson {
     return 0;
   }
 
+  /**
+   * Build a JSON object from headers and field values
+   * Applies type formatting and sub-array parsing as configured
+   * @param {string[]} headers - Array of header field names
+   * @param {string[]} currentLine - Array of field values
+   * @returns {object} JSON object with header names as keys
+   * @private
+   */
   buildJsonResult(headers, currentLine) {
     let jsonObject = {};
     for (let j = 0; j < headers.length; j++) {
@@ -263,6 +390,12 @@ class CsvToJson {
     return jsonObject;
   }
 
+  /**
+   * Parse a field value into a sub-array using configured delimiter and separator
+   * @param {string} value - Field value to parse
+   * @returns {Array<string|number|boolean>} Array of parsed values
+   * @private
+   */
   buildJsonSubArray(value) {
     let extractedValues = value.substring(
         value.indexOf(this.parseSubArrayDelimiter) + 1,
@@ -278,6 +411,12 @@ class CsvToJson {
     return value;
   }
 
+  /**
+   * Check if a field value should be parsed as a sub-array
+   * @param {string} value - Field value to check
+   * @returns {boolean} True if value is bracketed with sub-array delimiter
+   * @private
+   */
   isParseSubArray(value){
     if(this.parseSubArrayDelimiter){
       if (value && (value.indexOf(this.parseSubArrayDelimiter) === 0 && value.lastIndexOf(this.parseSubArrayDelimiter) === (value.length - 1))) {
@@ -287,6 +426,11 @@ class CsvToJson {
     return false;
   }
 
+  /**
+   * Validate configuration for conflicts and incompatibilities
+   * @throws {ConfigurationError} If incompatible options are set
+   * @private
+   */
   validateInputConfig(){
     if(this.isSupportQuotedField) {
       if(this.getFieldDelimiter() === '"'){
@@ -301,6 +445,12 @@ class CsvToJson {
     }
   }
 
+  /**
+   * Check if a line contains quote characters
+   * @param {string} line - Line to check
+   * @returns {boolean} True if line contains quotes
+   * @private
+   */
   hasQuotes(line) {
     return line.includes('"');
   }
@@ -363,7 +513,12 @@ class CsvToJson {
 
   /**
    * Check if character at index is an escaped quote (double quote)
-   * @returns {boolean}
+   * Escaped quotes appear as "" within quoted fields per RFC 4180
+   * @param {string} line - Line being parsed
+   * @param {number} index - Character index to check
+   * @param {boolean} insideQuoted - Whether currently inside a quoted field
+   * @returns {boolean} True if character is an escaped quote
+   * @private
    */
   isEscapedQuote(line, index, insideQuoted) {
     return insideQuoted && 
@@ -373,7 +528,13 @@ class CsvToJson {
 
   /**
    * Check if this is an empty quoted field: "" before delimiter or end of line
-   * @returns {boolean}
+   * @param {string} line - Line being parsed
+   * @param {number} index - Character index to check
+   * @param {boolean} insideQuoted - Whether currently inside a quoted field
+   * @param {string} currentField - Current field accumulation
+   * @param {string} delimiter - Field delimiter character
+   * @returns {boolean} True if this represents an empty quoted field
+   * @private
    */
   isEmptyQuotedField(line, index, insideQuoted, currentField, delimiter) {
     if (insideQuoted || currentField !== '' || index + 1 >= line.length) {

package/src/csvToJsonAsync.js

@@ -1,17 +1,27 @@
+/* globals CsvFormatError, FileOperationError */
 'use strict';
 
 const fileUtils = require('./util/fileUtils');
 const csvToJson = require('./csvToJson');
 const { InputValidationError } = require('./util/errors');
 
+/**
+ * Asynchronous CSV to JSON converter
+ * Proxies configuration to sync instance but provides async file I/O methods
+ */
 class CsvToJsonAsync {
+    /**
+     * Constructor initializes proxy to sync csvToJson instance
+     */
     constructor() {
         // Proxy the configuration methods to the sync instance
         this.csvToJson = csvToJson;
     }
 
     /**
-     * Set value type formatting
+     * Enable or disable automatic type formatting for values
+     * @param {boolean} active - Whether to format values by type
+     * @returns {this} For method chaining
      */
     formatValueByType(active) {
         this.csvToJson.formatValueByType(active);
@@ -19,7 +29,9 @@ class CsvToJsonAsync {
     }
 
     /**
-     * Set quoted field support
+     * Enable or disable support for RFC 4180 quoted fields
+     * @param {boolean} active - Whether to support quoted fields
+     * @returns {this} For method chaining
      */
     supportQuotedField(active) {
         this.csvToJson.supportQuotedField(active);
@@ -27,7 +39,9 @@ class CsvToJsonAsync {
     }
 
     /**
-     * Set field delimiter
+     * Set the field delimiter character
+     * @param {string} delimiter - Character(s) to use as field separator
+     * @returns {this} For method chaining
      */
     fieldDelimiter(delimiter) {
         this.csvToJson.fieldDelimiter(delimiter);
@@ -35,7 +49,9 @@ class CsvToJsonAsync {
     }
 
     /**
-     * Trim header field whitespace
+     * Configure whitespace handling in header field names
+     * @param {boolean} active - If true, removes all whitespace; if false, only trims edges
+     * @returns {this} For method chaining
      */
     trimHeaderFieldWhiteSpace(active) {
         this.csvToJson.trimHeaderFieldWhiteSpace(active);
@@ -43,7 +59,9 @@ class CsvToJsonAsync {
     }
 
     /**
-     * Set header index
+     * Set the row index where CSV headers are located
+     * @param {number} indexHeader - Zero-based row index containing headers
+     * @returns {this} For method chaining
      */
     indexHeader(indexHeader) {
         this.csvToJson.indexHeader(indexHeader);
@@ -51,7 +69,10 @@ class CsvToJsonAsync {
     }
 
     /**
-     * Set sub-array parsing options
+     * Configure sub-array parsing for special field values
+     * @param {string} delimiter - Bracket character (default: '*')
+     * @param {string} separator - Item separator within brackets (default: ',')
+     * @returns {this} For method chaining
      */
     parseSubArray(delimiter = '*', separator = ',') {
         this.csvToJson.parseSubArray(delimiter, separator);
@@ -59,7 +80,9 @@ class CsvToJsonAsync {
     }
 
     /**
-     * Set row mapper function to transform each row
+     * Set a mapper function to transform each row after conversion
+     * @param {Function} mapperFn - Function receiving (row, index) that returns transformed row or null to filter
+     * @returns {this} For method chaining
      */
     mapRows(mapperFn) {
         this.csvToJson.mapRows(mapperFn);
@@ -67,7 +90,9 @@ class CsvToJsonAsync {
     }
 
     /**
-     * Set encoding
+     * Set file encoding for reading CSV files
+     * @param {string} encoding - Node.js supported encoding (e.g., 'utf8', 'latin1')
+     * @returns {this} For method chaining
      */
     encoding(encoding) {
         this.csvToJson.encoding = encoding;
@@ -75,7 +100,12 @@ class CsvToJsonAsync {
     }
 
     /**
-     * Async version of generateJsonFileFromCsv
+     * Read a CSV file and write parsed JSON to an output file (async)
+     * @param {string} fileInputName - Path to input CSV file
+     * @param {string} fileOutputName - Path to output JSON file
+     * @returns {Promise<void>}
+     * @throws {FileOperationError} If file operations fail
+     * @throws {CsvFormatError} If CSV is malformed
      */
     async generateJsonFileFromCsv(fileInputName, fileOutputName) {
         const jsonStringified = await this.getJsonFromCsvStringified(fileInputName);
@@ -83,7 +113,11 @@ class CsvToJsonAsync {
     }
 
     /**
-     * Async version that returns stringified JSON from CSV file
+     * Read a CSV file and return parsed data as stringified JSON (async)
+     * @param {string} fileInputName - Path to input CSV file
+     * @returns {Promise<string>} JSON stringified array of objects
+     * @throws {FileOperationError} If file read fails
+     * @throws {CsvFormatError} If CSV is malformed
      */
     async getJsonFromCsvStringified(fileInputName) {
         const json = await this.getJsonFromCsvAsync(fileInputName);
@@ -91,8 +125,19 @@ class CsvToJsonAsync {
     }
 
     /**
-     * Main async API method. If options.raw is true, treats input as CSV string.
-     * Otherwise reads from file path.
+     * Main async API method for reading CSV and returning parsed JSON
+     * Supports reading from file path or parsing CSV string content
+     * @param {string} inputFileNameOrCsv - File path or CSV string content
+     * @param {object} options - Configuration options
+     * @param {boolean} options.raw - If true, treats input as CSV string; if false, reads from file
+     * @returns {Promise<Array<object>>} Array of objects representing CSV rows
+     * @throws {InputValidationError} If input is invalid
+     * @throws {FileOperationError} If file read fails
+     * @throws {CsvFormatError} If CSV is malformed
+     * @example
+     * const csvToJson = require('convert-csv-to-json');
+     * const data = await csvToJson.getJsonFromCsvAsync('resource/input.csv');
+     * console.log(data);
      */
     async getJsonFromCsvAsync(inputFileNameOrCsv, options = {}) {
         if (inputFileNameOrCsv === null || inputFileNameOrCsv === undefined) {
@@ -116,14 +161,29 @@ class CsvToJsonAsync {
     }
 
     /**
-     * Parse CSV string to JSON asynchronously
+     * Parse CSV string to JSON array (async)
+     * @param {string} csvString - CSV content as string
+     * @param {object} options - Configuration options (default: { raw: true })
+     * @returns {Promise<Array<object>>} Array of objects representing CSV rows
+     * @throws {CsvFormatError} If CSV is malformed
+     * @example
+     * const csvToJson = require('convert-csv-to-json');
+     * const data = await csvToJson.csvStringToJsonAsync('name,age\nAlice,30');
+     * console.log(data);
      */
     csvStringToJsonAsync(csvString, options = { raw: true }) {
         return this.getJsonFromCsvAsync(csvString, options);
     }
 
     /**
-     * Parse CSV string to stringified JSON asynchronously
+     * Parse CSV string to stringified JSON (async)
+     * @param {string} csvString - CSV content as string
+     * @returns {Promise<string>} JSON stringified array of objects
+     * @throws {CsvFormatError} If CSV is malformed
+     * @example
+     * const csvToJson = require('convert-csv-to-json');
+     * const jsonString = await csvToJson.csvStringToJsonStringifiedAsync('name,age\nAlice,30');
+     * console.log(jsonString);
      */
     async csvStringToJsonStringifiedAsync(csvString) {
         const json = await this.csvStringToJsonAsync(csvString);

package/src/util/errors.js

@@ -10,6 +10,12 @@
  * Provides consistent error formatting and context
  */
 class CsvParsingError extends Error {
+    /**
+     * Create a CSV parsing error
+     * @param {string} message - Error message
+     * @param {string} code - Error code for identification
+     * @param {object} context - Additional context information (default: {})
+     */
     constructor(message, code, context = {}) {
         super(message);
         this.name = 'CsvParsingError';
@@ -18,6 +24,10 @@ class CsvParsingError extends Error {
         Error.captureStackTrace(this, this.constructor);
     }
 
+    /**
+     * Convert error to formatted string with context information
+     * @returns {string} Formatted error message including context
+     */
     toString() {
         let output = `${this.name}: ${this.message}`;
         
@@ -31,6 +41,12 @@ class CsvParsingError extends Error {
         return output;
     }
 
+    /**
+     * Format a context value for display in error message
+     * @param {*} value - Value to format
+     * @returns {string} Formatted value string
+     * @private
+     */
     formatValue(value) {
         if (value === null) return 'null';
         if (value === undefined) return 'undefined';
@@ -42,8 +58,16 @@ class CsvParsingError extends Error {
 
 /**
  * Input validation errors
+ * Thrown when function parameters don't meet expected type or value requirements
  */
 class InputValidationError extends CsvParsingError {
+    /**
+     * Create an input validation error
+     * @param {string} paramName - Name of the invalid parameter
+     * @param {string} expectedType - Expected type description
+     * @param {string} receivedType - Actual type received
+     * @param {string} details - Additional error details (optional)
+     */
     constructor(paramName, expectedType, receivedType, details = '') {
         const message = 
             `Invalid input: Parameter '${paramName}' is required.\n` +
@@ -61,13 +85,27 @@ class InputValidationError extends CsvParsingError {
 
 /**
  * Configuration-related errors
+ * Thrown when configuration options conflict or are invalid
  */
 class ConfigurationError extends CsvParsingError {
+    /**
+     * Create a configuration error
+     * @param {string} message - Error message
+     * @param {object} conflictingOptions - Configuration options in conflict (optional)
+     */
     constructor(message, conflictingOptions = {}) {
         super(message, 'CONFIGURATION_ERROR', conflictingOptions);
         this.name = 'ConfigurationError';
     }
 
+    /**
+     * Create error for quoted field configuration conflict
+     * Occurs when quote character is used as delimiter while quoted fields are enabled
+     * @param {string} optionName - Name of the conflicting option
+     * @param {string} value - Value that causes the conflict
+     * @returns {ConfigurationError} Configured error instance
+     * @static
+     */
     static quotedFieldConflict(optionName, value) {
         return new ConfigurationError(
             `Configuration conflict: supportQuotedField() is enabled, but ${optionName} is set to '${value}'.\n` +
@@ -80,6 +118,13 @@ class ConfigurationError extends CsvParsingError {
         );
     }
 
+    /**
+     * Create error for invalid header index
+     * Occurs when indexHeader() receives non-numeric value
+     * @param {*} value - Invalid header index value
+     * @returns {ConfigurationError} Configured error instance
+     * @static
+     */
     static invalidHeaderIndex(value) {
         return new ConfigurationError(
             `Invalid configuration: indexHeader() expects a numeric value.\n` +
@@ -95,13 +140,25 @@ class ConfigurationError extends CsvParsingError {
 
 /**
  * CSV parsing errors with detailed context
+ * Thrown when CSV format is invalid or malformed
  */
 class CsvFormatError extends CsvParsingError {
+    /**
+     * Create a CSV format error
+     * @param {string} message - Error message
+     * @param {object} context - Additional context information (optional)
+     */
     constructor(message, context = {}) {
         super(message, 'CSV_FORMAT_ERROR', context);
         this.name = 'CsvFormatError';
     }
 
+    /**
+     * Create error for missing CSV header row
+     * Occurs when no valid header row is found in CSV
+     * @returns {CsvFormatError} Configured error instance
+     * @static
+     */
     static missingHeader() {
         return new CsvFormatError(
             `CSV parsing error: No header row found.\n` +
@@ -114,6 +171,13 @@ class CsvFormatError extends CsvParsingError {
         );
     }
 
+    /**
+     * Create error for mismatched quotes in CSV
+     * Occurs when quoted fields are not properly closed
+     * @param {string} location - Where the error occurred (default: 'CSV')
+     * @returns {CsvFormatError} Configured error instance
+     * @static
+     */
     static mismatchedQuotes(location = 'CSV') {
         return new CsvFormatError(
             `CSV parsing error: Mismatched quotes detected in ${location}.\n` +
@@ -135,8 +199,15 @@ class CsvFormatError extends CsvParsingError {
 
 /**
  * File operation errors
+ * Thrown when file read or write operations fail
  */
 class FileOperationError extends CsvParsingError {
+    /**
+     * Create a file operation error
+     * @param {string} operation - Type of operation that failed (e.g., 'read', 'write')
+     * @param {string} filePath - Path to the file where operation failed
+     * @param {Error} originalError - The underlying error object from Node.js
+     */
     constructor(operation, filePath, originalError) {
         const message = 
             `File operation error: Failed to ${operation} file.\n` +
@@ -160,8 +231,14 @@ class FileOperationError extends CsvParsingError {
 
 /**
  * JSON validation errors
+ * Thrown when parsed CSV data cannot be converted to valid JSON
  */
 class JsonValidationError extends CsvParsingError {
+    /**
+     * Create a JSON validation error
+     * @param {string} csvData - The CSV data that failed validation
+     * @param {Error} originalError - The underlying JSON parsing error
+     */
     constructor(csvData, originalError) {
         const message = 
             `JSON validation error: The parsed CSV data generated invalid JSON.\n` +
@@ -184,13 +261,25 @@ class JsonValidationError extends CsvParsingError {
 
 /**
  * Browser-specific errors
+ * Thrown when browser API operations fail
  */
 class BrowserApiError extends CsvParsingError {
+    /**
+     * Create a browser API error
+     * @param {string} message - Error message
+     * @param {object} context - Additional context information (optional)
+     */
     constructor(message, context = {}) {
         super(message, 'BROWSER_API_ERROR', context);
         this.name = 'BrowserApiError';
     }
 
+    /**
+     * Create error for unavailable FileReader API
+     * Occurs when browser doesn't support FileReader
+     * @returns {BrowserApiError} Configured error instance
+     * @static
+     */
     static fileReaderNotAvailable() {
         return new BrowserApiError(
             `Browser compatibility error: FileReader API is not available.\n` +
@@ -202,6 +291,13 @@ class BrowserApiError extends CsvParsingError {
         );
     }
 
+    /**
+     * Create error for file parsing failure in browser
+     * Occurs when file read or CSV parse fails
+     * @param {Error} originalError - The underlying error that occurred
+     * @returns {BrowserApiError} Configured error instance
+     * @static
+     */
     static parseFileError(originalError) {
         return new BrowserApiError(
             `Browser file parsing error: Failed to read and parse the file.\n` +