}

  private fun loomThreadFactory(): ThreadFactory {
    val ofVirtual = Thread::class.java.getMethod("ofVirtual").invoke(null)

    return Class.forName("java.lang.Thread\$Builder")
      .getMethod("factory")
      .invoke(ofVirtual) as ThreadFactory
  }

  private fun isLoom(): Boolean {
    return getPlatformSystemProperty() == LOOM_PROPERTY
  }

    static Method newStringUnsafeMethod = null;

    static {
        try {
            final Class<?> sharedSecretsClass = Class.forName("sun.misc.SharedSecrets");
            javaLangAccess = sharedSecretsClass.getDeclaredMethod("getJavaLangAccess").invoke(null);
            final Class<?> javaLangAccessClass = Class.forName("sun.misc.JavaLangAccess");
            newStringUnsafeMethod = javaLangAccessClass.getMethod("newStringUnsafe", char[].class);

    URLClassLoader shadowLoader = new URLClassLoader(parseJavaClassPath(), null);
    @SuppressWarnings("unchecked")
    Class<WillBeUnloadedException> shadowClass =
        (Class<WillBeUnloadedException>)
            Class.forName(WillBeUnloadedException.class.getName(), false, shadowLoader);
    assertNotSame(shadowClass, WillBeUnloadedException.class);
    getChecked(immediateFuture("foo"), shadowClass);
    return new WeakReference<>(shadowLoader);

            } catch (final LinkageError e) {
                // drop through...
            }
        }

        try {
            // last chance - classic model
            return Class.forName(name);
        } catch (final Exception e) {
            throw new TypeNotPresentException(name, e);
        } catch (final LinkageError e) {
            throw new TypeNotPresentException(name, e);
        }
    }

        }
    }

    protected boolean isSupportedCharset(final String charsetName) {
        if (charsetName == null) {
            return false;
        }
        try {
            Charset.forName(charsetName);
        } catch (final Exception e) {
            return false;
        }
        return true;
    }

    protected String loadCharset(final InputStream inputStream) {

   * this class loader, but at least the world doesn't end.
   */
  static class DirectLoader implements FinalizerLoader {
    @Override
    public Class<?> loadFinalizer() {
      try {
        return Class.forName(FINALIZER_CLASS_NAME);
      } catch (ClassNotFoundException e) {
        throw new AssertionError(e);
      }
    }
  }

  /** Looks up Finalizer.startFinalizer(). */

     * </p>
     *
     * @return ログアダプタのファクトリ
     */
    protected static LoggerAdapterFactory getLoggerAdapterFactory() {
        // TODO
        try {
            Class.forName("org.apache.commons.logging.LogFactory");
            return new JclLoggerAdapterFactory();
        } catch (final Throwable ignore) {
            return new JulLoggerAdapterFactory();
        }
    }

    /**

      }
    };

    public abstract boolean isExpectedType(Throwable cause);
  }

  private static boolean annotatedTypeExists() {
    try {
      Class.forName("java.lang.reflect.AnnotatedType");
    } catch (ClassNotFoundException e) {
      return false;
    }
    return true;
  }

  private static final NullnessAnnotationReader NULLNESS_ANNOTATION_READER =

      }
    }
  }

  private static final boolean ANNOTATED_TYPE_EXISTS = initAnnotatedTypeExists();

  private static boolean initAnnotatedTypeExists() {
    try {
      Class.forName("java.lang.reflect.AnnotatedType");
    } catch (ClassNotFoundException e) {
      return false;
    }
    return true;
  }

    private static final Logger logger = LoggerFactory.getLogger(AbstractCrawlerService.class);

    private static final String ID_SEPARATOR = ".";

    private static final Charset UTF_8 = Charset.forName("UTF-8");

    protected static final String ID = "id";

    protected static final String SESSION_ID = "sessionId";

    protected static final String URL = "url";