javonet-ruby-sdk 2.1.12 → 2.1.14

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/interpreter/Interpreter.js

@@ -1,21 +1,27 @@
 const { Handler } = require('../handler/Handler')
-const CommandEncoder = require('../protocol/CommandEncoder')
-const CommandDecoder = require('../protocol/CommandDecoder')
+const CommandSerializer = require('../protocol/CommandSerializer')
+const CommandDeserializer = require('../protocol/CommandDeserializer')
 const Runtime = require("../../utils/RuntimeName");
 
 let Transmitter
+let Receiver
 
 class Interpreter {
     handler = new Handler()
 
     execute(command, connectionType, tcpAddress) {
-        let commandEncoder = new CommandEncoder()
-        let byteMessage = commandEncoder.encode(command,connectionType, tcpAddress)
+        let commandSerializer = new CommandSerializer()
+        let byteMessage = commandSerializer.serialize(command,connectionType, tcpAddress)
         let responseByteArray
 
         if (command.runtimeName === Runtime.Nodejs)
         {
-            return this.process(byteMessage)
+            // lazy receiver loading
+            if (!Receiver) {
+                Receiver = require('../receiver/Receiver')
+            }
+            responseByteArray = Receiver.sendCommand(byteMessage)
+
         }
         else {
             // lazy transmitter loading
@@ -23,14 +29,16 @@ class Interpreter {
                 Transmitter = require('../transmitter/Transmitter')
             }
             responseByteArray = Transmitter.sendCommand(byteMessage)
-            return new CommandDecoder(responseByteArray).decode()
         }
+        return new CommandDeserializer(responseByteArray).deserialize()
     }
 
     process(byteArray) {
-        let decoder = new CommandDecoder(byteArray)
-        let command = decoder.decode()
-        return this.handler.handleCommand(command)
+        let commandDeserializer = new CommandDeserializer(byteArray)
+        let receivedCommand = commandDeserializer.deserialize()
+        let responseCommand = this.handler.handleCommand(receivedCommand)
+        let commandSerializer = new CommandSerializer()
+        return commandSerializer.serialize(responseCommand, 0, "0.0.0.0:0")
     }
 }
 

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/protocol/CommandDeserializer.js

