rbs 4.1.0.pre.2-java

data/src/util/rbs_unescape.c

@@ -0,0 +1,167 @@
+#include "rbs/util/rbs_unescape.h"
+#include "rbs/util/rbs_encoding.h"
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+// Define the escape character mappings
+// TODO: use a switch instead
+static const struct {
+    const char *from;
+    const char *to;
+} TABLE[] = {
+    { "\\a", "\a" },
+    { "\\b", "\b" },
+    { "\\e", "\033" },
+    { "\\f", "\f" },
+    { "\\n", "\n" },
+    { "\\r", "\r" },
+    { "\\s", " " },
+    { "\\t", "\t" },
+    { "\\v", "\v" },
+    { "\\\"", "\"" },
+    { "\\'", "'" },
+    { "\\\\", "\\" },
+    { "\\", "" }
+};
+
+// Helper function to convert hex string to integer
+static int hex_to_int(const char *hex, int length) {
+    int result = 0;
+    for (int i = 0; i < length; i++) {
+        result = result * 16 + (isdigit(hex[i]) ? hex[i] - '0' : tolower(hex[i]) - 'a' + 10);
+    }
+    return result;
+}
+
+// Helper function to convert octal string to integer
+static int octal_to_int(const char *octal, int length) {
+    int result = 0;
+    for (int i = 0; i < length; i++) {
+        result = result * 8 + (octal[i] - '0');
+    }
+    return result;
+}
+
+// Fills buf starting at index 'start' with the UTF-8 encoding of 'codepoint'.
+// Returns the number of bytes written, or 0 when the output is not changed.
+//
+size_t rbs_utf8_fill_codepoint(char *buf, size_t start, size_t end, unsigned int codepoint) {
+    if (start + 4 > end) {
+        return 0;
+    }
+
+    if (codepoint <= 0x7F) {
+        buf[start] = codepoint & 0x7F;
+        return 1;
+    } else if (codepoint <= 0x7FF) {
+        buf[start + 0] = 0xC0 | ((codepoint >> 6) & 0x1F);
+        buf[start + 1] = 0x80 | (codepoint & 0x3F);
+        return 2;
+    } else if (codepoint <= 0xFFFF) {
+        buf[start + 0] = 0xE0 | ((codepoint >> 12) & 0x0F);
+        buf[start + 1] = 0x80 | ((codepoint >> 6) & 0x3F);
+        buf[start + 2] = 0x80 | (codepoint & 0x3F);
+        return 3;
+    } else if (codepoint <= 0x10FFFF) {
+        buf[start + 0] = 0xF0 | ((codepoint >> 18) & 0x07);
+        buf[start + 1] = 0x80 | ((codepoint >> 12) & 0x3F);
+        buf[start + 2] = 0x80 | ((codepoint >> 6) & 0x3F);
+        buf[start + 3] = 0x80 | (codepoint & 0x3F);
+        return 4;
+    } else {
+        return 0;
+    }
+}
+
+rbs_string_t unescape_string(rbs_allocator_t *allocator, const rbs_string_t string, bool is_double_quote, bool is_unicode) {
+    if (!string.start) return RBS_STRING_NULL;
+
+    size_t len = string.end - string.start;
+    const char *input = string.start;
+
+    // The output cannot be longer than the input even after unescaping.
+    char *output = rbs_allocator_alloc_many(allocator, len + 1, char);
+    if (!output) return RBS_STRING_NULL;
+
+    size_t i = 0, j = 0;
+    while (i < len) {
+        if (input[i] == '\\' && i + 1 < len) {
+            if (is_double_quote) {
+                if (isdigit(input[i + 1])) {
+                    // Octal escape
+                    int octal_len = 1;
+                    while (octal_len < 3 && i + 1 + octal_len < len && isdigit(input[i + 1 + octal_len]))
+                        octal_len++;
+                    int value = octal_to_int(input + i + 1, octal_len);
+                    output[j++] = (char) value;
+                    i += octal_len + 1;
+                } else if (input[i + 1] == 'x' && i + 3 < len) {
+                    // Hex escape
+                    int hex_len = isxdigit(input[i + 3]) ? 2 : 1;
+                    int value = hex_to_int(input + i + 2, hex_len);
+                    output[j++] = (char) value;
+                    i += hex_len + 2;
+                } else if (input[i + 1] == 'u' && i + 5 < len) {
+                    // Unicode escape
+
+                    if (is_unicode) {
+                        // The UTF-8 representation is at most 4 bytes, shorter than the input length.
+                        int value = hex_to_int(input + i + 2, 4);
+                        j += rbs_utf8_fill_codepoint(output, j, len + 1, value);
+                        i += 6;
+                    } else {
+                        // Copy the escape sequence as-is
+                        output[j++] = input[i++];
+                        output[j++] = input[i++];
+                        output[j++] = input[i++];
+                        output[j++] = input[i++];
+                        output[j++] = input[i++];
+                        output[j++] = input[i++];
+                    }
+                } else {
+                    // Other escapes
+                    int found = 0;
+                    for (size_t k = 0; k < sizeof(TABLE) / sizeof(TABLE[0]); k++) {
+                        if (strncmp(input + i, TABLE[k].from, strlen(TABLE[k].from)) == 0) {
+                            output[j++] = TABLE[k].to[0];
+                            i += strlen(TABLE[k].from);
+                            found = 1;
+                            break;
+                        }
+                    }
+                    if (!found) {
+                        output[j++] = input[i++];
+                    }
+                }
+            } else {
+                /* Single quote: only escape ' and \ */
+                if (input[i + 1] == '\'' || input[i + 1] == '\\') {
+                    output[j++] = input[i + 1];
+                    i += 2;
+                } else {
+                    output[j++] = input[i++];
+                }
+            }
+        } else {
+            output[j++] = input[i++];
+        }
+    }
+    output[j] = '\0';
+    return rbs_string_new(output, output + j);
+}
+
+rbs_string_t rbs_unquote_string(rbs_allocator_t *allocator, rbs_string_t input, const rbs_encoding_t *encoding) {
+    unsigned int first_char = input.start[0];
+
+    const char *new_start = input.start;
+    const char *new_end = input.end;
+
+    if (first_char == '"' || first_char == '\'' || first_char == '`') {
+        new_start += 1;
+        new_end -= 1;
+    }
+
+    rbs_string_t string = rbs_string_new(new_start, new_end);
+    return unescape_string(allocator, string, first_char == '"', encoding == RBS_ENCODING_UTF_8_ENTRY);
+}

