}
            }
        }

    }

    /**
     * Detects the MIME type of the content.
     *
     * @param out the deferred file output stream
     * @return the detected MIME type
     * @throws IOException if an I/O error occurs
     */
    protected String getMimeType(final DeferredFileOutputStream out) throws IOException {

     * @return the detected content type
     */
    String getContentType(InputStream is, String filename);

    /**
     * Determines the content type of the given input stream using the provided parameters.
     * @param is the input stream to analyze
     * @param params the parameters containing additional information like filename
     * @return the detected content type
     */

import org.codelibs.fess.crawler.helper.MimeTypeHelper;

/**
 * MimeTypeHelperImpl is a helper class that detects the MIME type of a given input stream or filename.
 * It uses the Apache Tika library to detect the MIME type.
 *
 * <p>
 * This class provides methods to:
 * </p>
 * <ul>
 *   <li>Detect the MIME type based on the input stream and filename.</li>
 *   <li>Normalize the filename to handle special characters.</li>

    /**
     * This class is a parser that detects the document type.
     */
    protected class TikaDetectParser extends CompositeParser {
        private static final long serialVersionUID = 1L;

        /**
         * The type detector used by this parser to auto-detect the type of a
         * document.
         */
        private final Detector detector; // always set in the constructor

        /**

     */
    protected ExtractData createExtractData(final String content) {
        return new ExtractData(extractString(content));
    }

    /**
     * Detects the encoding of the input stream.
     * @param bis The buffered input stream.
     * @return The detected encoding.
     */
    protected String getEncoding(final BufferedInputStream bis) {
        final byte[] b = new byte[preloadSizeForCharset];
        try {

 * It also provides methods to add custom features and properties to the {@link DOMParser}.
 * </p>
 * <p>
 * The encoding of the HTML document is automatically detected using a regular expression that matches the charset attribute in the meta tag.
 * </p>
 *
 */
public class HtmlXpathExtractor extends AbstractXmlExtractor {
    /**

        } catch (final Exception e) {
            return false;
        }
        return true;
    }

    /**
     * Loads and detects the character set from the input stream.
     *
     * @param inputStream the input stream to read from
     * @return the detected character set name, or null if not found
     * @throws CrawlingAccessException if an error occurs while reading the content
     */

     a low one
   * The priority for containers normally need to be higher than for
     the things they contain, so they don't accidently get detected
     as what's in them
   * For logic too complex to be expressed in a magic match, do the best
     you can here, then provide a Custom Detector for the rest
-->
<mime-info xmlns:tika="https://tika.apache.org/">

  <mime-type type="application/activemessage"/>

        this.client = client;
        this.request = request;
    }

    /**
     * Executes the request.
     * @return A Promise that will be resolved with the response or rejected with an error.
     */
    public Deferred<Res>.Promise execute() {
        return request.execute(client);
    }

import org.apache.logging.log4j.Logger;
import org.codelibs.core.io.FileUtil;

/**
 * A custom InputStream that wraps a temporary file. This class ensures that the temporary file
 * is deleted when the stream is closed.
 */
public class TemporaryFileInputStream extends InputStream {
    private static final Logger logger = LogManager.getLogger(TemporaryFileInputStream.class);

    private final File tempFile;