Update dependency gradle to v9

.github/workflows/announce-release-on-discord.yml

@@ -11,7 +11,7 @@ jobs:
           DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}
           DISCORD_USERNAME: PlotSquared Release
           DISCORD_AVATAR: https://raw.githubusercontent.com/IntellectualSites/Assets/main/plugins/PlotSquared/PlotSquared.png
-        uses: Ilshidur/action-discord@0.4.0
+        uses: Ilshidur/action-discord@0.3.2
         with:
           args: |
             "<@&525015541815967744> <@&679322738552471574> <@&699293353862496266>"

Bukkit/src/main/java/com/plotsquared/bukkit/generator/BukkitPlotGenerator.java

@@ -90,7 +90,12 @@ public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrap
         this.plotGenerator = generator;
         this.platformGenerator = this;
         this.populators = new ArrayList<>();
+        int minecraftMinorVersion = PlotSquared.platform().serverVersion()[1];
+        if (minecraftMinorVersion >= 17) {
             this.populators.add(new BlockStatePopulator(this.plotGenerator));
+        } else {
+            this.populators.add(new LegacyBlockStatePopulator(this.plotGenerator));
+        }
         this.full = true;
         this.useNewGenerationMethods = PlotSquared.platform().serverVersion()[1] >= 19;
         this.biomeProvider = new BukkitPlotBiomeProvider();

Bukkit/src/main/java/com/plotsquared/bukkit/generator/LegacyBlockStatePopulator.java

@@ -36,7 +36,6 @@ import org.checkerframework.checker.nullness.qual.NonNull;
 
 import java.util.Random;
 