@@ -0,0 +1,160 @@
+const TypeDeserializer = require("./TypeDeserializer")
+const Command = require("../../utils/Command")
+const Type = require("../../utils/Type")
+const StringEncodingMode = require("../../utils/StringEncodingMode")
+
+
+class CommandDeserializer {
+    constructor(buffer) {
+        this.buffer = buffer
+        this.command = new Command(
+            buffer[0],
+            buffer[10],
+            []
+        )
+        this.position = 11
+    }
+
+    deserialize() {
+        while (!this.isAtEnd()) {
+            this.command = this.command.addArgToPayload((this.readObject(this.buffer[this.position])))
+        }
+        return this.command
+    }
+
+    isAtEnd() {
+        return this.position === this.buffer.length
+    }
+
+    readObject(typeNum) {
+        let type = Object.entries(Type).find(entry => entry[1] === typeNum)[0]
+        switch (type) {
+            case 'JAVONET_COMMAND':
+                return this.readCommand()
+            case 'JAVONET_STRING':
+                return this.readString()
+            case 'JAVONET_INTEGER':
+                return this.readInt()
+            case 'JAVONET_BOOLEAN':
+                return this.readBool();
+            case 'JAVONET_FLOAT':
+                return this.readFloat();
+            case 'JAVONET_BYTE':
+                return this.readByte();
+            case 'JAVONET_CHAR':
+                return this.readChar();
+            case 'JAVONET_LONG_LONG':
+                return this.readLongLong();
+            case 'JAVONET_DOUBLE':
+                return this.readDouble();
+            case 'JAVONET_UNSIGNED_LONG_LONG':
+                return this.readUllong
+            case 'JAVONET_UNSIGNED_INTEGER':
+                return this.readUInt()
+            default:
+                throw 'Unknown type - not supported in JavaScript'
+        }
+    }
+
+    readCommand() {
+        let p = this.position
+        let numberOfElementsInPayload = TypeDeserializer.deserializeInt(this.buffer.slice(p + 1, p + 5))
+        let runtime = this.buffer[p + 5]
+        let type = this.buffer[p + 6]
+        this.position += 7
+        let command = new Command(runtime, type, [])
+        return this.readCommandRecursively(numberOfElementsInPayload, command)
+    }
+
+    readCommandRecursively(numberOfElementsInPayloadLeft, cmd) {
+        if (numberOfElementsInPayloadLeft === 0) return cmd
+        let p = this.position
+        cmd = cmd.addArgToPayload(this.readObject(this.buffer[p]))
+        return this.readCommandRecursively(numberOfElementsInPayloadLeft - 1, cmd)
+    }
+
+    readString() {
+        let p = this.position
+        let stringEncodingMode = this.buffer[p + 1]
+        let size = TypeDeserializer.deserializeInt(this.buffer.slice(p + 2, p + 6))
+        this.position += 6
+        p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeString(stringEncodingMode, this.buffer.slice(p, p + size))
+
+    }
+
+    readInt() {
+        let size = 4
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeInt(this.buffer.slice(p, p + size))
+    }
+
+    readBool() {
+        let size = 1
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeBool(this.buffer.slice(p, p + size))
+    }
+
+    readFloat() {
+        let size = 4
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeFloat(this.buffer.slice(p, p + size))
+    }
+
+    readByte() {
+        let size = 1
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeByte(this.buffer.slice(p, p + size))
+    }
+
+    readChar() {
+        let size = 1
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeChar(this.buffer.slice(p, p + size))
+    }
+
+    readLongLong() {
+        let size = 8
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeLongLong(this.buffer.slice(p, p + size))
+    }
+
+    readDouble() {
+        let size = 8
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeDouble(this.buffer.slice(p, p + size))
+    }
+
+    readUllong() {
+        let size = 8
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeULLong(this.buffer.slice(p, p + size))
+    }
+
+    readUInt() {
+        let size = 4
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeUInt(this.buffer.slice(p, p + size))
+    }
+}
+
+module.exports = CommandDeserializer

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/protocol/{CommandEncoder.js → CommandSerializer.js}

@@ -1,13 +1,13 @@
 const Command = require("../../utils/Command")
-const TypeEncoder = require('./TypeEncoder')
+const TypeEncoder = require('./TypeSerializer')
 const ConnectionType = require("../../utils/ConnectionType");
 const Runtime = require('../../utils/RuntimeName')
 
