*/
    public SitemapSet parse(final InputStream in) {
        return parse(in, true);
    }

    /**
     * Parses a sitemap from the given input stream.
     * @param in the input stream to parse
     * @param recursive whether to recursively parse compressed files
     * @return the parsed sitemap set
     */
    protected SitemapSet parse(final InputStream in, final boolean recursive) {

        } finally {
            FileUtil.deleteInBackground(tempFile);
        }
    }

    /**
     * Creates a parse context.
     *
     * @param parser A parser.
     * @param params A map of parameters.
     * @return a parse context.
     */
    protected ParseContext createParseContext(final Parser parser, final Map<String, String> params) {

            File file = null;
            try {
                file = new File(new URI(filePath));
            } catch (final URISyntaxException e) {
                logger.warn("Could not parse url: " + filePath, e);
            }

            if (file == null) {
                responseData.setHttpStatusCode(Constants.NOT_FOUND_STATUS_CODE);
                responseData.setCharSet(charset);

            if (responseData.getCharSet() != null) {
                is.setEncoding(responseData.getCharSet());
            }
            parser.parse(is);
        } catch (final Exception e) {
            throw new CrawlingAccessException("Could not parse " + responseData.getUrl(), e);
        }
        final Document document = parser.getDocument();

        final StringBuilder buf = new StringBuilder(1000);

                        }
                    }
                }
            } catch (final IOException e) {
                logger.warn("Failed to parse annotation.", e);
            }
        }
    }

    /**
     * Extracts text from an embedded file using the appropriate extractor.
     * @param filename the filename of the embedded file

 * The default value for {@code targetNodePath} is "//HTML/BODY | //@alt | //@title", which selects the body of the HTML document,
 * as well as the alt and title attributes.
 * </p>
 * <p>
 * The class uses {@link DOMParser} to parse HTML documents and {@link XPathAPI} to execute XPath queries.
 * It also provides methods to add custom features and properties to the {@link DOMParser}.
 * </p>
 * <p>

            parser.setDefaultOperator(StandardQueryConfigHandler.Operator.AND);

            // Parse with the first field if available, otherwise use "default"
            String defaultField = fields != null && fields.length > 0 ? fields[0] : "default";
            termQueryList = getTermQueryList(parser.parse(q, defaultField), fields);
        } catch (final Exception e) {
            return keywords;
        }

        try (final InputStream is = responseData.getResponseBody()) {
            final DOMParser parser = getDomParser();
            parser.parse(new InputSource(is));
            final Document document = parser.getDocument();
            // base href
            final String baseHref = getBaseHref(document);
            URI uri;
            try {

import org.opensearch.action.admin.indices.analyze.AnalyzeAction.AnalyzeToken;

/**
 * DefaultContentsParser is an implementation of the ContentsParser interface.
 * It provides methods to parse search words, query logs, and documents into SuggestItem objects.
 *
 * <p>This class uses various utilities such as ReadingConverter, Normalizer, and SuggestAnalyzer
 * to process and analyze the input data.</p>
 *

            } else {
                file = new SmbFile(filePath, smbAuthentication.getAuthentication());
            }
        } catch (final MalformedURLException e) {
            logger.warn("Could not parse url: " + filePath, e);
        }

        if (logger.isDebugEnabled()) {
            logger.debug("Processing SmbFile: {}", filePath);
        }

        try {
            if (file == null) {