Updated to 6.7.0

build.gradle

@@ -51,6 +51,9 @@ allprojects {
 
         // CombatLogX
         maven { url 'https://nexus.sirblobman.xyz/repository/public/' }
+
+        // Head Database
+        maven { url 'https://mvn.intellectualsites.com/content/groups/public/' }
     }
 
     dependencies {

eco-api/src/main/java/com/willfp/eco/core/items/Items.java

@@ -1,5 +1,6 @@
 package com.willfp.eco.core.items;
 
+import com.willfp.eco.core.items.args.LookupArgParser;
 import com.willfp.eco.core.recipe.parts.EmptyTestableItem;
 import com.willfp.eco.core.recipe.parts.MaterialTestableItem;
 import com.willfp.eco.core.recipe.parts.ModifiedTestableItem;
@@ -8,18 +9,19 @@ import com.willfp.eco.util.NamespacedKeyUtils;
 import lombok.experimental.UtilityClass;
 import org.bukkit.Material;
 import org.bukkit.NamespacedKey;
-import org.bukkit.enchantments.Enchantment;
 import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.EnchantmentStorageMeta;
 import org.bukkit.inventory.meta.ItemMeta;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Predicate;
 
 /**
  * Class to manage all custom and vanilla items.
@@ -29,19 +31,33 @@ public final class Items {
     /**
      * All recipe parts.
      */
-    private static final Map<NamespacedKey, CustomItem> REGISTRY = new HashMap<>();
+    private static final Map<NamespacedKey, CustomItem> REGISTRY = new ConcurrentHashMap<>();
 
     /**
-     * Register a new recipe part.
+     * All recipe parts.
+     */
+    private static final List<LookupArgParser> ARG_PARSERS = new ArrayList<>();
+
+    /**
+     * Register a new custom item.
      *
-     * @param key  The key of the recipe part.
+     * @param key  The key of the item.
-     * @param part The recipe part.
+     * @param part The item.
      */
     public void registerCustomItem(@NotNull final NamespacedKey key,
                                    @NotNull final CustomItem part) {
         REGISTRY.put(key, part);
     }
 
+    /**
+     * Register a new arg parser.
+     *
+     * @param parser The parser.
+     */
+    public void registerArgParser(@NotNull final LookupArgParser parser) {
+        ARG_PARSERS.add(parser);
+    }
+
     /**
      * Remove an item.
      *
@@ -52,12 +68,27 @@ public final class Items {
     }
 
     /**
-     * Lookup item from string.
+     * This is the backbone of the entire eco item system.
      * <p>
-     * Used for recipes.
+     * You can lookup a TestableItem for any material, custom item,
+     * or item in general, and it will return it with any modifiers
+     * passed as parameters. This includes stack size (item amount)
+     * and enchantments that should be present on the item.
+     * <p>
+     * If you want to get an ItemStack instance from this, then just call
+     * {@link TestableItem#getItem()}.
+     * <p>
+     * The advantages of the testable item system are that there is the inbuilt
+     * {@link TestableItem#matches(ItemStack)} - this allows to check if any item
+     * is that testable item; which may sound negligible but actually it allows for
+     * much more power an flexibility. For example, you can have an item with an
+     * extra metadata tag, extra lore lines, different display name - and it
+     * will still work as long as the test passes. This is very important
+     * for custom crafting recipes where other plugins may add metadata
+     * values or the play may rename the item.
      *
-     * @param key The string to test.
+     * @param key The lookup string.
-     * @return The found testable item, or an empty item if not found.
+     * @return The testable item, or an {@link EmptyTestableItem}.
      */
     public TestableItem lookup(@NotNull final String key) {
         if (key.contains("?")) {
@@ -96,7 +127,7 @@ public final class Items {
 
             /*
             Legacy id:amount format
-            This has been superceded by id amount
+            This has been superseded by id amount
              */
             if (part == null) {
                 Material material = Material.getMaterial(split[0].toUpperCase());
@@ -112,7 +143,7 @@ public final class Items {
 
         /*
         Legacy namespace:id:amount format
-        This has been superceded by namespace:id amount
+        This has been superseded by namespace:id amount
          */
         if (split.length == 3) {
             CustomItem part = REGISTRY.get(NamespacedKeyUtils.create(split[0], split[1]));
@@ -137,60 +168,26 @@ public final class Items {
             return new EmptyTestableItem();
         }
 
-        String[] enchantArgs = Arrays.copyOfRange(args, usingNewStackFormat ? 2 : 1, args.length);
-
-        Map<Enchantment, Integer> requiredEnchantments = new HashMap<>();
-
-        for (String enchantArg : enchantArgs) {
-            String[] enchantArgSplit = enchantArg.split(":");
-
-            Enchantment enchantment = Enchantment.getByKey(NamespacedKey.minecraft(enchantArgSplit[0].toLowerCase()));
-            int level = Integer.parseInt(enchantArgSplit[1]);
-
-            requiredEnchantments.put(enchantment, level);
-        }
-
         ItemStack example = item.getItem();
+        ItemMeta meta = example.getItemMeta();
+        assert meta != null;
 
-        if (example.getItemMeta() instanceof EnchantmentStorageMeta storageMeta) {
+        String[] modifierArgs = Arrays.copyOfRange(args, usingNewStackFormat ? 2 : 1, args.length);
-            requiredEnchantments.forEach((enchantment, integer) -> storageMeta.addStoredEnchant(enchantment, integer, true));
+
-            example.setItemMeta(storageMeta);
+        List<Predicate<ItemStack>> predicates = new ArrayList<>();
-        } else {
+
-            ItemMeta meta = example.getItemMeta();
+        for (LookupArgParser argParser : ARG_PARSERS) {
-            assert meta != null;
+            predicates.add(argParser.parseArguments(modifierArgs, meta));
-            requiredEnchantments.forEach((enchantment, integer) -> meta.addEnchant(enchantment, integer, true));
-            example.setItemMeta(meta);
         }
 
-        if (!requiredEnchantments.isEmpty()) {
+        example.setItemMeta(meta);
+        if (!predicates.isEmpty()) {
             item = new ModifiedTestableItem(
                     item,
-                    itemStack -> {
+                    test -> {
-                        if (!itemStack.hasItemMeta()) {
+                        for (Predicate<ItemStack> predicate : predicates) {
-                            return false;
+                            if (!predicate.test(test)) {
-                        }
+                                return false;
-
-                        ItemMeta meta = itemStack.getItemMeta();
-
-                        assert meta != null;
-
-                        if (meta instanceof EnchantmentStorageMeta storageMeta) {
-                            for (Map.Entry<Enchantment, Integer> entry : requiredEnchantments.entrySet()) {
-                                if (!storageMeta.hasStoredEnchant(entry.getKey())) {
-                                    return false;
-                                }
-                                if (storageMeta.getStoredEnchantLevel(entry.getKey()) < entry.getValue()) {
-                                    return false;
-                                }
-                            }
-                        } else {
-                            for (Map.Entry<Enchantment, Integer> entry : requiredEnchantments.entrySet()) {
-                                if (!meta.hasEnchant(entry.getKey())) {
-                                    return false;
-                                }
-                                if (meta.getEnchantLevel(entry.getKey()) < entry.getValue()) {
-                                    return false;
-                                }
                             }
                         }
 

eco-api/src/main/java/com/willfp/eco/core/items/args/EnchantmentArgParser.java

@@ -0,0 +1,75 @@
+package com.willfp.eco.core.items.args;
+
+import org.bukkit.NamespacedKey;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.EnchantmentStorageMeta;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Predicate;
+
+public class EnchantmentArgParser implements LookupArgParser {
+    @Override
+    public Predicate<ItemStack> parseArguments(@NotNull final String[] args,
+                                               @NotNull final ItemMeta meta) {
+        Map<Enchantment, Integer> requiredEnchantments = new HashMap<>();
+
+        for (String enchantArg : args) {
+            String[] enchantArgSplit = enchantArg.split(":");
+
+            Enchantment enchantment = Enchantment.getByKey(NamespacedKey.minecraft(enchantArgSplit[0].toLowerCase()));
+            if (enchantment == null) {
+                continue;
+            }
+
+            if (enchantArgSplit.length < 2) {
+                continue;
+            }
+
+            int level = Integer.parseInt(enchantArgSplit[1]);
+
+            requiredEnchantments.put(enchantment, level);
+        }
+
+        if (meta instanceof EnchantmentStorageMeta storageMeta) {
+            requiredEnchantments.forEach((enchantment, integer) -> storageMeta.addStoredEnchant(enchantment, integer, true));
+        } else {
+            requiredEnchantments.forEach((enchantment, integer) -> meta.addEnchant(enchantment, integer, true));
+        }
+
+        return test -> {
+            if (!test.hasItemMeta()) {
+                return false;
+            }
+
+            ItemMeta testMeta = test.getItemMeta();
+
+            assert testMeta != null;
+
+            if (testMeta instanceof EnchantmentStorageMeta storageMeta) {
+                for (Map.Entry<Enchantment, Integer> entry : requiredEnchantments.entrySet()) {
+                    if (!storageMeta.hasStoredEnchant(entry.getKey())) {
+                        return false;
+                    }
+                    if (storageMeta.getStoredEnchantLevel(entry.getKey()) < entry.getValue()) {
+                        return false;
+                    }
+                }
+            } else {
+                for (Map.Entry<Enchantment, Integer> entry : requiredEnchantments.entrySet()) {
+                    if (!testMeta.hasEnchant(entry.getKey())) {
+                        return false;
+                    }
+                    if (testMeta.getEnchantLevel(entry.getKey()) < entry.getValue()) {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        };
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/items/args/LookupArgParser.java

@@ -0,0 +1,23 @@
+package com.willfp.eco.core.items.args;
+
+import com.willfp.eco.core.items.TestableItem;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.Predicate;
+
+public interface LookupArgParser {
+    /**
+     * Parse the arguments.
+     * <p>
+     * An argument parser should generate the predicate as well
+     * as modify the ItemMeta for {@link TestableItem#getItem()}
+     *
+     * @param args The arguments.
+     * @param meta The ItemMeta to modify.
+     * @return The predicate test to apply to the modified item.
+     */
+    Predicate<ItemStack> parseArguments(@NotNull String[] args,
+                                        @NotNull ItemMeta meta);
+}

eco-api/src/main/java/com/willfp/eco/core/items/args/TextureArgParser.java

@@ -0,0 +1,51 @@
+package com.willfp.eco.core.items.args;
+
+import com.willfp.eco.util.SkullUtils;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.inventory.meta.SkullMeta;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.Predicate;
+
+public class TextureArgParser implements LookupArgParser {
+    @Override
+    public Predicate<ItemStack> parseArguments(@NotNull final String[] args,
+                                               @NotNull final ItemMeta meta) {
+        String skullTexture = null;
+
+        for (String arg : args) {
+            String[] argSplit = arg.split(":");
+            if (!argSplit[0].equalsIgnoreCase("texture")) {
+                continue;
+            }
+
+            if (argSplit.length < 2) {
+                continue;
+            }
+
+            skullTexture = argSplit[1];
+        }
+
+        if (meta instanceof SkullMeta skullMeta && skullTexture != null) {
+            SkullUtils.setSkullTexture(skullMeta, skullTexture);
+        }
+
+        String finalSkullTexture = skullTexture;
+        return test -> {
+            if (!test.hasItemMeta()) {
+                return false;
+            }
+
+            ItemMeta testMeta = test.getItemMeta();
+
+            assert testMeta != null;
+
+            if (testMeta instanceof SkullMeta skullMeta && finalSkullTexture != null) {
+                return finalSkullTexture.equalsIgnoreCase(SkullUtils.getSkullTexture(skullMeta));
+            }
+
+            return true;
+        };
+    }
+}

eco-api/src/main/java/com/willfp/eco/util/SkullUtils.java

@@ -7,6 +7,7 @@ import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.function.BiConsumer;
+import java.util.function.Function;
 
 /**
  * Utilities / API methods for player heads.
@@ -23,6 +24,11 @@ public class SkullUtils {
      */
     private BiConsumer<SkullMeta, String> metaSetConsumer = null;
 
+    /**
+     * The meta get function.
+     */
+    private Function<SkullMeta, String> metaGetConsumer = null;
+
     /**
      * Set the texture of a skull from base64.
      *
@@ -37,16 +43,32 @@ public class SkullUtils {
         metaSetConsumer.accept(meta, base64);
     }
 
+    /**
+     * Get the texture of a skull - in base64.
+     *
+     * @param meta The meta to modify.
+     * @return The texture.
+     */
+    public String getSkullTexture(@NotNull final SkullMeta meta) {
+        Validate.isTrue(initialized, "Must be initialized!");
+        Validate.notNull(metaGetConsumer, "Must be initialized!");
+
+        return metaGetConsumer.apply(meta);
+    }
+
     /**
      * Initialize the skull texture function.
      *
-     * @param function The function.
+     * @param function  The function.
+     * @param function2 Get function.
      */
     @ApiStatus.Internal
-    public void initialize(@NotNull final BiConsumer<SkullMeta, String> function) {
+    public void initialize(@NotNull final BiConsumer<SkullMeta, String> function,
+                           @NotNull final Function<SkullMeta, String> function2) {
         Validate.isTrue(!initialized, "Already initialized!");
 
         metaSetConsumer = function;
+        metaGetConsumer = function2;
         initialized = true;
     }
 }

eco-core/core-nms/v1_16_R3/src/main/kotlin/com/willfp/eco/proxy/v1_16_R3/Skull.kt

@@ -1,32 +1,43 @@
 package com.willfp.eco.proxy.v1_16_R3
+
 import com.mojang.authlib.GameProfile
 import com.mojang.authlib.properties.Property
-import org.bukkit.inventory.meta.SkullMeta
 import com.willfp.eco.proxy.SkullProxy
+import org.bukkit.inventory.meta.SkullMeta
+import java.lang.reflect.Field
 import java.lang.reflect.Method
 import java.util.*
 
 class Skull : SkullProxy {
     private lateinit var setProfile: Method
+    private lateinit var profile: Field
 
     override fun setSkullTexture(
         meta: SkullMeta,
         base64: String
     ) {
-        try {
+        if (!this::setProfile.isInitialized) {
-            if (!this::setProfile.isInitialized) {
+            setProfile = meta.javaClass.getDeclaredMethod("setProfile", GameProfile::class.java)
-                setProfile = meta.javaClass.getDeclaredMethod("setProfile", GameProfile::class.java)
+            setProfile.isAccessible = true
-                setProfile.isAccessible = true
-            }
-            val uuid = UUID(
-                base64.substring(base64.length - 20).hashCode().toLong(),
-                base64.substring(base64.length - 10).hashCode().toLong()
-            )
-            val profile = GameProfile(uuid, "eco")
-            profile.properties.put("textures", Property("textures", base64))
-            setProfile.invoke(meta, profile)
-        } catch (e: ReflectiveOperationException) {
-            e.printStackTrace()
         }
+        val uuid = UUID(
+            base64.substring(base64.length - 20).hashCode().toLong(),
+            base64.substring(base64.length - 10).hashCode().toLong()
+        )
+        val profile = GameProfile(uuid, "eco")
+        profile.properties.put("textures", Property("textures", base64))
+        setProfile.invoke(meta, profile)
+    }
+
+    override fun getSkullTexture(
+        meta: SkullMeta
+    ): String? {
+        if (!this::profile.isInitialized) {
+            profile = meta.javaClass.getDeclaredField("profile")
+            profile.isAccessible = true
+        }
+        val profile = profile[meta] as GameProfile?
+        val property = profile?.properties?.get("textures") as Property?
+        return property?.value
     }
 }

eco-core/core-nms/v1_17_R1/src/main/kotlin/com/willfp/eco/proxy/v1_17_R1/Skull.kt

@@ -4,30 +4,40 @@ import com.mojang.authlib.GameProfile
 import com.mojang.authlib.properties.Property
 import com.willfp.eco.proxy.SkullProxy
 import org.bukkit.inventory.meta.SkullMeta
+import java.lang.reflect.Field
 import java.lang.reflect.Method
 import java.util.*
 
 class Skull : SkullProxy {
     private lateinit var setProfile: Method
+    private lateinit var profile: Field
 
     override fun setSkullTexture(
         meta: SkullMeta,
         base64: String
     ) {
-        try {
+        if (!this::setProfile.isInitialized) {
-            if (!this::setProfile.isInitialized) {
+            setProfile = meta.javaClass.getDeclaredMethod("setProfile", GameProfile::class.java)
-                setProfile = meta.javaClass.getDeclaredMethod("setProfile", GameProfile::class.java)
+            setProfile.isAccessible = true
-                setProfile.isAccessible = true
-            }
-            val uuid = UUID(
-                base64.substring(base64.length - 20).hashCode().toLong(),
-                base64.substring(base64.length - 10).hashCode().toLong()
-            )
-            val profile = GameProfile(uuid, "eco")
-            profile.properties.put("textures", Property("textures", base64))
-            setProfile.invoke(meta, profile)
-        } catch (e: ReflectiveOperationException) {
-            e.printStackTrace()
         }
+        val uuid = UUID(
+            base64.substring(base64.length - 20).hashCode().toLong(),
+            base64.substring(base64.length - 10).hashCode().toLong()
+        )
+        val profile = GameProfile(uuid, "eco")
+        profile.properties.put("textures", Property("textures", base64))
+        setProfile.invoke(meta, profile)
+    }
+
+    override fun getSkullTexture(
+        meta: SkullMeta
+    ): String? {
+        if (!this::profile.isInitialized) {
+            profile = meta.javaClass.getDeclaredField("profile")
+            profile.isAccessible = true
+        }
+        val profile = profile[meta] as GameProfile?
+        val property = profile?.properties?.get("textures") as Property?
+        return property?.value
     }
 }

eco-core/core-plugin/build.gradle

@@ -21,8 +21,8 @@ dependencies {
     compileOnly 'me.clip:placeholderapi:2.10.9'
     compileOnly 'com.willfp:Oraxen:e1f4003d8d'
     compileOnly 'com.github.brcdev-minecraft:shopgui-api:2.2.0'
-
     compileOnly 'com.github.LoneDev6:API-ItemsAdder:2.4.7'
+    compileOnly 'me.arcaniax:HeadDatabase-API:1.2.0'
 
     // CombatLogX V10 + NewbieHelper Expansion
     compileOnly 'com.SirBlobman.combatlogx:CombatLogX-API:10.0.0.0-SNAPSHOT'

eco-core/core-plugin/src/main/kotlin/com/willfp/eco/spigot/EcoSpigotPlugin.kt

@@ -9,6 +9,9 @@ import com.willfp.eco.core.integrations.antigrief.AntigriefManager
 import com.willfp.eco.core.integrations.customitems.CustomItemsManager
 import com.willfp.eco.core.integrations.mcmmo.McmmoManager
 import com.willfp.eco.core.integrations.shop.ShopManager
+import com.willfp.eco.core.items.Items
+import com.willfp.eco.core.items.args.EnchantmentArgParser
+import com.willfp.eco.core.items.args.TextureArgParser
 import com.willfp.eco.internal.drops.DropManager
 import com.willfp.eco.proxy.BlockBreakProxy
 import com.willfp.eco.proxy.FastItemStackFactoryProxy
@@ -20,6 +23,7 @@ import com.willfp.eco.spigot.eventlisteners.*
 import com.willfp.eco.spigot.gui.GUIListener
 import com.willfp.eco.spigot.integrations.anticheat.*
 import com.willfp.eco.spigot.integrations.antigrief.*
+import com.willfp.eco.spigot.integrations.customitems.CustomItemsHeadDatabase
 import com.willfp.eco.spigot.integrations.customitems.CustomItemsItemsAdder
 import com.willfp.eco.spigot.integrations.customitems.CustomItemsOraxen
 import com.willfp.eco.spigot.integrations.mcmmo.McmmoIntegrationImpl
@@ -44,8 +48,14 @@ abstract class EcoSpigotPlugin : EcoPlugin(
     init {
         Display.setFinalizeKey(namespacedKeyFactory.create("finalized"))
 
+        Items.registerArgParser(EnchantmentArgParser())
+        Items.registerArgParser(TextureArgParser())
+
         val skullProxy = getProxy(SkullProxy::class.java)
-        SkullUtils.initialize { meta: SkullMeta, base64: String -> skullProxy.setSkullTexture(meta, base64) }
+        SkullUtils.initialize(
+            { meta: SkullMeta, base64: String -> skullProxy.setSkullTexture(meta, base64) },
+            { meta: SkullMeta -> skullProxy.getSkullTexture(meta) }
+        )
 
         val blockBreakProxy = getProxy(BlockBreakProxy::class.java)
         BlockUtils.initialize { player: Player, block: Block -> blockBreakProxy.breakBlock(player, block) }
@@ -113,6 +123,7 @@ abstract class EcoSpigotPlugin : EcoPlugin(
             // Custom Items
             IntegrationLoader("Oraxen") { CustomItemsManager.register(CustomItemsOraxen()) },
             IntegrationLoader("ItemsAdder") { CustomItemsManager.register(CustomItemsItemsAdder(this)) },
+            IntegrationLoader("HeadDatabase") { CustomItemsManager.register(CustomItemsHeadDatabase()) },
 
             // Shop
             IntegrationLoader("ShopGuiPlus") { ShopManager.register(ShopShopGuiPlus()) },

eco-core/core-plugin/src/main/kotlin/com/willfp/eco/spigot/integrations/customitems/CustomItemsHeadDatabase.kt

@@ -0,0 +1,34 @@
+package com.willfp.eco.spigot.integrations.customitems
+
+import com.willfp.eco.core.integrations.customitems.CustomItemsWrapper
+import com.willfp.eco.core.items.CustomItem
+import com.willfp.eco.util.NamespacedKeyUtils
+import me.arcaniax.hdb.api.HeadDatabaseAPI
+import me.arcaniax.hdb.enums.CategoryEnum
+import java.util.function.Predicate
+
+class CustomItemsHeadDatabase : CustomItemsWrapper {
+    private val api = HeadDatabaseAPI()
+
+    override fun registerAllItems() {
+        for (categoryEnum in CategoryEnum.values()) {
+            for (head in api.getHeads(categoryEnum)) {
+                val stack = head.head
+                val id = head.id
+                val key = NamespacedKeyUtils.create("headdb", id.lowercase());
+                CustomItem(
+                    key,
+                    Predicate { test ->
+                        val headId = api.getItemID(test) ?: return@Predicate false
+                        headId.equals(id, ignoreCase = true)
+                    },
+                    stack
+                ).register()
+            }
+        }
+    }
+
+    override fun getPluginName(): String {
+        return "HeadDatabase"
+    }
+}

eco-core/core-plugin/src/main/resources/plugin.yml

@@ -4,6 +4,7 @@ main: com.willfp.eco.spigot.EcoHandler
 api-version: 1.16
 authors: [Auxilor]
 website: willfp.com
+load: STARTUP
 depend:
   - ProtocolLib
 softdepend:
@@ -23,6 +24,7 @@ softdepend:
   - ShopGuiPlus
   - ItemsAdder
   - Oraxen
+  - HeadDatabase
 libraries:
   - org.reflections:reflections:0.9.12
   - org.apache.maven:maven-artifact:3.0.3

eco-core/core-proxy/src/main/kotlin/com/willfp/eco/proxy/SkullProxy.kt

@@ -8,4 +8,8 @@ interface SkullProxy : AbstractProxy {
         meta: SkullMeta,
         base64: String
     )
+
+    fun getSkullTexture(
+        meta: SkullMeta
+    ): String?
 }

gradle.properties

@@ -1,2 +1,2 @@
-version = 6.6.4
+version = 6.7.0
 plugin-name = eco