*/
    public static PopularWordHelper getPopularWordHelper() {
        return getComponent(POPULAR_WORD_HELPER);
    }

    /**
     * Gets the path mapping helper component.
     * @return The path mapping helper.
     */
    public static PathMappingHelper getPathMappingHelper() {
        return getComponent(PATH_MAPPING_HELPER);
    }

    /**

        } catch (final OfficeException e) {
            throw new CrawlerSystemException("Failed to stop officeManager.", e);
        }
    }

    /**
     * Adds a conversion rule for mapping input file extensions to output extensions.
     *
     * @param inExt the input file extension
     * @param outExt the output file extension
     */

import org.codelibs.fess.util.ComponentUtil;

/**
 * Interface for transforming and processing crawled documents in Fess.
 * Provides utility methods for URL processing, site extraction, data mapping,
 * and field configuration handling during the document transformation process.
 */
public interface FessTransformer {

    /**
     * Synchronized LRU cache for storing parent URL encodings.

/**
 * will also strip BOM from the source
 */
@Throws(IOException::class)
internal fun BufferedSource.readBomAsCharset(default: Charset): Charset =
  when (select(UNICODE_BOMS)) {
    // a mapping from the index of encoding methods in UNICODE_BOMS to its corresponding encoding method
    0 -> UTF_8
    1 -> UTF_16BE
    2 -> UTF_32LE
    3 -> UTF_16LE
    4 -> UTF_32BE
    -1 -> default

import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException;

/**
 * A semi-persistent mapping from keys to values. Values are automatically loaded by the cache, and
 * are stored in the cache until either evicted or manually invalidated. The common way to build
 * instances is using {@link CacheBuilder}.
 *

After import, verify:
- **Crawler > Web**: Check web crawling configurations
- **Crawler > File**: Check file crawling configurations (SMB, FTP)
- **System > General**: Verify URL patterns and filters

**GSA Configuration Mapping**

| GSA Setting | Fess Equivalent |
|-------------|----------------|
| Collection | WebConfig or FileConfig |
| Start URLs | URLs field in crawl config |
| Good URL Pattern | Included URLs (regex) |

    }
}
`,
		// Built-in user-to-policies mapping should be imported without errors
		// even if LDAP is enabled.
		userPolicyMappingsFile: `{
  "foo": {
    "version": 0,
    "policy": "readwrite",
    "updatedAt": "2024-04-23T21:34:43.815519816Z"
  }
}
`,
		// Contains:
		//
		// 1. duplicate mapping with same policy, we should not error out;
		//

    public static final String LABELS_notification_to = "{labels.notification_to}";

    /** The key of the message: Path Mapping */
    public static final String LABELS_pathmap_configuration = "{labels.pathmap_configuration}";

    /** The key of the message: Path Mapping */
    public static final String LABELS_pathmap_title_details = "{labels.pathmap_title_details}";

    /** The key of the message: Disabled */

        if (allowsParallelEdges()) {
          return super.edges(); // Defer to AbstractGraph implementation.
        }

        // Optimized implementation assumes no parallel edges (1:1 edge to EndpointPair mapping).
        return new AbstractSet<EndpointPair<N>>() {
          @Override
          public Iterator<EndpointPair<N>> iterator() {
            return Iterators.transform(

    }
    double xSumOfSquaresOfDeltas = xStats.sumOfSquaresOfDeltas();
    if (xSumOfSquaresOfDeltas > 0.0) {
      if (yStats.sumOfSquaresOfDeltas() > 0.0) {
        return LinearTransformation.mapping(xStats.mean(), yStats.mean())
            .withSlope(sumOfProductsOfDeltas / xSumOfSquaresOfDeltas);
      } else {
        return LinearTransformation.horizontal(yStats.mean());
      }
    } else {