-class CommandEncoder {
+class CommandSerializer {
     buffer = new Int8Array(2)
     encodedTcp;
 
-    encode(command, connectionType, tcpConnectionData, runtimeVersion = 0) {
+    serialize(command, connectionType, tcpConnectionData, runtimeVersion = 0) {
         let deque = [command]
         this.buffer[0] = command.runtimeName
         this.buffer[1] = runtimeVersion
@@ -48,7 +48,7 @@ class CommandEncoder {
         if (cmd.payload.length > 0) {
             if (cmd.payload[0] instanceof Command) {
                 let innerCommand = cmd.payload[0]
-                this.#insertIntoBuffer(TypeEncoder.encodeCommand(innerCommand))
+                this.#insertIntoBuffer(TypeEncoder.serializeCommand(innerCommand))
                 deque.push(innerCommand)
             } else {
                 let result = TypeEncoder.encodePrimitive(cmd.payload[0])
@@ -69,4 +69,4 @@ class CommandEncoder {
     }
 }
 
-module.exports = CommandEncoder
+module.exports = CommandSerializer

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/protocol/TypeDeserializer.js

@@ -0,0 +1,77 @@
+const Command = require('../../utils/Command')
+const Type = require('../../utils/Type')
+const StringEncodingMode = require('../../utils/StringEncodingMode')
+const {TextDecoder} = require("util");
+
+class TypeDeserializer {
+    static deserializeCommand(encodedCommand) {
+        return new Command(encodedCommand[0], encodedCommand[1], [])
+    }
+
+    static deserializeString(stringEncodingMode, encodedString) {
+        switch (stringEncodingMode) {
+            case StringEncodingMode.ASCII:
+                return String.fromCharCode(...encodedString)
+            case StringEncodingMode.UTF8:
+                let decoder = new TextDecoder('UTF-8');
+                return decoder.decode(new Uint8Array(encodedString))
+            case StringEncodingMode.UTF16:
+                let str = "";
+                let newBuffer = new Uint8Array(encodedString)
+                for (let i = 0; i < newBuffer.length; i++) {
+                    newBuffer[i] = encodedString[i]
+                }
+                for (let i = 0; i < encodedString.length; i = i + 2) {
+                    str += String.fromCharCode(newBuffer[i] + 256 * newBuffer[i + 1])
+                }
+                return str;
+            case StringEncodingMode.UTF32:
+                throw "Type utf32-encoded string not supported in JavaScript"
+            default:
+                throw "Unknown string encoding - not supported in JavaScript";
+        }
+    }
+
+    static deserializeInt(encodedInt) {
+        return (
+            (encodedInt[0] & 0xFF)
+            | ((encodedInt[1] & 0xFF) << 8)
+            | ((encodedInt[2] & 0xFF) << 16)
+            | ((encodedInt[3] & 0xFF) << 24)
+        )
+    }
+
+    static deserializeBool(encodedBool) {
+        return encodedBool[0] === 1
+    }
+
+    static deserializeFloat(encodedFloat) {
+        return Buffer.from(encodedFloat).readFloatLE()
+    }
+
+    static deserializeByte(encodedByte) {
+        return Buffer.from(encodedByte).readUint8()
+    }
+
+    static deserializeChar(encodedChar) {
+        return Buffer.from(encodedChar).readUint8()
+    }
+
+    static deserializeLongLong(encodedLongLong) {
+        return Buffer.from(encodedLongLong).readBigInt64LE()
+    }
+
+    static deserializeDouble(encodedDouble) {
+        return Buffer.from(encodedDouble).readDoubleLE()
+    }
+
+    static deserializeULLong(encodedULLong) {
+        return Buffer.from(encodedULLong).readBigUInt64LE()
+    }
+
+    static deserializeUInt(encodedUInt) {
+        return Buffer.from(encodedUInt).readUIntLE(0, 4)
+    }
+}
+
+module.exports = TypeDeserializer

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/protocol/TypeSerializer.js

@@ -0,0 +1,126 @@
+const Command = require('../../utils/Command')
+const Type = require('../../utils/Type')
+const StringEncodingMode = require('../../utils/StringEncodingMode')
+
+const util = require('util');
+let encoder = new util.TextEncoder();
+
+class TypeSerializer {
+
+    static encodePrimitive(payload_item) {
+        if (payload_item instanceof Command) {
+            return TypeSerializer.serializeCommand(payload_item)
+        } else if (typeof (payload_item) === 'number' || payload_item instanceof Number) {
+            if (Number.isInteger(payload_item)) {
+                return TypeSerializer.serializeInt(payload_item)
+            } else {
+                return TypeSerializer.serializeDouble(payload_item)
+            }
+        } else if (typeof (payload_item) === 'string' || payload_item instanceof String) {
+            return TypeSerializer.serializeString(payload_item)
+        } else if (typeof (payload_item) === 'boolean' || payload_item instanceof Boolean) {
+            return TypeSerializer.serializeBool(payload_item)
+        } else {
+            throw 'Unknown type - not supported in JavaScript'
+        }
+    }
+
+    static serializeCommand(command) {
+        const buffer = Buffer.alloc(7, command)
+        buffer.writeUInt8(Type.JAVONET_COMMAND, 0)
+        buffer.fill(Buffer.from(this.serializeIntValue(command.payload.length)), 1, 5)
+        buffer.writeUInt8(command.runtime, 5)
+        buffer.writeUInt8(command.commandType, 6)
+        return buffer
+    }
+
+    static serializeString(string_value) {
+        let bytes = encoder.encode(string_value)
+        const buffer = Buffer.alloc(6 + bytes.length)
+        buffer.writeUInt8(Type.JAVONET_STRING, 0)
+        buffer.writeUInt8(StringEncodingMode.UTF8, 1)
+        buffer.fill(Buffer.from(this.serializeIntValue(bytes.length)), 2, 6)
+        buffer.fill(Buffer.from(bytes), 6, 6 + bytes.length)
+        return buffer
+    }
+
+    static serializeInt(int_value) {
+        const buffer = Buffer.alloc(6)
+        buffer.writeUInt8(Type.JAVONET_INTEGER, 0)
+        buffer.writeUInt8(4, 1)
+        buffer.writeInt32LE(int_value, 2)
+        return buffer
+    }
+
+    static serializeBool(bool_value) {
+        const buffer = Buffer.alloc(3)
+        buffer.writeUInt8(Type.JAVONET_BOOLEAN, 0)
+        buffer.writeUInt8(1, 1)
+        buffer.writeUInt8(bool_value ? 1 : 0, 2)
+        return buffer
+    }
+
+    static serializeFloat(float_value) {
+        const buffer = Buffer.alloc(6)
+        buffer.writeUInt8(Type.JAVONET_FLOAT, 0)
+        buffer.writeUInt8(4, 1)
+        buffer.writeFloatLE(float_value, 2)
+        return buffer
+    }
+
+    static serializeByte(byte_value) {
+        const buffer = Buffer.alloc(3)
+        buffer.writeUInt8(Type.JAVONET_BYTE, 0)
+        buffer.writeUInt8(1, 1)
+        buffer.writeUInt8(byte_value, 2)
+        return buffer
+    }
+
+    static serializeChar(char_value) {
+        const buffer = Buffer.alloc(3)
+        buffer.writeUInt8(Type.JAVONET_CHAR, 0)
+        buffer.writeUInt8(1, 1)
+        buffer.writeUInt8(char_value, 2)
+        return buffer
+    }
+
+    static serializeLongLong(longlong_value) {
+        const buffer = Buffer.alloc(10)
+        buffer.writeUInt8(Type.JAVONET_LONG_LONG, 0)
+        buffer.writeUInt8(8, 1)
+        buffer.writeBigInt64LE(BigInt(longlong_value), 2)
+        return buffer
+    }
+
+    static serializeDouble(double_value) {
+        const buffer = Buffer.alloc(10)
+        buffer.writeUInt8(Type.JAVONET_DOUBLE, 0)
+        buffer.writeUInt8(8, 1)
+        buffer.writeDoubleLE(double_value, 2)
+        return buffer
+    }
+
+    static serializeULLong(ullong_value) {
+        const buffer = Buffer.alloc(10)
+        buffer.writeUInt8(Type.JAVONET_UNSIGNED_LONG_LONG, 0)
+        buffer.writeUInt8(8, 1)
+        buffer.writeBigUInt64LE(ullong_value, 2)
+        return buffer
+    }
+
+    static serializeUInt(uint_value) {
+        const buffer = Buffer.alloc(6)
+        buffer.writeUInt8(Type.JAVONET_UNSIGNED_INTEGER, 0)
+        buffer.writeUInt8(4, 1)
+        buffer.writeUInt32LE(uint_value, 2)
+        return buffer
+    }
+
+    static serializeIntValue(int_value) {
+        const buffer = Buffer.alloc(4)
+        buffer.writeInt32LE(int_value, 0)
+        return buffer
+    }
+}
+
+module.exports = TypeSerializer

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/core/receiver/Receiver.js

@@ -1,12 +1,9 @@
 const Interpreter = require('../interpreter/Interpreter')
-const CommandEncoder = require('../protocol/CommandEncoder')
 const interpreter = new Interpreter()
 
 class Receiver {
     static sendCommand(byteArray) {
-        let command = interpreter.process(byteArray)
-        let commandEncoder = new CommandEncoder()
-        return commandEncoder.encode(command, 0, 0)
+        return interpreter.process(byteArray)
     }
     static heartBeat(byteArray) {
         return Int8Array.from([49, 48])

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Windows/X64/utils/RuntimeName.js

@@ -6,5 +6,6 @@ module.exports = {
     Perl: 4,
     Python: 5,
     Ruby: 6,
-    Nodejs: 7
+    Nodejs: 7,
+    Cpp: 8
 }

data/lib/javonet-ruby-sdk/Binaries/Perl/Linux/X64/deps/lib/perl5/Devel/StackTrace/Frame.pm

@@ -3,7 +3,7 @@ package Devel::StackTrace::Frame;
 use strict;
 use warnings;
 
-our $VERSION = '2.04';
+our $VERSION = '2.05';
 
 # Create accessor routines
 BEGIN {
@@ -183,7 +183,7 @@ Devel::StackTrace::Frame - A single frame in a stack trace
 
 =head1 VERSION
 
-version 2.04
+version 2.05
 
 =head1 DESCRIPTION
 
@@ -193,21 +193,34 @@ See L<Devel::StackTrace> for details.
 
 =head1 METHODS
 
-See Perl's C<caller> documentation for more information on what these
-methods return.
+See Perl's C<caller> documentation for more information on what these methods
+return.
 
 =head2 $frame->package
 
+The package which created this frame.
+
 =head2 $frame->filename
 
+The filename which created this frame.
+
 =head2 $frame->line
 
+The line where the frame was created.
+
 =head2 $frame->subroutine
 
+The subroutine which created this frame.
+
 =head2 $frame->hasargs
 
+This will be true if a new C<@_> was created for this this frame.
+
 =head2 $frame->wantarray
 
+This indicates the context for the call for this frame. This will be true if
+called in array context, false in scalar context, and C<undef> in void context.
+
 =head2 $frame->evaltext
 
 Returns undef if the frame was not part of an eval.
@@ -223,8 +236,12 @@ references are returned as references, not copies.
 
 =head2 $frame->hints
 
+Returns the value of C<$^H> for this frame.
+
 =head2 $frame->bitmask
 
+Returns the value of C<$bitmask> for this frame.
+
 =head2 $frame->as_string
 
 Returns a string containing a description of the frame.
@@ -233,8 +250,6 @@ Returns a string containing a description of the frame.
 
 Bugs may be submitted at L<https://github.com/houseabsolute/Devel-StackTrace/issues>.
 
-I am also usually active on IRC as 'autarch' on C<irc://irc.perl.org>.
-
 =head1 SOURCE
 
 The source code repository for Devel-StackTrace can be found at L<https://github.com/houseabsolute/Devel-StackTrace>.
@@ -245,7 +260,7 @@ Dave Rolsky <autarch@urth.org>
 
 =head1 COPYRIGHT AND LICENSE
 
-This software is Copyright (c) 2000 - 2019 by David Rolsky.
+This software is Copyright (c) 2000 - 2024 by David Rolsky.
 
 This is free software, licensed under:
 

data/lib/javonet-ruby-sdk/Binaries/Perl/Linux/X64/deps/lib/perl5/Devel/StackTrace.pm

@@ -5,7 +5,7 @@ use 5.006;
 use strict;
 use warnings;
 
-our $VERSION = '2.04';
+our $VERSION = '2.05';
 
 use Devel::StackTrace::Frame;
 use File::Spec;
@@ -13,6 +13,7 @@ use Scalar::Util qw( blessed );
 
 use overload
     '""'     => \&as_string,
+    bool     => sub {1},
     fallback => 1;
 
 sub new {
@@ -324,7 +325,7 @@ Devel::StackTrace - An object representing a stack trace
 
 =head1 VERSION
 
-version 2.04
+version 2.05
 
 =head1 SYNOPSIS
 
@@ -347,8 +348,8 @@ version 2.04
 =head1 DESCRIPTION
 
 The C<Devel::StackTrace> module contains two classes, C<Devel::StackTrace> and
-L<Devel::StackTrace::Frame>. These objects encapsulate the information that
-can retrieved via Perl's C<caller> function, as well as providing a simple
+L<Devel::StackTrace::Frame>. These objects encapsulate the information that can
+retrieved via Perl's C<caller> function, as well as providing a simple
 interface to this data.
 
 The C<Devel::StackTrace> object contains a set of C<Devel::StackTrace::Frame>
@@ -412,13 +413,12 @@ stacktrace is created, and before refs are stringified (if
 C<unsafe_ref_capture> is not set), rather than being filtered lazily when
 L<Devel::StackTrace::Frame> objects are first needed.
 
-This is useful if you want to filter based on the frame's arguments and want
-to be able to examine object properties, for example.
+This is useful if you want to filter based on the frame's arguments and want to
+be able to examine object properties, for example.
 
 =item * ignore_package => $package_name OR \@package_names
 
-Any frames where the package is one of these packages will not be on the
-stack.
+Any frames where the package is one of these packages will not be on the stack.
 
 =item * ignore_class => $package_name OR \@package_names
 
@@ -433,8 +433,8 @@ you create a subclass of Devel::StackTrace it will not be ignored.
 
 This will cause this number of stack frames to be excluded from top of the
 stack trace. This prevents the frames from being captured at all, and applies
-before the C<frame_filter>, C<ignore_package>, or C<ignore_class> options,
-even with C<filter_frames_early>.
+before the C<frame_filter>, C<ignore_package>, or C<ignore_class> options, even
+with C<filter_frames_early>.
 
 =item * unsafe_ref_capture => $boolean
 
@@ -459,9 +459,8 @@ arguments in stack trace frames at all.
 
 By default, Devel::StackTrace will call C<overload::AddrRef> to get the
 underlying string representation of an object, instead of respecting the
-object's stringification overloading. If you would prefer to see the
-overloaded representation of objects in stack traces, then set this parameter
-to true.
+object's stringification overloading. If you would prefer to see the overloaded
+representation of objects in stack traces, then set this parameter to true.
 
 =item * max_arg_length => $integer
 
@@ -485,11 +484,11 @@ tab character, just like C<Carp::confess>.
 
 =head2 $trace->next_frame
 
-Returns the next L<Devel::StackTrace::Frame> object on the stack, going
-down. If this method hasn't been called before it returns the first frame. It
-returns C<undef> when it reaches the bottom of the stack and then resets its
-pointer so the next call to C<< $trace->next_frame >> or C<<
-$trace->prev_frame >> will work properly.
+Returns the next L<Devel::StackTrace::Frame> object on the stack, going down.
+If this method hasn't been called before it returns the first frame. It returns
+C<undef> when it reaches the bottom of the stack and then resets its pointer so
+the next call to C<< $trace->next_frame >> or C<< $trace->prev_frame >> will
+work properly.
 
 =head2 $trace->prev_frame
 
@@ -521,9 +520,9 @@ complex than can be handled by the C<< $trace->filter_frames >> method:
 
 =head2 $trace->frame($index)
 
-Given an index, this method returns the relevant frame, or undef if there is
-no frame at that index. The index is exactly like a Perl array. The first
-frame is 0 and negative indexes are allowed.
+Given an index, this method returns the relevant frame, or undef if there is no
+frame at that index. The index is exactly like a Perl array. The first frame is
+0 and negative indexes are allowed.
 
 =head2 $trace->frame_count
 
@@ -550,8 +549,6 @@ method returns C<undef>.
 
 Bugs may be submitted at L<https://github.com/houseabsolute/Devel-StackTrace/issues>.
 
-I am also usually active on IRC as 'autarch' on C<irc://irc.perl.org>.
-
 =head1 SOURCE
 
 The source code repository for Devel-StackTrace can be found at L<https://github.com/houseabsolute/Devel-StackTrace>.
@@ -571,7 +568,7 @@ software much more, unless I get so many donations that I can consider working
 on free software full time (let's all have a chuckle at that together).
 
 To donate, log into PayPal and send money to autarch@urth.org, or use the
-button at L<http://www.urth.org/~autarch/fs-donation.html>.
+button at L<https://houseabsolute.com/foss-donations/>.
 
 =head1 AUTHOR
 
@@ -615,7 +612,7 @@ Ricardo Signes <rjbs@cpan.org>
 
 =head1 COPYRIGHT AND LICENSE
 
-This software is Copyright (c) 2000 - 2019 by David Rolsky.
+This software is Copyright (c) 2000 - 2024 by David Rolsky.
 
 This is free software, licensed under: