} catch (final IOException e) {
            closeResources(httpRequest, responseData);
            throw new CrawlingAccessException("I/O exception(" + e.getMessage() + "): " + url, e);
        } catch (final CrawlerSystemException e) {
            closeResources(httpRequest, responseData);
            throw e;
        } catch (final Exception e) {
            closeResources(httpRequest, responseData);

        rewritten = rewritten.replaceAll("\\@youtube\\(([a-zA-Z\\-_]+)\\,([^\\s<]+)\\)\\@",
            "<details> \n" +
                "  <summary>📺 Watch the $1</summary> \n" +
                "  <div class=\"youtube-video\"> \n" +
                "    <div class=\"youtube-player\"> \n" +

 <span style="background-color:#C4A000"><font color="#2E3436">╰─────────────────────────────────────────────────────╯</font></span>

<font color="#4E9A06">INFO</font>:     Will watch for changes in these directories: [&apos;/home/user/code/awesomeapp&apos;]
<font color="#4E9A06">INFO</font>:     Uvicorn running on <b>http://127.0.0.1:8000</b> (Press CTRL+C to quit)

            circuitBreaker.call(() -> {
                try {
                    doConnectInternal();
                    return null;
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            });
        } catch (SimpleCircuitBreaker.CircuitBreakerOpenException e) {
            // Log circuit breaker rejection

        dataStoreMap.put(dataStore.getClass().getSimpleName().toLowerCase(Locale.ROOT), dataStore);
    }

    /**
     * Retrieves a data store instance by name.
     * The lookup is case-insensitive and will match both registered names
     * and class simple names.
     *
     * @param name the name of the data store to retrieve, may be null
     * @return the data store instance if found, null if not found or name is null
     */

            } catch (ModelParseException e) {
                if (!strict) {
                    throw e;
                }

                options.put(ModelProcessor.IS_STRICT, Boolean.FALSE);

                try {
                    model = modelProcessor.read(modelSource.getInputStream(), options);
                } catch (ModelParseException ne) {

                }
                try {
                    // store
                    CrawlingParameterUtil.getDataService().store(accessResult);
                } catch (final Exception e) {
                    crawlerContext.decrementAndGetAccessCount();
                    if (urlQueueService.visited(urlQueue)) {
                        // document already exists

        } else {
            return create(100);
        }
    }

    /**
     * Creates new instance of problem collector with the specified maximum problem count limit,
     * but only preserves problems that match the given filter.
     *
     * @param <P>           the type of problem
     * @param maxCountLimit the maximum number of problems to preserve
     * @param filter        predicate to decide which problems to record

          "match": "*_bn",
          "mapping": {
            "type": "text",
            "analyzer": "empty_analyzer"
          }
        }
      },
      {
        "lang_ca": {
          "match": "*_ca",
          "mapping": {
            "type": "text",
            "analyzer": "catalan_analyzer"
          }
        }
      },
      {
        "lang_ca": {
          "match": "*_ckb-iq",
          "mapping": {

            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();