data/stdlib/abbrev/0/abbrev.rbs

@@ -0,0 +1,66 @@
+# <!-- rdoc-file=lib/abbrev.rb -->
+# Calculates the set of unambiguous abbreviations for a given set of strings.
+#
+#     require 'abbrev'
+#     require 'pp'
+#
+#     pp Abbrev.abbrev(['ruby'])
+#     #=>  {"ruby"=>"ruby", "rub"=>"ruby", "ru"=>"ruby", "r"=>"ruby"}
+#
+#     pp Abbrev.abbrev(%w{ ruby rules })
+#
+# *Generates:*
+#     { "ruby"  =>  "ruby",
+#       "rub"   =>  "ruby",
+#       "rules" =>  "rules",
+#       "rule"  =>  "rules",
+#       "rul"   =>  "rules" }
+#
+# It also provides an array core extension, Array#abbrev.
+#
+#     pp %w{ summer winter }.abbrev
+#
+# *Generates:*
+#     { "summer"  => "summer",
+#       "summe"   => "summer",
+#       "summ"    => "summer",
+#       "sum"     => "summer",
+#       "su"      => "summer",
+#       "s"       => "summer",
+#       "winter"  => "winter",
+#       "winte"   => "winter",
+#       "wint"    => "winter",
+#       "win"     => "winter",
+#       "wi"      => "winter",
+#       "w"       => "winter" }
+#
+module Abbrev
+  # <!--
+  #   rdoc-file=lib/abbrev.rb
+  #   - abbrev(words, pattern = nil)
+  # -->
+  # Given a set of strings, calculate the set of unambiguous abbreviations for
+  # those strings, and return a hash where the keys are all the possible
+  # abbreviations and the values are the full strings.
+  #
+  # Thus, given `words` is "car" and "cone", the keys pointing to "car" would be
+  # "ca" and "car", while those pointing to "cone" would be "co", "con", and
+  # "cone".
+  #
+  #     require 'abbrev'
+  #
+  #     Abbrev.abbrev(%w{ car cone })
+  #     #=> {"ca"=>"car", "con"=>"cone", "co"=>"cone", "car"=>"car", "cone"=>"cone"}
+  #
+  # The optional `pattern` parameter is a pattern or a string. Only input strings
+  # that match the pattern or start with the string are included in the output
+  # hash.
+  #
+  #     Abbrev.abbrev(%w{car box cone crab}, /b/)
+  #     #=> {"box"=>"box", "bo"=>"box", "b"=>"box", "crab" => "crab"}
+  #
+  #     Abbrev.abbrev(%w{car box cone}, 'ca')
+  #     #=> {"car"=>"car", "ca"=>"car"}
+  #
+  def self?.abbrev: (Array[String], ?String | Regexp | nil) -> Hash[String, String]
+end

