return new CacheKey(extensionRealms);
    }

    public CacheRecord get(Key key) {
        return cache.get(key);
    }

    public CacheRecord put(Key key, ClassRealm projectRealm, DependencyFilter extensionArtifactFilter) {
        Objects.requireNonNull(projectRealm, "projectRealm cannot be null");

        if (cache.containsKey(key)) {

        cache.put(key, record);
        return record;
    }

    @Override
    public CacheRecord put(Key key, LifecycleExecutionException exception) {
        Objects.requireNonNull(exception, "exception cannot be null");
        assertUniqueKey(key);
        CacheRecord record = new CacheRecord(exception);
        cache.put(key, record);
        return record;
    }

                    if (ret != null) {
                        return ret;
                    }
                    cycle.removeLast();
                    stateMap.put(v, DfsState.VISITED);
                } else if (state == DfsState.VISITING) {
                    // we are already visiting this vertex, this mean we have a cycle
                    int pos = cycle.lastIndexOf(v);

        PathModularization info = moduleInfo.get(path);
        if (info == null) {
            info = new PathModularization(path, true);
            moduleInfo.put(path, info);
            pathTypes.put(path, info.getPathType());
        }
        return info;
    }

    /**
     * Returns {@link JavaPathType#MODULES} if the given JAR file or output directory is modular.

            Metadata metadata = it.next();
            if (metadata instanceof PluginsMetadata pluginMetadata) {
                it.remove();
                processedPlugins.put(pluginMetadata.getGroupId(), pluginMetadata);
            }
        }
    }

    @Override
    public Collection<? extends Metadata> prepare(Collection<? extends Artifact> artifacts) {

        for (String phase : lifecycle.getPhases()) {
            Map<Integer, List<MojoExecution>> phaseBindings = new TreeMap<>();

            mappings.put(phase, phaseBindings);

            if (phase.equals(lifecyclePhase)) {
                break;
            }
        }

        /*

        Map<String, Expression> bySyntax = new HashMap<>();

        if (expressions != null && !expressions.isEmpty()) {
            for (Expression expression : expressions) {
                bySyntax.put(expression.getSyntax(), expression);
            }
        }

        return bySyntax;
    }

    private static ClassLoader initializeDocLoader() throws ExpressionDocumentationException {

            if (e.getCause() instanceof PluginContainerException) {
                throw (PluginContainerException) e.getCause();
            }
            throw e;
        }
    }

    public CacheRecord put(Key key, ClassRealm pluginRealm, List<Artifact> pluginArtifacts) {
        Objects.requireNonNull(pluginRealm, "pluginRealm cannot be null");
        Objects.requireNonNull(pluginArtifacts, "pluginArtifacts cannot be null");

                if (index < 0) {
                    location = sourceLocations.get(~index);
                } else {
                    location = targetLocations.get(index);
                }
                locations.put(locations.size(), location);
            }
        }

        return new InputLocation(-1, -1, InputSource.merge(source.getSource(), target.getSource()), locations);

            if (transferred == null) {
                transferred = (long) length;
            } else {
                transferred = transferred + length;
            }
            transfers.put(transferEvent.getResource(), transferred);
        }

        ArtifactTransferEvent event = wrap(transferEvent);
        event.setDataBuffer(buffer);
        event.setDataOffset(0);