uq.setUrl(d.getUrl());
                    uq.setWeight(d.getWeight());
                    return uq;
                })
                .collect(Collectors.toList());

        if (!childList.isEmpty()) {
            CrawlingParameterUtil.getUrlQueueService().offerAll(crawlerContext.getSessionId(), childList);
        }
    }

    /**
     * Gets the transformer.

        private static final List<BuilderProblem.Severity> REVERSED_ORDER = Arrays.stream(
                        BuilderProblem.Severity.values())
                .sorted(Comparator.reverseOrder())
                .toList();

        private Impl(int maxCountLimit, Predicate<? super P> filter) {
            if (maxCountLimit < 0) {
                throw new IllegalArgumentException("maxCountLimit must be non-negative");
            }

            if (context.options().showErrors().orElse(false)) {
                for (BuilderProblem problem :
                        settingsResult.getProblems().problems().toList()) {
                    context.logger.warn(problem.getMessage() + " @ " + problem.getLocation());
                }
            }
            context.logger.info("");
        }
        return () -> {

                        .stream()
                        .map(protwordsItem -> createEditBody(protwordsItem, dictId))
                        .collect(Collectors.toList())).status(ApiResult.Status.OK).result());
    }

    /**
     * Retrieves a specific stemmer override dictionary item by ID.
     *
     * @param dictId the dictionary ID

                }
            }
        });
    }

    private static List<String> ps() {
        return run(determinePsCommand()).assertZeroExit().stdout.lines().collect(Collectors.toList());
    }

    private static String[] determinePsCommand() {
        if (isWindows()) {

                    }
                }
                //noinspection unchecked
                return (Q) list(list.stream().sorted(getPriorityComparator()).toList(), this::getInstance);
            };
        }

        private <Q> Supplier<Q> getMapSupplier(Key<Q> key) {
            Key<?> keyType = key.getTypeParameter(0);

            return result.getArtifactResults().stream()
                    .filter(ArtifactResult::isResolved)
                    .map(ArtifactResult::getArtifact)
                    .collect(Collectors.toList());
        } catch (PluginResolutionException | InterpolatorException e) {
            throw new ExtensionResolutionException(extension, e);
        }
    }

            return Collections.emptyList();
        }
        return Arrays.stream(excludes.split(","))
                .map(String::trim)
                .filter(s -> !s.isEmpty())
                .collect(Collectors.toList());
    }

    private ValidationReportLevel validationReportLevel(RepositorySystemSession session) {
        return (ValidationReportLevel) session.getData()

                .stream()
                .map(protwordsItem -> createEditBody(protwordsItem, dictId))
                .collect(Collectors.toList())).status(ApiResult.Status.OK).result());
    }

    /**
     * Retrieve a single character mapping entry by ID for the specified dictionary.
     *
     * @param dictId identifier of the dictionary

        final List<ElevateWord> list = elevateWordService.getElevateWordList(pager);
        return asJson(
                new ApiResult.ApiConfigsResponse<EditBody>().settings(list.stream().map(this::createEditBody).collect(Collectors.toList()))
                        .total(pager.getAllRecordCount())
                        .status(ApiResult.Status.OK)
                        .result());
    }

    // GET /api/admin/elevateword/{id}
    /**