}

// ToQuery constructs a URL query string from the MSS, including "?" if there are any keys.
func (m MSS) ToQuery() string {
	if len(m) == 0 {
		return ""
	}
	var buf strings.Builder
	buf.WriteByte('?')
	keys := make([]string, 0, len(m))
	for k := range m {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {
		v := m[k]
		keyEscaped := url.QueryEscape(k)
		if buf.Len() > 1 {

  public void testAsMapGetImplementsSet() {
    for (K key : multimap().keySet()) {
      assertTrue(multimap().asMap().get(key) instanceof Set);
    }
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testAsMapRemoveImplementsSet() {
    List<K> keys = new ArrayList<>(multimap().keySet());
    for (K key : keys) {
      resetCollection();
      assertTrue(multimap().asMap().remove(key) instanceof Set);
    }
  }

        return parent;
    }

    /**
     * Converts a key to camelCase.
     *
     * @param key the key to convert
     * @return the converted key
     */
    protected Object toCamelCase(final Object key) {
        if (key == null) {
            return key;
        }
        String keyStr = key.toString();
        if (keyStr.indexOf('_') < 0) {

 *       as that of its keys. This is sometimes called an "invertible map," since the restriction on
 *       values enables it to support an {@linkplain BiMap#inverse inverse view} -- which is another
 *       instance of {@code BiMap}.
 *   <dt>{@link Table}
 *   <dd>A new type, which is similar to {@link java.util.Map}, but which indexes its values by an
 *       ordered pair of keys, a row key and column key.
 *   <dt>{@link Multiset}

    getMap()
        .replaceAll(
            (K k, V v) -> {
              int index = keys().asList().indexOf(k);
              return values().asList().get(index + 1);
            });
    List<Entry<K, V>> orderedEntries = getOrderedElements();
    int index = 0;
    for (K key : getMap().keySet()) {
      assertEquals(orderedEntries.get(index).getKey(), key);
      index++;
    }
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)

    }

    /**
     * Gets the map of display keys to query strings.
     *
     * @return the query map
     */
    public Map<String, String> getQueryMap() {
        return queryMap;
    }

    /**
     * Adds a query to the query map with the specified display key.
     *
     * @param key the display key for the query
     * @param query the query string to add
     */

     */
    public static <KEY, VALUE> Maps<KEY, VALUE> hashMap(final KEY key, final VALUE value) {
        return new Maps<>(new HashMap<KEY, VALUE>()).$(key, value);
    }

    /**
     * Returns a {@literal Maps} for constructing a {@link Hashtable} with the specified key and value.
     *
     * @param <KEY> the key type of the <code>Map</code>

    private static class ReactorDependencyFilter implements DependencyFilter {

        private final Set<String> keys = new HashSet<>();

        ReactorDependencyFilter(Collection<Artifact> artifacts) {
            for (Artifact artifact : artifacts) {
                String key = ArtifactUtils.key(artifact);
                keys.add(key);
            }
        }

        @Override

    private Map<Key, PluginDescriptor> descriptors = new ConcurrentHashMap<>(128);
    private Map<Key, Key> keys = new ConcurrentHashMap<>();

    @Override
    public void flush() {
        descriptors.clear();
    }

    @Override
    public Key createKey(Plugin plugin, List<RemoteRepository> repositories, RepositorySystemSession session) {

     */
    public BeanMap() {
    }

    @Override
    public Object get(final Object key) {
        if (!containsKey(key)) {
            throw new IllegalKeyOfBeanMapException(key, this);
        }
        return super.get(key);
    }