Low-level API

/**
 * Get encoder instance for incremental encoding
 * @param encoding - Target encoding name
 * @param options - Encoding options
 * @returns Encoder instance with write() and end() methods
 */
function getEncoder(encoding, options);

const iconv = require('iconv-lite');

// Basic encoder usage
const encoder = iconv.getEncoder('utf16le');
const chunk1 = encoder.write('Hello ');
const chunk2 = encoder.write('World');
const finalChunk = encoder.end();

const result = Buffer.concat([chunk1, chunk2, finalChunk || Buffer.alloc(0)]);

// Encoder with BOM
const encoderWithBOM = iconv.getEncoder('utf16le', { addBOM: true });
const encoded = encoderWithBOM.write('Text with BOM');
const final = encoderWithBOM.end();

/**
 * Get decoder instance for incremental decoding
 * @param encoding - Source encoding name
 * @param options - Decoding options
 * @returns Decoder instance with write() and end() methods
 */
function getDecoder(encoding, options);

const iconv = require('iconv-lite');

// Basic decoder usage
const decoder = iconv.getDecoder('gbk');
const str1 = decoder.write(buffer1);
const str2 = decoder.write(buffer2);
const finalStr = decoder.end();

const result = str1 + str2 + (finalStr || '');

// Decoder with BOM preservation
const decoder = iconv.getDecoder('utf16le', { stripBOM: false });
const decoded = decoder.write(bufferWithBOM);

/**
 * Get internal codec for encoding
 * @param encoding - Encoding name
 * @returns Codec object with encoder and decoder constructors
 */
function getCodec(encoding);

const iconv = require('iconv-lite');

// Get codec information
const codec = iconv.getCodec('utf8');
console.log(codec.encodingName); // Canonical encoding name
console.log(codec.bomAware);     // Boolean indicating BOM support

// Create encoder/decoder instances directly
const encoder = new codec.encoder({}, codec);
const decoder = new codec.decoder({}, codec);

// Check codec properties
if (codec.bomAware) {
  console.log('This encoding supports BOM handling');
}

/**
 * Encoder stream interface
 */
const EncoderStream = {
  /**
   * Encode a string chunk
   * @param str - String to encode
   * @returns Encoded buffer chunk
   */
  write(str),
  
  /**
   * Finalize encoding and get any remaining bytes
   * @returns Final buffer chunk or undefined
   */
  end()
};

/**
 * Decoder stream interface
 */
const DecoderStream = {
  /**
   * Decode a buffer chunk
   * @param buf - Buffer to decode
   * @returns Decoded string chunk
   */
  write(buf),
  
  /**
   * Finalize decoding and get any remaining characters
   * @returns Final string chunk or undefined
   */
  end()
};

/**
 * Codec interface
 */
const Codec = {
  /** Canonical encoding name */
  encodingName,
  /** Whether this encoding supports BOM handling */
  bomAware,
  /** Encoder constructor */
  encoder,
  /** Decoder constructor */
  decoder
};

/**
 * Internal cache of loaded codec instances
 * Object with null prototype containing codec instances keyed by encoding name
 */
const _codecDataCache;

/**
 * Normalize encoding name to canonical form
 * @param encoding - Raw encoding name
 * @returns Canonicalized encoding name (lowercase, alphanumeric only)
 */
function _canonicalizeEncoding(encoding);

const iconv = require('iconv-lite');

// Encoding name normalization
console.log(iconv._canonicalizeEncoding('UTF-8'));      // 'utf8'
console.log(iconv._canonicalizeEncoding('iso-8859-1')); // 'iso88591'
console.log(iconv._canonicalizeEncoding('Windows-1252:2000')); // 'windows1252'

/**
 * Registry of all available encodings and aliases
 * Lazy-loaded on first access, initially null
 */
const encodings;

/** BOM (Byte Order Mark) character constant */
const BOMChar; // "\uFEFF"

/**
 * Encoder wrapper that prepends BOM to output
 * @param encoder - Base encoder instance
 * @param options - Options (unused)
 */
class PrependBOMWrapper {
  constructor(encoder, options);
  write(str);
  end();
}

/**
 * Decoder wrapper that strips BOM from output
 * @param decoder - Base decoder instance
 * @param options - Options with optional stripBOM callback
 */
class StripBOMWrapper {
  constructor(decoder, options);
  write(buf);
  end();
}

const iconv = require('iconv-lite');

// Custom stream implementation
class CustomEncodingStream extends Transform {
  constructor(encoding, options) {
    super(options);
    this.encoder = iconv.getEncoder(encoding, options);
  }
  
  _transform(chunk, encoding, callback) {
    try {
      const result = this.encoder.write(chunk.toString());
      callback(null, result);
    } catch (err) {
      callback(err);
    }
  }
  
  _flush(callback) {
    try {
      const final = this.encoder.end();
      callback(null, final);
    } catch (err) {
      callback(err);
    }
  }
}