data/stdlib/abbrev/0/array.rbs

@@ -0,0 +1,26 @@
+%a{annotate:rdoc:skip}
+class Array[unchecked out E]
+  # <!--
+  #   rdoc-file=lib/abbrev.rb
+  #   - abbrev(pattern = nil)
+  # -->
+  # Calculates the set of unambiguous abbreviations for the strings in `self`.
+  #
+  #     require 'abbrev'
+  #     %w{ car cone }.abbrev
+  #     #=> {"car"=>"car", "ca"=>"car", "cone"=>"cone", "con"=>"cone", "co"=>"cone"}
+  #
+  # The optional `pattern` parameter is a pattern or a string. Only input strings
+  # that match the pattern or start with the string are included in the output
+  # hash.
+  #
+  #     %w{ fast boat day }.abbrev(/^.a/)
+  #     #=> {"fast"=>"fast", "fas"=>"fast", "fa"=>"fast", "day"=>"day", "da"=>"day"}
+  #
+  #     Abbrev.abbrev(%w{car box cone}, "ca")
+  #     #=> {"car"=>"car", "ca"=>"car"}
+  #
+  # See also Abbrev.abbrev
+  #
+  def abbrev: (?String | Regexp | nil) -> Hash[String, String]
+end

data/stdlib/base64/0/base64.rbs