-@Deprecated(since = "TODO")
 final class LegacyBlockStatePopulator extends BlockPopulator {
 
     private final IndependentPlotGenerator plotGenerator;

Bukkit/src/main/java/com/plotsquared/bukkit/schematic/StateWrapper.java

@@ -21,7 +21,6 @@ package com.plotsquared.bukkit.schematic;
 import com.destroystokyo.paper.profile.PlayerProfile;
 import com.destroystokyo.paper.profile.ProfileProperty;
 import com.plotsquared.bukkit.util.BukkitUtil;
-import com.plotsquared.core.PlotSquared;
 import com.sk89q.jnbt.ByteTag;
 import com.sk89q.jnbt.CompoundTag;
 import com.sk89q.jnbt.ListTag;
@@ -37,8 +36,6 @@ import org.apache.logging.log4j.Logger;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.DyeColor;
-import org.bukkit.NamespacedKey;
-import org.bukkit.Registry;
 import org.bukkit.World;
 import org.bukkit.block.Banner;
 import org.bukkit.block.Block;
@@ -47,36 +44,26 @@ import org.bukkit.block.Sign;
 import org.bukkit.block.Skull;
 import org.bukkit.block.banner.Pattern;
 import org.bukkit.block.banner.PatternType;
-import org.bukkit.block.sign.Side;
-import org.bukkit.block.sign.SignSide;
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
 import org.checkerframework.checker.nullness.qual.NonNull;
-import org.jetbrains.annotations.ApiStatus;
 
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
-import java.util.Locale;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Objects;
 import java.util.UUID;
-import java.util.function.BiConsumer;
 
-// TODO: somehow unbreak this class so it doesn't fuck up the whole schematic population system due to MC updates
-@ApiStatus.Internal
 public class StateWrapper {
 
-    private static final Logger LOGGER = LogManager.getLogger("PlotSquared/" + StateWrapper.class.getSimpleName());
-    private static final boolean MODERN_SIGNS = PlotSquared.platform().serverVersion()[1] > 19;
-    private final Registry<PatternType> PATTERN_TYPE_REGISTRY = Objects.requireNonNull(Bukkit.getRegistry(PatternType.class));
-
-    private static boolean paperErrorTextureSent = false;
-
     public CompoundTag tag;
 
+    private boolean paperErrorTextureSent = false;
+    private static final Logger LOGGER = LogManager.getLogger("PlotSquared/" + StateWrapper.class.getSimpleName());
+
     public StateWrapper(CompoundTag tag) {
         this.tag = tag;
     }
@@ -225,9 +212,9 @@ public class StateWrapper {
                     if (type == null) {
                         continue;
                     }
-                    int count = itemComp.containsKey("count") ? itemComp.getInt("count") : itemComp.getByte("Count");
+                    int count = itemComp.getByte("Count");
                     int slot = itemComp.getByte("Slot");
-                    CompoundTag tag = (CompoundTag) itemComp.getValue().get(itemComp.containsKey("tag") ? "tag" : "components");
+                    CompoundTag tag = (CompoundTag) itemComp.getValue().get("tag");
                     BaseItemStack baseItemStack = new BaseItemStack(type, tag, count);
                     ItemStack itemStack = BukkitAdapter.adapt(baseItemStack);
                     inv.setItem(slot, itemStack);
@@ -236,63 +223,83 @@ public class StateWrapper {
                 return true;
             }
             case "sign" -> {
-                if (state instanceof Sign sign && this.restoreSign(sign)) {
+                if (state instanceof Sign sign) {
-                    state.update(true, false);
+                    sign.setLine(0, jsonToColourCode(tag.getString("Text1")));
+                    sign.setLine(1, jsonToColourCode(tag.getString("Text2")));
+                    sign.setLine(2, jsonToColourCode(tag.getString("Text3")));
+                    sign.setLine(3, jsonToColourCode(tag.getString("Text4")));
+                    state.update(true);
                     return true;
                 }
                 return false;
             }
             case "skull" -> {
-                if (state instanceof Skull skull && this.restoreSkull(skull)) {
+                if (state instanceof Skull skull) {
-                    skull.update(true, false);
+                    CompoundTag skullOwner = ((CompoundTag) this.tag.getValue().get("SkullOwner"));
+                    if (skullOwner == null) {
                         return true;
                     }
+                    String player = skullOwner.getString("Name");
+
+                    if (player != null && !player.isEmpty()) {
+                        try {
+                            skull.setOwningPlayer(Bukkit.getOfflinePlayer(player));
+                            skull.update(true);
+                        } catch (Exception e) {
+                            e.printStackTrace();
+                        }
+                        return true;
+                    }
+
+                    final CompoundTag properties = (CompoundTag) skullOwner.getValue().get("Properties");
+                    if (properties == null) {
+                        return false;
+                    }
+                    final ListTag textures = properties.getListTag("textures");
+                    if (textures.getValue().isEmpty()) {
+                        return false;
+                    }
+                    final CompoundTag textureCompound = (CompoundTag) textures.getValue().get(0);
+                    if (textureCompound == null) {
+                        return false;
+                    }
+                    String textureValue = textureCompound.getString("Value");
+                    if (textureValue == null) {
+                        return false;
+                    }
+                    if (!PaperLib.isPaper()) {
+                        if (!paperErrorTextureSent) {
+                            paperErrorTextureSent = true;
+                            LOGGER.error("Failed to populate skull data in your road schematic - This is a Spigot limitation.");
+                        }
+                        return false;
+                    }
+                    final PlayerProfile profile = Bukkit.createProfile(UUID.randomUUID());
+                    profile.setProperty(new ProfileProperty("textures", textureValue));
+                    skull.setPlayerProfile(profile);
+                    skull.update(true);
+                    return true;
+
+                }
                 return false;
             }
             case "banner" -> {
                 if (state instanceof Banner banner) {
-                    List<CompoundTag> patterns;
+                    List<Tag> patterns = this.tag.getListTag("Patterns").getValue();
-                    // "old" format
+                    if (patterns == null || patterns.isEmpty()) {
-                    if ((patterns = this.tag.getList("Patterns", CompoundTag.class)) != null && !patterns.isEmpty()) {
+                        return false;
-                        banner.setPatterns(patterns.stream().map(compoundTag -> {
+                    }
+                    banner.setPatterns(patterns.stream().map(t -> (CompoundTag) t).map(compoundTag -> {
                         DyeColor color = DyeColor.getByWoolData((byte) compoundTag.getInt("Color"));
-                            final PatternType patternType = PATTERN_TYPE_REGISTRY.get(Objects.requireNonNull(
+                        PatternType patternType = PatternType.getByIdentifier(compoundTag.getString("Pattern"));
-                                    NamespacedKey.fromString(compoundTag.getString("Pattern"))
-                            ));
                         if (color == null || patternType == null) {
                             return null;
                         }
                         return new Pattern(color, patternType);
                     }).filter(Objects::nonNull).toList());
-                        banner.update(true, false);
+                    banner.update(true);
                     return true;
                 }
-
-                    // "new" format - since 1.21.3-ish
-                    if ((patterns = this.tag.getList("patterns", CompoundTag.class)) != null && !patterns.isEmpty()) {
-                        for (final CompoundTag patternTag : patterns) {
-                            final String color = patternTag.getString("color");
-                            if (color.isEmpty()) {
-                                continue;
-                            }
-                            final Tag pattern = patternTag.getValue().get("pattern");
-                            if (pattern instanceof StringTag patternString && !patternString.getValue().isEmpty()) {
-                                final PatternType patternType = PATTERN_TYPE_REGISTRY.get(Objects.requireNonNull(
-                                        NamespacedKey.fromString(patternString.getValue())
-                                ));
-                                if (patternType == null) {
-                                    continue;
-                                }
-                                banner.addPattern(new Pattern(
-                                        DyeColor.legacyValueOf(color.toUpperCase(Locale.ROOT)),
-                                        patternType
-                                ));
-                            }
-                            // not supporting banner pattern definitions (no API available)
-                        }
-                        banner.update(true, false);
-                    }
-                }
                 return false;
             }
         }
@@ -339,150 +346,4 @@ public class StateWrapper {
         return data;
     }
 
-    private boolean restoreSkull(Skull skull) {
-        boolean updated = false;
-        // can't support custom_name - Spigot does not provide any API for that
-        if (this.tag.containsKey("note_block_sound")) {
-            skull.setNoteBlockSound(NamespacedKey.fromString(this.tag.getString("note_block_sound")));
-            updated = true;
-        }
-        // modern format - MC 1.21.3-ish
-        if (this.tag.containsKey("profile")) {
-            final Tag profile = this.tag.getValue().get("profile");
-            if (profile instanceof StringTag stringTag) {
-                final String name = stringTag.getValue();
-                if (name != null && !name.isEmpty()) {
-                    skull.setOwningPlayer(Bukkit.getOfflinePlayer(name));
-                    return true;
-                }
-                return updated;
-            }
-            if (profile instanceof CompoundTag compoundTag) {
-                final List<Tag> properties = compoundTag.getList("properties");
-                if (properties != null && !properties.isEmpty()) {
-                    if (!PaperLib.isPaper()) {
-                        if (!paperErrorTextureSent) {
-                            paperErrorTextureSent = true;
-                            LOGGER.error("Failed to populate schematic skull data - this is a Spigot limitation.");
-                        }
-                        return updated;
-                    }
-                    for (final Tag propertyTag : properties) {
-                        if (!(propertyTag instanceof CompoundTag property)) {
-                            continue;
-                        }
-                        if (!property.getString("name").equals("textures")) {
-                            continue;
-                        }
-                        final String value = property.getString("value");
-                        final String signature = property.containsKey("signature") ? property.getString("signature") : null;
-                        final PlayerProfile playerProfile = Bukkit.createProfile(UUID.randomUUID());
-                        playerProfile.setProperty(new ProfileProperty("textures", value, signature));
-                        skull.setPlayerProfile(playerProfile);
-                        return true;
-                    }
-                    return updated;
-                }
-                final int[] id = compoundTag.getIntArray("id");
-                if (id != null && id.length == 4) {
-                    skull.setOwningPlayer(Bukkit.getOfflinePlayer(new UUID(
-                            (long) id[0] << 32 | (id[1] & 0xFFFFFFFFL),
-                            (long) id[2] << 32 | (id[3] & 0xFFFFFFFFL)
-                    )));
-                    return true;
-                }
-                final String name = compoundTag.getString("name");
-                if (name != null && !name.isEmpty()) {
-                    skull.setOwningPlayer(Bukkit.getOfflinePlayer(name));
-                    return true;
-                }
-            }
-        }
-
-        // "Old" MC format (idk when it got updated)
-        if (this.tag.getValue().get("SkullOwner") instanceof CompoundTag skullOwner) {
-            if (skullOwner.getValue().get("Name") instanceof StringTag ownerName && !ownerName.getValue().isEmpty()) {
-                skull.setOwningPlayer(Bukkit.getOfflinePlayer(ownerName.getValue()));
-                skull.update(true);
-                return true;
-            }
-            if (skullOwner.getValue().get("Properties") instanceof CompoundTag properties) {
-                if (!paperErrorTextureSent) {
-                    paperErrorTextureSent = true;
-                    LOGGER.error("Failed to populate schematic skull data - this is a Spigot limitation.");
-                    return updated;
-                }
-                final List<CompoundTag> textures = properties.getList("textures", CompoundTag.class);
-                if (textures.isEmpty()) {
-                    return updated;
-                }
-                final String value = textures.get(0).getString("Value");
-                if (!value.isEmpty()) {
-                    final PlayerProfile profile = Bukkit.createProfile(UUID.randomUUID());
-                    profile.setProperty(new ProfileProperty("textures", value));
-                    skull.setPlayerProfile(profile);
-                    return true;
-                }
-            }
-        }
-        return updated;
-    }
-
-    private boolean restoreSign(Sign sign) {
-        // "old" format (pre 1.20)
-        if (this.tag.containsKey("Text1") || this.tag.containsKey("Text2")
-                || this.tag.containsKey("Text3") || this.tag.containsKey("Text4")) {
-            if (!MODERN_SIGNS) {
-                sign.setLine(0, jsonToColourCode(tag.getString("Text1")));
-                sign.setLine(1, jsonToColourCode(tag.getString("Text2")));
-                sign.setLine(2, jsonToColourCode(tag.getString("Text3")));
-                sign.setLine(3, jsonToColourCode(tag.getString("Text4")));
-                sign.setGlowingText(tag.getByte("GlowingText") == 1);
-                if (tag.getValue().get("Color") instanceof StringTag colorTag && !colorTag.getValue().isEmpty()) {
-                    sign.setColor(DyeColor.legacyValueOf(colorTag.getValue()));
-                }
-                return true;
-            }
-            SignSide front = sign.getSide(Side.FRONT);
-            front.setLine(0, jsonToColourCode(tag.getString("Text1")));
-            front.setLine(1, jsonToColourCode(tag.getString("Text2")));
-            front.setLine(2, jsonToColourCode(tag.getString("Text3")));
-            front.setLine(3, jsonToColourCode(tag.getString("Text4")));
-            front.setGlowingText(tag.getByte("GlowingText") == 1);
-            if (tag.getValue().get("Color") instanceof StringTag colorTag && !colorTag.getValue().isEmpty()) {
-                front.setColor(DyeColor.legacyValueOf(colorTag.getValue()));
-            }
-            return true;
-        }
-
-        // "modern" format
-        if (this.tag.containsKey("front_text") || this.tag.containsKey("back_text") || this.tag.containsKey("is_waxed")) {
-            // the new format on older servers shouldn't be possible, I hope?
-            sign.setWaxed(this.tag.getByte("is_waxed") == 1);
-            BiConsumer<SignSide, CompoundTag> sideSetter = (signSide, compoundTag) -> {
-                signSide.setGlowingText(compoundTag.getByte("has_glowing_text") == 1);
-                if (tag.getValue().get("color") instanceof StringTag colorTag && !colorTag.getValue().isEmpty()) {
-                    signSide.setColor(DyeColor.legacyValueOf(colorTag.getValue()));
-                }
-                final List<Tag> lines = compoundTag.getList("messages");
-                for (int i = 0; i < Math.min(lines.size(), 4); i++) {
-                    final Tag line = lines.get(i);
-                    if (line instanceof StringTag stringLine) {
-                        signSide.setLine(i, jsonToColourCode(stringLine.getValue()));
-                        continue;
-                    }
-                    // TODO: how tf support list of components + components - utilize paper + adventure?
-                }
-            };
-            if (this.tag.getValue().get("front_text") instanceof CompoundTag frontText) {
-                sideSetter.accept(sign.getSide(Side.FRONT), frontText);
-            }
-            if (this.tag.getValue().get("back_text") instanceof CompoundTag backText) {
-                sideSetter.accept(sign.getSide(Side.BACK), backText);
-            }
-            return true;
-        }
-        return false;
-    }
-
 }

Core/src/main/java/com/plotsquared/core/command/Grant.java

@@ -177,14 +177,8 @@ public class Grant extends Command {
                 commands.addAll(TabCompletions.completePlayers(player, args[0], Collections.emptyList()));
             }
             return commands;
-        } else if (args.length == 2) {
-            final String subcommand = args[0].toLowerCase();
-            if ((subcommand.equals("add") && player.hasPermission(Permission.PERMISSION_GRANT_ADD)) ||
-                (subcommand.equals("check") && player.hasPermission(Permission.PERMISSION_GRANT_CHECK))) {
-                return TabCompletions.completePlayers(player, args[1], Collections.emptyList());
         }
-        }
+        return TabCompletions.completePlayers(player, String.join(",", args).trim(), Collections.emptyList());
-        return Collections.emptyList();
     }
 
 }

Core/src/main/java/com/plotsquared/core/command/MainCommand.java

@@ -283,35 +283,24 @@ public class MainCommand extends Command {
         }
     }
 
-    private CompletableFuture<Optional<CommandExecutionData>> preparePlotArgument(
+    private CompletableFuture<Optional<CommandExecutionData>> preparePlotArgument(@Nullable Plot newPlot,
-            @Nullable Plot newPlot,
                                                                         @Nonnull CommandExecutionData data,
-            @Nullable PlotArea area
+                                                                                  @Nullable PlotArea area) {
-    ) {
+        if (newPlot != null && (data.player() instanceof ConsolePlayer
-        if (newPlot == null) {
+                || (area != null && area.equals(newPlot.getArea()))
-            return CompletableFuture.completedFuture(Optional.of(data));
+                || data.player().hasPermission(Permission.PERMISSION_ADMIN)
-        }
+                || data.player().hasPermission(Permission.PERMISSION_ADMIN_AREA_SUDO))
-        final PlotPlayer<?> player = data.player();
+                && !newPlot.isDenied(data.player().getUUID())) {
-        final boolean isAdmin = player instanceof ConsolePlayer || player.hasPermission(Permission.PERMISSION_ADMIN);
-        final boolean isDenied = newPlot.isDenied(player.getUUID());
-        if (!isAdmin) {
-            if (isDenied) {
-                throw new CommandException(TranslatableCaption.of("deny.cannot_interact"));
-            }
-            if (area != null && area.equals(newPlot.getArea()) && !player.hasPermission(Permission.PERMISSION_ADMIN_AREA_SUDO)) {
-                return CompletableFuture.completedFuture(Optional.of(data));
-            }
-        }
             return fetchPlotCenterLocation(newPlot)
                     .thenApply(newLoc -> {
-                    if (!player.canTeleport(newLoc)) {
+                        if (!data.player().canTeleport(newLoc)) {
-                        player.sendMessage(TranslatableCaption.of("border.denied"));
+                            data.player().sendMessage(TranslatableCaption.of("border.denied"));
                             return Optional.empty();
                         }
                         // Save meta
-                    var originalCommandMeta = setCommandScope(player, new TemporaryCommandMeta(newLoc, newPlot));
+                        var originalCommandMeta = setCommandScope(data.player(), new TemporaryCommandMeta(newLoc, newPlot));
                         return Optional.of(new CommandExecutionData(
-                            player,
+                                data.player(),
                                 Arrays.copyOfRange(data.args(), 1, data.args().length), // Trimmed command
                                 data.confirm(),
                                 data.whenDone(),
@@ -319,6 +308,8 @@ public class MainCommand extends Command {
                         ));
                     });
         }
+        return CompletableFuture.completedFuture(Optional.of(data));
+    }
 
     private Optional<CommandExecutionData> prepareFlagArgument(@Nonnull CommandExecutionData data, @Nonnull PlotArea area) {
         if (data.args().length >= 2 && !data.args()[0].isEmpty() && data.args()[0].charAt(0) == '-') {

Core/src/main/java/com/plotsquared/core/util/placeholders/PlaceholderRegistry.java

@@ -49,12 +49,10 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.Locale;
 import java.util.Map;
-import java.util.Set;
 import java.util.TimeZone;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 import java.util.function.BiFunction;
-import java.util.stream.Collectors;
 
 /**
  * Registry that contains {@link Placeholder placeholders}
@@ -129,22 +127,6 @@ public final class PlaceholderRegistry {
             }
             return legacyComponent(TranslatableCaption.of("info.unknown"), player);
         });
-        this.createPlaceholder("currentplot_owners", (player, plot) -> {
-            if (plot.getFlag(ServerPlotFlag.class)) {
-                return legacyComponent(TranslatableCaption.of("info.server"), player);
-            }
-            final Set<UUID> plotOwners = plot.getOwners();
-            if (plotOwners.isEmpty()) {
-                return legacyComponent(TranslatableCaption.of("generic.generic_unowned"), player);
-            }
-            return plotOwners.stream().map(PlotSquared.platform().playerManager()::getUsernameCaption).map(f -> {
-                try {
-                    return f.get(Settings.UUID.BLOCKING_TIMEOUT, TimeUnit.MILLISECONDS).getComponent(player);
-                } catch (final Exception ignored) {
-                    return legacyComponent(TranslatableCaption.of("info.unknown"), player);
-                }
-            }).collect(Collectors.joining(", "));
-        });
         this.createPlaceholder("currentplot_members", (player, plot) -> {
             if (plot.getMembers().isEmpty() && plot.getTrusted().isEmpty()) {
                 return legacyComponent(TranslatableCaption.of("info.none"), player);

Core/src/main/resources/lang/messages_en.json

@@ -415,7 +415,6 @@
   "deny.denied_added": "<prefix><dark_aqua>You successfully denied the player from this plot.</dark_aqua>",
   "deny.no_enter": "<prefix><red>You are denied from the plot <red><gold><plot></gold><red> and therefore not allowed to enter.</red>",
   "deny.you_got_denied": "<prefix><red>You are denied from the plot you were previously on, and got teleported to spawn.</red>",
-  "deny.cannot_interact": "<prefix><red>You are denied from the plot <red><gold><plot></gold><red> and therefore cannot interact with it.</red>",
   "deny.cant_remove_owner": "<prefix><red>You can't remove the plot owner.</red>",
   "kick.player_not_in_plot": "<prefix><red>The player <gray><player></gray> is not on this plot.</red>",
   "kick.cannot_kick_player": "<prefix><red>You cannot kick the player <gray><player></gray>.</red>",

gradle/libs.versions.toml

@@ -2,21 +2,21 @@
 # Platform expectations
 paper = "1.20.4-R0.1-SNAPSHOT"
 guice = "7.0.0"
-spotbugs = "4.9.4"
+spotbugs = "4.9.3"
 checkerqual = "3.49.5"
 gson = "2.10"
 guava = "31.1-jre"
 snakeyaml = "2.0"
-adventure = "4.24.0"
+adventure = "4.23.0"
 adventure-bukkit = "4.4.1"
 log4j = "2.19.0"
 
 # Plugins
 worldedit = "7.2.20"
-fawe = "2.13.1"
+fawe = "2.13.0"
 placeholderapi = "2.11.6"
 luckperms = "5.5"
-essentialsx = "2.21.2"
+essentialsx = "2.21.1"
 mvdwapi = "3.1.1"
 
 # Third party
@@ -33,7 +33,7 @@ vault = "1.7.1"
 serverlib = "2.3.7"
 
 # Gradle plugins
-shadow = "8.3.9"
+shadow = "8.3.8"
 grgit = "4.1.1"
 spotless = "7.2.1"
 publish = "0.34.0"

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.0.0-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

gradlew

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 #
-# Copyright © 2015-2021 the original authors.
+# Copyright © 2015 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.