@@ -0,0 +1,355 @@
+# <!-- rdoc-file=lib/base64.rb -->
+# Module Base64 provides methods for:
+#
+# *   Encoding a binary string (containing non-ASCII characters) as a string of
+#     printable ASCII characters.
+# *   Decoding such an encoded string.
+#
+# Base64 is commonly used in contexts where binary data is not allowed or
+# supported:
+#
+# *   Images in HTML or CSS files, or in URLs.
+# *   Email attachments.
+#
+# A Base64-encoded string is about one-third larger that its source. See the
+# [Wikipedia article](https://en.wikipedia.org/wiki/Base64) for more
+# information.
+#
+# This module provides three pairs of encode/decode methods. Your choices among
+# these methods should depend on:
+#
+# *   Which character set is to be used for encoding and decoding.
+# *   Whether "padding" is to be used.
+# *   Whether encoded strings are to contain newlines.
+#
+# Note: Examples on this page assume that the including program has executed:
+#
+#     require 'base64'
+#
+# ## Encoding Character Sets
+#
+# A Base64-encoded string consists only of characters from a 64-character set:
+#
+# *   `('A'..'Z')`.
+# *   `('a'..'z')`.
+# *   `('0'..'9')`.
+# *   `=`, the 'padding' character.
+# *   Either:
+#     *   `%w[+ /]`:
+#         [RFC-2045-compliant](https://datatracker.ietf.org/doc/html/rfc2045);
+#         *not* safe for URLs.
+#     *   `%w[- _]`:
+#         [RFC-4648-compliant](https://datatracker.ietf.org/doc/html/rfc4648);
+#         safe for URLs.
+#
+# If you are working with Base64-encoded strings that will come from or be put
+# into URLs, you should choose this encoder-decoder pair of RFC-4648-compliant
+# methods:
+#
+# *   Base64.urlsafe_encode64 and Base64.urlsafe_decode64.
+#
+# Otherwise, you may choose any of the pairs in this module, including the pair
+# above, or the RFC-2045-compliant pairs:
+#
+# *   Base64.encode64 and Base64.decode64.
+# *   Base64.strict_encode64 and Base64.strict_decode64.
+#
+# ## Padding
+#
+# Base64-encoding changes a triplet of input bytes into a quartet of output
+# characters.
+#
+# **Padding in Encode Methods**
+#
+# Padding -- extending an encoded string with zero, one, or two trailing `=`
+# characters -- is performed by methods Base64.encode64, Base64.strict_encode64,
+# and, by default, Base64.urlsafe_encode64:
+#
+#     Base64.encode64('s')                         # => "cw==\n"
+#     Base64.strict_encode64('s')                  # => "cw=="
+#     Base64.urlsafe_encode64('s')                 # => "cw=="
+#     Base64.urlsafe_encode64('s', padding: false) # => "cw"
+#
+# When padding is performed, the encoded string is always of length *4n*, where
+# `n` is a non-negative integer:
+#
+# *   Input bytes of length *3n* generate unpadded output characters of length
+#     *4n*:
+#
+#         # n = 1:  3 bytes => 4 characters.
+#         Base64.strict_encode64('123')      # => "MDEy"
+#         # n = 2:  6 bytes => 8 characters.
+#         Base64.strict_encode64('123456')   # => "MDEyMzQ1"
+#
+# *   Input bytes of length *3n+1* generate padded output characters of length
+#     *4(n+1)*, with two padding characters at the end:
+#
+#         # n = 1:  4 bytes => 8 characters.
+#         Base64.strict_encode64('1234')     # => "MDEyMw=="
+#         # n = 2:  7 bytes => 12 characters.
+#         Base64.strict_encode64('1234567')  # => "MDEyMzQ1Ng=="
+#
+# *   Input bytes of length *3n+2* generate padded output characters of length
+#     *4(n+1)*, with one padding character at the end:
+#
+#         # n = 1:  5 bytes => 8 characters.
+#         Base64.strict_encode64('12345')    # => "MDEyMzQ="
+#         # n = 2:  8 bytes => 12 characters.
+#         Base64.strict_encode64('12345678') # => "MDEyMzQ1Njc="
+#
+# When padding is suppressed, for a positive integer *n*:
+#
+# *   Input bytes of length *3n* generate unpadded output characters of length
+#     *4n*:
+#
+#         # n = 1:  3 bytes => 4 characters.
+#         Base64.urlsafe_encode64('123', padding: false)      # => "MDEy"
+#         # n = 2:  6 bytes => 8 characters.
+#         Base64.urlsafe_encode64('123456', padding: false)   # => "MDEyMzQ1"
+#
+# *   Input bytes of length *3n+1* generate unpadded output characters of length
+#     *4n+2*, with two padding characters at the end:
+#
+#         # n = 1:  4 bytes => 6 characters.
+#         Base64.urlsafe_encode64('1234', padding: false)     # => "MDEyMw"
+#         # n = 2:  7 bytes => 10 characters.
+#         Base64.urlsafe_encode64('1234567', padding: false)  # => "MDEyMzQ1Ng"
+#
+# *   Input bytes of length *3n+2* generate unpadded output characters of length
+#     *4n+3*, with one padding character at the end:
+#
+#         # n = 1:  5 bytes => 7 characters.
+#         Base64.urlsafe_encode64('12345', padding: false)    # => "MDEyMzQ"
+#         # m = 2:  8 bytes => 11 characters.
+#         Base64.urlsafe_encode64('12345678', padding: false) # => "MDEyMzQ1Njc"
+#
+# **Padding in Decode Methods**
+#
+# All of the Base64 decode methods support (but do not require) padding.
+#
+# Method Base64.decode64 does not check the size of the padding:
+#
+#     Base64.decode64("MDEyMzQ1Njc") # => "01234567"
+#     Base64.decode64("MDEyMzQ1Njc=") # => "01234567"
+#     Base64.decode64("MDEyMzQ1Njc==") # => "01234567"
+#
+# Method Base64.strict_decode64 strictly enforces padding size:
+#
+#     Base64.strict_decode64("MDEyMzQ1Njc")   # Raises ArgumentError
+#     Base64.strict_decode64("MDEyMzQ1Njc=")  # => "01234567"
+#     Base64.strict_decode64("MDEyMzQ1Njc==") # Raises ArgumentError
+#
+# Method Base64.urlsafe_decode64 allows padding in `str`, which if present, must
+# be correct: see [Padding](Base64.html#module-Base64-label-Padding), above:
+#
+#     Base64.urlsafe_decode64("MDEyMzQ1Njc") # => "01234567"
+#     Base64.urlsafe_decode64("MDEyMzQ1Njc=") # => "01234567"
+#     Base64.urlsafe_decode64("MDEyMzQ1Njc==") # Raises ArgumentError.
+#
+# ## Newlines
+#
+# An encoded string returned by Base64.encode64 or Base64.urlsafe_encode64 has
+# an embedded newline character after each 60-character sequence, and, if
+# non-empty, at the end:
+#
+#     # No newline if empty.
+#     encoded = Base64.encode64("\x00" *  0)
+#     encoded.index("\n") # => nil
+#
+#     # Newline at end of short output.
+#     encoded = Base64.encode64("\x00" *  1)
+#     encoded.size        # => 4
+#     encoded.index("\n") # => 4
+#
+#     # Newline at end of longer output.
+#     encoded = Base64.encode64("\x00" * 45)
+#     encoded.size        # => 60
+#     encoded.index("\n") # => 60
+#
+#     # Newlines embedded and at end of still longer output.
+#     encoded = Base64.encode64("\x00" * 46)
+#     encoded.size                          # => 65
+#     encoded.rindex("\n")                  # => 65
+#     encoded.split("\n").map {|s| s.size } # => [60, 4]
+#
+# The string to be encoded may itself contain newlines, which are encoded as
+# Base64:
+#
+#       #   Base64.encode64("\n\n\n") # => "CgoK\n"
+#     s = "This is line 1\nThis is line 2\n"
+#     Base64.encode64(s) # => "VGhpcyBpcyBsaW5lIDEKVGhpcyBpcyBsaW5lIDIK\n"
+#
+module Base64
+  # <!--
+  #   rdoc-file=lib/base64.rb
+  #   - decode64(str)
+  # -->
+  # Returns a string containing the decoding of an RFC-2045-compliant
+  # Base64-encoded string `str`:
+  #
+  #     s = "VGhpcyBpcyBsaW5lIDEKVGhpcyBpcyBsaW5lIDIK\n"
+  #     Base64.decode64(s) # => "This is line 1\nThis is line 2\n"
+  #
+  # Non-Base64 characters in `str` are ignored; see [Encoding Character
+  # Set](Base64.html#module-Base64-label-Encoding+Character+Sets) above: these
+  # include newline characters and characters `-` and `/`:
+  #
+  #     Base64.decode64("\x00\n-_") # => ""
+  #
+  # Padding in `str` (even if incorrect) is ignored:
+  #
+  #     Base64.decode64("MDEyMzQ1Njc")   # => "01234567"
+  #     Base64.decode64("MDEyMzQ1Njc=")  # => "01234567"
+  #     Base64.decode64("MDEyMzQ1Njc==") # => "01234567"
+  #
+  def self?.decode64: (String str) -> String
+
+  # <!--
+  #   rdoc-file=lib/base64.rb
+  #   - encode64(bin)
+  # -->
+  # Returns a string containing the RFC-2045-compliant Base64-encoding of `bin`.
+  #
+  # Per RFC 2045, the returned string may contain the URL-unsafe characters `+` or
+  # `/`; see [Encoding Character
+  # Set](Base64.html#module-Base64-label-Encoding+Character+Sets) above:
+  #
+  #     Base64.encode64("\xFB\xEF\xBE") # => "++++\n"
+  #     Base64.encode64("\xFF\xFF\xFF") # => "////\n"
+  #
+  # The returned string may include padding; see
+  # [Padding](Base64.html#module-Base64-label-Padding) above.
+  #
+  #     Base64.encode64('*') # => "Kg==\n"
+  #
+  # The returned string ends with a newline character, and if sufficiently long
+  # will have one or more embedded newline characters; see
+  # [Newlines](Base64.html#module-Base64-label-Newlines) above:
+  #
+  #     Base64.encode64('*') # => "Kg==\n"
+  #     Base64.encode64('*' * 46)
+  #     # => "KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq\nKg==\n"
+  #
+  # The string to be encoded may itself contain newlines, which will be encoded as
+  # ordinary Base64:
+  #
+  #     Base64.encode64("\n\n\n") # => "CgoK\n"
+  #     s = "This is line 1\nThis is line 2\n"
+  #     Base64.encode64(s) # => "VGhpcyBpcyBsaW5lIDEKVGhpcyBpcyBsaW5lIDIK\n"
+  #
+  def self?.encode64: (String bin) -> String
+
+  # <!--
+  #   rdoc-file=lib/base64.rb
+  #   - strict_decode64(str)
+  # -->
+  # Returns a string containing the decoding of an RFC-2045-compliant
+  # Base64-encoded string `str`:
+  #
+  #     s = "VGhpcyBpcyBsaW5lIDEKVGhpcyBpcyBsaW5lIDIK"
+  #     Base64.strict_decode64(s) # => "This is line 1\nThis is line 2\n"
+  #
+  # Non-Base64 characters in `str` not allowed; see [Encoding Character
+  # Set](Base64.html#module-Base64-label-Encoding+Character+Sets) above: these
+  # include newline characters and characters `-` and `/`:
+  #
+  #     Base64.strict_decode64("\n") # Raises ArgumentError
+  #     Base64.strict_decode64('-')  # Raises ArgumentError
+  #     Base64.strict_decode64('_')  # Raises ArgumentError
+  #
+  # Padding in `str`, if present, must be correct:
+  #
+  #     Base64.strict_decode64("MDEyMzQ1Njc")   # Raises ArgumentError
+  #     Base64.strict_decode64("MDEyMzQ1Njc=")  # => "01234567"
+  #     Base64.strict_decode64("MDEyMzQ1Njc==") # Raises ArgumentError
+  #
+  def self?.strict_decode64: (String str) -> String
+
+  # <!--
+  #   rdoc-file=lib/base64.rb
+  #   - strict_encode64(bin)
+  # -->
+  # Returns a string containing the RFC-2045-compliant Base64-encoding of `bin`.
+  #
+  # Per RFC 2045, the returned string may contain the URL-unsafe characters `+` or
+  # `/`; see [Encoding Character
+  # Set](Base64.html#module-Base64-label-Encoding+Character+Sets) above:
+  #
+  #     Base64.strict_encode64("\xFB\xEF\xBE") # => "++++\n"
+  #     Base64.strict_encode64("\xFF\xFF\xFF") # => "////\n"
+  #
+  # The returned string may include padding; see
+  # [Padding](Base64.html#module-Base64-label-Padding) above.
+  #
+  #     Base64.strict_encode64('*') # => "Kg==\n"
+  #
+  # The returned string will have no newline characters, regardless of its length;
+  # see [Newlines](Base64.html#module-Base64-label-Newlines) above:
+  #
+  #     Base64.strict_encode64('*') # => "Kg=="
+  #     Base64.strict_encode64('*' * 46)
+  #     # => "KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKg=="
+  #
+  # The string to be encoded may itself contain newlines, which will be encoded as
+  # ordinary Base64:
+  #
+  #     Base64.strict_encode64("\n\n\n") # => "CgoK"
+  #     s = "This is line 1\nThis is line 2\n"
+  #     Base64.strict_encode64(s) # => "VGhpcyBpcyBsaW5lIDEKVGhpcyBpcyBsaW5lIDIK"
+  #
+  def self?.strict_encode64: (String bin) -> String
+
+  # <!--
+  #   rdoc-file=lib/base64.rb
+  #   - urlsafe_decode64(str)
+  # -->
+  # Returns the decoding of an RFC-4648-compliant Base64-encoded string `str`:
+  #
+  # `str` may not contain non-Base64 characters; see [Encoding Character
+  # Set](Base64.html#module-Base64-label-Encoding+Character+Sets) above:
+  #
+  #     Base64.urlsafe_decode64('+')  # Raises ArgumentError.
+  #     Base64.urlsafe_decode64('/')  # Raises ArgumentError.
+  #     Base64.urlsafe_decode64("\n") # Raises ArgumentError.
+  #
+  # Padding in `str`, if present, must be correct: see
+  # [Padding](Base64.html#module-Base64-label-Padding), above:
+  #
+  #     Base64.urlsafe_decode64("MDEyMzQ1Njc") # => "01234567"
+  #     Base64.urlsafe_decode64("MDEyMzQ1Njc=") # => "01234567"
+  #     Base64.urlsafe_decode64("MDEyMzQ1Njc==") # Raises ArgumentError.
+  #
+  def self?.urlsafe_decode64: (String str) -> String
+
+  # <!--
+  #   rdoc-file=lib/base64.rb
+  #   - urlsafe_encode64(bin, padding: true)
+  # -->
+  # Returns the RFC-4648-compliant Base64-encoding of `bin`.
+  #
+  # Per RFC 4648, the returned string will not contain the URL-unsafe characters
+  # `+` or `/`, but instead may contain the URL-safe characters `-` and `_`; see
+  # [Encoding Character
+  # Set](Base64.html#module-Base64-label-Encoding+Character+Sets) above:
+  #
+  #     Base64.urlsafe_encode64("\xFB\xEF\xBE") # => "----"
+  #     Base64.urlsafe_encode64("\xFF\xFF\xFF") # => "____"
+  #
+  # By default, the returned string may have padding; see
+  # [Padding](Base64.html#module-Base64-label-Padding), above:
+  #
+  #     Base64.urlsafe_encode64('*') # => "Kg=="
+  #
+  # Optionally, you can suppress padding:
+  #
+  #     Base64.urlsafe_encode64('*', padding: false) # => "Kg"
+  #
+  # The returned string will have no newline characters, regardless of its length;
+  # see [Newlines](Base64.html#module-Base64-label-Newlines) above:
+  #
+  #     Base64.urlsafe_encode64('*') # => "Kg=="
+  #     Base64.urlsafe_encode64('*' * 46)
+  #     # => "KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKg=="
+  #
+  def self?.urlsafe_encode64: (String bin, ?padding: boolish) -> String
+end