grammy 1.18.0 → 1.18.1

package/out/web.mjs

@@ -373,6 +373,9 @@ const checker = {
     }
 };
 class Context {
+    update;
+    api;
+    me;
     match;
     constructor(update, api, me){
         this.update = update;
@@ -763,9 +766,6 @@ class Context {
     replyWithGame(game_short_name, other, signal) {
         return this.api.sendGame(orThrow(this.chat, "sendGame").id, game_short_name, other, signal);
     }
-    update;
-    api;
-    me;
 }
 function orThrow(value, method) {
     if (value === undefined) {
@@ -792,6 +792,8 @@ function toArray(e) {
     ];
 }
 class BotError extends Error {
+    error;
+    ctx;
     constructor(error, ctx){
         super(generateBotErrorMessage(error));
         this.error = error;
@@ -799,8 +801,6 @@ class BotError extends Error {
         this.name = "BotError";
         if (error instanceof Error) this.stack = error.stack;
     }
-    error;
-    ctx;
 }
 function generateBotErrorMessage(error) {
     let msg;
@@ -1574,15 +1574,15 @@ browser$1.log;
 browser$1.save;
 browser$1.storage;
 browser$1.useColors;
-class DenoStdInternalError extends Error {
+class AssertionError extends Error {
+    name = "AssertionError";
     constructor(message){
         super(message);
-        this.name = "DenoStdInternalError";
     }
 }
 function assert(expr, msg = "") {
     if (!expr) {
-        throw new DenoStdInternalError(msg);
+        throw new AssertionError(msg);
     }
 }
 function copy(src, dst, off = 0) {
@@ -1670,27 +1670,27 @@ class Buffer1 {
         assert(len <= this.#buf.buffer.byteLength);
         this.#buf = new Uint8Array(this.#buf.buffer, 0, len);
     }
-    #grow(n1) {
+    #grow(n) {
         const m = this.length;
         if (m === 0 && this.#off !== 0) {
             this.reset();
         }
-        const i = this.#tryGrowByReslice(n1);
+        const i = this.#tryGrowByReslice(n);
         if (i >= 0) {
             return i;
         }
         const c = this.capacity;
-        if (n1 <= Math.floor(c / 2) - m) {
+        if (n <= Math.floor(c / 2) - m) {
             copy(this.#buf.subarray(this.#off), this.#buf);
-        } else if (c + n1 > MAX_SIZE) {
+        } else if (c + n > MAX_SIZE) {
             throw new Error("The buffer cannot be grown beyond the maximum size.");
         } else {
-            const buf = new Uint8Array(Math.min(2 * c + n1, MAX_SIZE));
+            const buf = new Uint8Array(Math.min(2 * c + n, MAX_SIZE));
             copy(this.#buf.subarray(this.#off), buf);
             this.#buf = buf;
         }
         this.#off = 0;
-        this.#reslice(Math.min(m + n1, MAX_SIZE));
+        this.#reslice(Math.min(m + n, MAX_SIZE));
         return m;
     }
     grow(n) {
@@ -1911,6 +1911,8 @@ function readableStreamFromIterable(iterable) {
 const baseFetchConfig = (_apiRoot)=>({});
 const defaultAdapter = "cloudflare";
 class GrammyError extends Error {
+    method;
+    payload;
     ok;
     error_code;
     description;
@@ -1925,19 +1927,17 @@ class GrammyError extends Error {
         this.description = err.description;
         this.parameters = err.parameters ?? {};
     }
-    method;
-    payload;
 }
 function toGrammyError(err, method, payload) {
     return new GrammyError(`Call to '${method}' failed!`, err, method, payload);
 }
 class HttpError extends Error {
+    error;
     constructor(message, error){
         super(message);
         this.error = error;
         this.name = "HttpError";
     }
-    error;
 }
 function isTelegramError(err) {
     return typeof err === "object" && err !== null && "status" in err && "statusText" in err;
@@ -2030,43 +2030,6 @@ function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
     }
     return res;
 }
-function _format(sep, pathObject) {
-    const dir = pathObject.dir || pathObject.root;
-    const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
-    if (!dir) return base;
-    if (base === sep) return dir;
-    if (dir === pathObject.root) return dir + base;
-    return dir + sep + base;
-}
-const WHITESPACE_ENCODINGS = {
-    "\u0009": "%09",
-    "\u000A": "%0A",
-    "\u000B": "%0B",
-    "\u000C": "%0C",
-    "\u000D": "%0D",
-    "\u0020": "%20"
-};
-function encodeWhitespace(string) {
-    return string.replaceAll(/[\s]/g, (c)=>{
-        return WHITESPACE_ENCODINGS[c] ?? c;
-    });
-}
-function lastPathSegment(path, isSep, start = 0) {
-    let matchedNonSeparator = false;
-    let end = path.length;
-    for(let i = path.length - 1; i >= start; --i){
-        if (isSep(path.charCodeAt(i))) {
-            if (matchedNonSeparator) {
-                start = i + 1;
-                break;
-            }
-        } else if (!matchedNonSeparator) {
-            matchedNonSeparator = true;
-            end = i + 1;
-        }
-    }
-    return path.slice(start, end);
-}
 function stripTrailingSeparators(segment, isSep) {
     if (segment.length <= 1) {
         return segment;
@@ -2081,21 +2044,34 @@ function stripTrailingSeparators(segment, isSep) {
     }
     return segment.slice(0, end);
 }
-function stripSuffix(name, suffix) {
-    if (suffix.length >= name.length) {
-        return name;
-    }
-    const lenDiff = name.length - suffix.length;
-    for(let i = suffix.length - 1; i >= 0; --i){
-        if (name.charCodeAt(lenDiff + i) !== suffix.charCodeAt(i)) {
-            return name;
+function posixResolve(...pathSegments) {
+    let resolvedPath = "";
+    let resolvedAbsolute = false;
+    for(let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--){
+        let path;
+        if (i >= 0) path = pathSegments[i];
+        else {
+            const { Deno  } = globalThis;
+            if (typeof Deno?.cwd !== "function") {
+                throw new TypeError("Resolved a relative path without a CWD.");
+            }
+            path = Deno.cwd();
+        }
+        assertPath(path);
+        if (path.length === 0) {
+            continue;
         }
+        resolvedPath = `${path}/${resolvedPath}`;
+        resolvedAbsolute = isPosixPathSeparator(path.charCodeAt(0));
     }
-    return name.slice(0, -suffix.length);
+    resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, "/", isPosixPathSeparator);
+    if (resolvedAbsolute) {
+        if (resolvedPath.length > 0) return `/${resolvedPath}`;
+        else return "/";
+    } else if (resolvedPath.length > 0) return resolvedPath;
+    else return ".";
 }
-const sep = "\\";
-const delimiter = ";";
-function resolve(...pathSegments) {
+function windowsResolve(...pathSegments) {
     let resolvedDevice = "";
     let resolvedTail = "";
     let resolvedAbsolute = false;
@@ -2188,10 +2164,23 @@ function resolve(...pathSegments) {
     resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, "\\", isPathSeparator);
     return resolvedDevice + (resolvedAbsolute ? "\\" : "") + resolvedTail || ".";
 }
-function normalize(path) {
+function assertArg(path) {
     assertPath(path);
+    if (path.length === 0) return ".";
+}
+function posixNormalize(path) {
+    assertArg(path);
+    const isAbsolute = isPosixPathSeparator(path.charCodeAt(0));
+    const trailingSeparator = isPosixPathSeparator(path.charCodeAt(path.length - 1));
+    path = normalizeString(path, !isAbsolute, "/", isPosixPathSeparator);
+    if (path.length === 0 && !isAbsolute) path = ".";
+    if (path.length > 0 && trailingSeparator) path += "/";
+    if (isAbsolute) return `/${path}`;
+    return path;
+}
+function windowsNormalize(path) {
+    assertArg(path);
     const len = path.length;
-    if (len === 0) return ".";
     let rootEnd = 0;
     let device;
     let isAbsolute = false;
@@ -2270,7 +2259,7 @@ function normalize(path) {
         return device;
     }
 }
-function isAbsolute(path) {
+function windowsIsAbsolute(path) {
     assertPath(path);
     const len = path.length;
     if (len === 0) return false;
@@ -2284,12 +2273,29 @@ function isAbsolute(path) {
     }
     return false;
 }
-function join(...paths) {
-    const pathsCount = paths.length;
-    if (pathsCount === 0) return ".";
+function posixIsAbsolute(path) {
+    assertPath(path);
+    return path.length > 0 && isPosixPathSeparator(path.charCodeAt(0));
+}
+function posixJoin(...paths) {
+    if (paths.length === 0) return ".";
+    let joined;
+    for(let i = 0, len = paths.length; i < len; ++i){
+        const path = paths[i];
+        assertPath(path);
+        if (path.length > 0) {
+            if (!joined) joined = path;
+            else joined += `/${path}`;
+        }
+    }
+    if (!joined) return ".";
+    return posixNormalize(joined);
+}
+function windowsJoin(...paths) {
+    if (paths.length === 0) return ".";
     let joined;
     let firstPart = null;
-    for(let i = 0; i < pathsCount; ++i){
+    for(let i = 0; i < paths.length; ++i){
         const path = paths[i];
         assertPath(path);
         if (path.length > 0) {
@@ -2322,14 +2328,73 @@ function join(...paths) {
         }
         if (slashCount >= 2) joined = `\\${joined.slice(slashCount)}`;
     }
-    return normalize(joined);
+    return windowsNormalize(joined);
 }
-function relative(from, to) {
+function assertArgs(from, to) {
     assertPath(from);
     assertPath(to);
     if (from === to) return "";
-    const fromOrig = resolve(from);
-    const toOrig = resolve(to);
+}
+function posixRelative(from, to) {
+    assertArgs(from, to);
+    from = posixResolve(from);
+    to = posixResolve(to);
+    if (from === to) return "";
+    let fromStart = 1;
+    const fromEnd = from.length;
+    for(; fromStart < fromEnd; ++fromStart){
+        if (!isPosixPathSeparator(from.charCodeAt(fromStart))) break;
+    }
+    const fromLen = fromEnd - fromStart;
+    let toStart = 1;
+    const toEnd = to.length;
+    for(; toStart < toEnd; ++toStart){
+        if (!isPosixPathSeparator(to.charCodeAt(toStart))) break;
+    }
+    const toLen = toEnd - toStart;
+    const length = fromLen < toLen ? fromLen : toLen;
+    let lastCommonSep = -1;
+    let i = 0;
+    for(; i <= length; ++i){
+        if (i === length) {
+            if (toLen > length) {
+                if (isPosixPathSeparator(to.charCodeAt(toStart + i))) {
+                    return to.slice(toStart + i + 1);
+                } else if (i === 0) {
+                    return to.slice(toStart + i);
+                }
+            } else if (fromLen > length) {
+                if (isPosixPathSeparator(from.charCodeAt(fromStart + i))) {
+                    lastCommonSep = i;
+                } else if (i === 0) {
+                    lastCommonSep = 0;
+                }
+            }
+            break;
+        }
+        const fromCode = from.charCodeAt(fromStart + i);
+        const toCode = to.charCodeAt(toStart + i);
+        if (fromCode !== toCode) break;
+        else if (isPosixPathSeparator(fromCode)) lastCommonSep = i;
+    }
+    let out = "";
+    for(i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i){
+        if (i === fromEnd || isPosixPathSeparator(from.charCodeAt(i))) {
+            if (out.length === 0) out += "..";
+            else out += "/..";
+        }
+    }
+    if (out.length > 0) return out + to.slice(toStart + lastCommonSep);
+    else {
+        toStart += lastCommonSep;
+        if (isPosixPathSeparator(to.charCodeAt(toStart))) ++toStart;
+        return to.slice(toStart);
+    }
+}
+function windowsRelative(from, to) {
+    assertArgs(from, to);
+    const fromOrig = windowsResolve(from);
+    const toOrig = windowsResolve(to);
     if (fromOrig === toOrig) return "";
     from = fromOrig.toLowerCase();
     to = toOrig.toLowerCase();
@@ -2397,10 +2462,13 @@ function relative(from, to) {
         return toOrig.slice(toStart, toEnd);
     }
 }
-function toNamespacedPath(path) {
+function posixToNamespacedPath(path) {
+    return path;
+}
+function windowsToNamespacedPath(path) {
     if (typeof path !== "string") return path;
     if (path.length === 0) return "";
-    const resolvedPath = resolve(path);
+    const resolvedPath = windowsResolve(path);
     if (resolvedPath.length >= 3) {
         if (resolvedPath.charCodeAt(0) === 92) {
             if (resolvedPath.charCodeAt(1) === 92) {
@@ -2417,10 +2485,32 @@ function toNamespacedPath(path) {
     }
     return path;
 }
-function dirname(path) {
+function assertArg1(path) {
     assertPath(path);
+    if (path.length === 0) return ".";
+}
+function posixDirname(path) {
+    assertArg1(path);
+    let end = -1;
+    let matchedNonSeparator = false;
+    for(let i = path.length - 1; i >= 1; --i){
+        if (isPosixPathSeparator(path.charCodeAt(i))) {
+            if (matchedNonSeparator) {
+                end = i;
+                break;
+            }
+        } else {
+            matchedNonSeparator = true;
+        }
+    }
+    if (end === -1) {
+        return isPosixPathSeparator(path.charCodeAt(0)) ? "/" : ".";
+    }
+    return stripTrailingSeparators(path.slice(0, end), isPosixPathSeparator);
+}
+function windowsDirname(path) {
+    assertArg1(path);
     const len = path.length;
-    if (len === 0) return ".";
     let rootEnd = -1;
     let end = -1;
     let matchedSlash = true;
@@ -2479,364 +2569,63 @@ function dirname(path) {
         if (rootEnd === -1) return ".";
         else end = rootEnd;
     }
-    return stripTrailingSeparators(path.slice(0, end), isPosixPathSeparator);
-}
-function basename(path, suffix = "") {
-    assertPath(path);
-    if (path.length === 0) return path;
-    if (typeof suffix !== "string") {
-        throw new TypeError(`Suffix must be a string. Received ${JSON.stringify(suffix)}`);
-    }
-    let start = 0;
-    if (path.length >= 2) {
-        const drive = path.charCodeAt(0);
-        if (isWindowsDeviceRoot(drive)) {
-            if (path.charCodeAt(1) === 58) start = 2;
-        }
-    }
-    const lastSegment = lastPathSegment(path, isPathSeparator, start);
-    const strippedSegment = stripTrailingSeparators(lastSegment, isPathSeparator);
-    return suffix ? stripSuffix(strippedSegment, suffix) : strippedSegment;
-}
-function extname(path) {
-    assertPath(path);
-    let start = 0;
-    let startDot = -1;
-    let startPart = 0;
-    let end = -1;
-    let matchedSlash = true;
-    let preDotState = 0;
-    if (path.length >= 2 && path.charCodeAt(1) === 58 && isWindowsDeviceRoot(path.charCodeAt(0))) {
-        start = startPart = 2;
-    }
-    for(let i = path.length - 1; i >= start; --i){
-        const code = path.charCodeAt(i);
-        if (isPathSeparator(code)) {
-            if (!matchedSlash) {
-                startPart = i + 1;
-                break;
-            }
-            continue;
-        }
-        if (end === -1) {
-            matchedSlash = false;
-            end = i + 1;
-        }
-        if (code === 46) {
-            if (startDot === -1) startDot = i;
-            else if (preDotState !== 1) preDotState = 1;
-        } else if (startDot !== -1) {
-            preDotState = -1;
-        }
-    }
-    if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
-        return "";
-    }
-    return path.slice(startDot, end);
-}
-function format(pathObject) {
-    if (pathObject === null || typeof pathObject !== "object") {
-        throw new TypeError(`The "pathObject" argument must be of type Object. Received type ${typeof pathObject}`);
-    }
-    return _format("\\", pathObject);
-}
-function parse2(path) {
-    assertPath(path);
-    const ret = {
-        root: "",
-        dir: "",
-        base: "",
-        ext: "",
-        name: ""
-    };
-    const len = path.length;
-    if (len === 0) return ret;
-    let rootEnd = 0;
-    let code = path.charCodeAt(0);
-    if (len > 1) {
-        if (isPathSeparator(code)) {
-            rootEnd = 1;
-            if (isPathSeparator(path.charCodeAt(1))) {
-                let j = 2;
-                let last = j;
-                for(; j < len; ++j){
-                    if (isPathSeparator(path.charCodeAt(j))) break;
-                }
-                if (j < len && j !== last) {
-                    last = j;
-                    for(; j < len; ++j){
-                        if (!isPathSeparator(path.charCodeAt(j))) break;
-                    }
-                    if (j < len && j !== last) {
-                        last = j;
-                        for(; j < len; ++j){
-                            if (isPathSeparator(path.charCodeAt(j))) break;
-                        }
-                        if (j === len) {
-                            rootEnd = j;
-                        } else if (j !== last) {
-                            rootEnd = j + 1;
-                        }
-                    }
-                }
-            }
-        } else if (isWindowsDeviceRoot(code)) {
-            if (path.charCodeAt(1) === 58) {
-                rootEnd = 2;
-                if (len > 2) {
-                    if (isPathSeparator(path.charCodeAt(2))) {
-                        if (len === 3) {
-                            ret.root = ret.dir = path;
-                            ret.base = "\\";
-                            return ret;
-                        }
-                        rootEnd = 3;
-                    }
-                } else {
-                    ret.root = ret.dir = path;
-                    return ret;
-                }
-            }
-        }
-    } else if (isPathSeparator(code)) {
-        ret.root = ret.dir = path;
-        ret.base = "\\";
-        return ret;
-    }
-    if (rootEnd > 0) ret.root = path.slice(0, rootEnd);
-    let startDot = -1;
-    let startPart = rootEnd;
-    let end = -1;
-    let matchedSlash = true;
-    let i = path.length - 1;
-    let preDotState = 0;
-    for(; i >= rootEnd; --i){
-        code = path.charCodeAt(i);
-        if (isPathSeparator(code)) {
-            if (!matchedSlash) {
-                startPart = i + 1;
-                break;
-            }
-            continue;
-        }
-        if (end === -1) {
-            matchedSlash = false;
-            end = i + 1;
-        }
-        if (code === 46) {
-            if (startDot === -1) startDot = i;
-            else if (preDotState !== 1) preDotState = 1;
-        } else if (startDot !== -1) {
-            preDotState = -1;
-        }
-    }
-    if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
-        if (end !== -1) {
-            ret.base = ret.name = path.slice(startPart, end);
-        }
-    } else {
-        ret.name = path.slice(startPart, startDot);
-        ret.base = path.slice(startPart, end);
-        ret.ext = path.slice(startDot, end);
-    }
-    ret.base = ret.base || "\\";
-    if (startPart > 0 && startPart !== rootEnd) {
-        ret.dir = path.slice(0, startPart - 1);
-    } else ret.dir = ret.root;
-    return ret;
-}
-function fromFileUrl(url) {
-    url = url instanceof URL ? url : new URL(url);
-    if (url.protocol != "file:") {
-        throw new TypeError("Must be a file URL.");
-    }
-    let path = decodeURIComponent(url.pathname.replace(/\//g, "\\").replace(/%(?![0-9A-Fa-f]{2})/g, "%25")).replace(/^\\*([A-Za-z]:)(\\|$)/, "$1\\");
-    if (url.hostname != "") {
-        path = `\\\\${url.hostname}${path}`;
-    }
-    return path;
-}
-function toFileUrl(path) {
-    if (!isAbsolute(path)) {
-        throw new TypeError("Must be an absolute path.");
-    }
-    const [, hostname, pathname] = path.match(/^(?:[/\\]{2}([^/\\]+)(?=[/\\](?:[^/\\]|$)))?(.*)/);
-    const url = new URL("file:///");
-    url.pathname = encodeWhitespace(pathname.replace(/%/g, "%25"));
-    if (hostname != null && hostname != "localhost") {
-        url.hostname = hostname;
-        if (!url.hostname) {
-            throw new TypeError("Invalid hostname.");
-        }
-    }
-    return url;
-}
-const mod = {
-    sep: sep,
-    delimiter: delimiter,
-    resolve: resolve,
-    normalize: normalize,
-    isAbsolute: isAbsolute,
-    join: join,
-    relative: relative,
-    toNamespacedPath: toNamespacedPath,
-    dirname: dirname,
-    basename: basename,
-    extname: extname,
-    format: format,
-    parse: parse2,
-    fromFileUrl: fromFileUrl,
-    toFileUrl: toFileUrl
-};
-const sep1 = "/";
-const delimiter1 = ":";
-function resolve1(...pathSegments) {
-    let resolvedPath = "";
-    let resolvedAbsolute = false;
-    for(let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--){
-        let path;
-        if (i >= 0) path = pathSegments[i];
-        else {
-            const { Deno  } = globalThis;
-            if (typeof Deno?.cwd !== "function") {
-                throw new TypeError("Resolved a relative path without a CWD.");
-            }
-            path = Deno.cwd();
-        }
-        assertPath(path);
-        if (path.length === 0) {
-            continue;
-        }
-        resolvedPath = `${path}/${resolvedPath}`;
-        resolvedAbsolute = isPosixPathSeparator(path.charCodeAt(0));
-    }
-    resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, "/", isPosixPathSeparator);
-    if (resolvedAbsolute) {
-        if (resolvedPath.length > 0) return `/${resolvedPath}`;
-        else return "/";
-    } else if (resolvedPath.length > 0) return resolvedPath;
-    else return ".";
-}
-function normalize1(path) {
-    assertPath(path);
-    if (path.length === 0) return ".";
-    const isAbsolute = isPosixPathSeparator(path.charCodeAt(0));
-    const trailingSeparator = isPosixPathSeparator(path.charCodeAt(path.length - 1));
-    path = normalizeString(path, !isAbsolute, "/", isPosixPathSeparator);
-    if (path.length === 0 && !isAbsolute) path = ".";
-    if (path.length > 0 && trailingSeparator) path += "/";
-    if (isAbsolute) return `/${path}`;
-    return path;
-}
-function isAbsolute1(path) {
-    assertPath(path);
-    return path.length > 0 && isPosixPathSeparator(path.charCodeAt(0));
-}
-function join1(...paths) {
-    if (paths.length === 0) return ".";
-    let joined;
-    for(let i = 0, len = paths.length; i < len; ++i){
-        const path = paths[i];
-        assertPath(path);
-        if (path.length > 0) {
-            if (!joined) joined = path;
-            else joined += `/${path}`;
-        }
-    }
-    if (!joined) return ".";
-    return normalize1(joined);
-}
-function relative1(from, to) {
-    assertPath(from);
-    assertPath(to);
-    if (from === to) return "";
-    from = resolve1(from);
-    to = resolve1(to);
-    if (from === to) return "";
-    let fromStart = 1;
-    const fromEnd = from.length;
-    for(; fromStart < fromEnd; ++fromStart){
-        if (!isPosixPathSeparator(from.charCodeAt(fromStart))) break;
-    }
-    const fromLen = fromEnd - fromStart;
-    let toStart = 1;
-    const toEnd = to.length;
-    for(; toStart < toEnd; ++toStart){
-        if (!isPosixPathSeparator(to.charCodeAt(toStart))) break;
-    }
-    const toLen = toEnd - toStart;
-    const length = fromLen < toLen ? fromLen : toLen;
-    let lastCommonSep = -1;
-    let i = 0;
-    for(; i <= length; ++i){
-        if (i === length) {
-            if (toLen > length) {
-                if (isPosixPathSeparator(to.charCodeAt(toStart + i))) {
-                    return to.slice(toStart + i + 1);
-                } else if (i === 0) {
-                    return to.slice(toStart + i);
-                }
-            } else if (fromLen > length) {
-                if (isPosixPathSeparator(from.charCodeAt(fromStart + i))) {
-                    lastCommonSep = i;
-                } else if (i === 0) {
-                    lastCommonSep = 0;
-                }
-            }
-            break;
-        }
-        const fromCode = from.charCodeAt(fromStart + i);
-        const toCode = to.charCodeAt(toStart + i);
-        if (fromCode !== toCode) break;
-        else if (isPosixPathSeparator(fromCode)) lastCommonSep = i;
-    }
-    let out = "";
-    for(i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i){
-        if (i === fromEnd || isPosixPathSeparator(from.charCodeAt(i))) {
-            if (out.length === 0) out += "..";
-            else out += "/..";
-        }
-    }
-    if (out.length > 0) return out + to.slice(toStart + lastCommonSep);
-    else {
-        toStart += lastCommonSep;
-        if (isPosixPathSeparator(to.charCodeAt(toStart))) ++toStart;
-        return to.slice(toStart);
-    }
+    return stripTrailingSeparators(path.slice(0, end), isPosixPathSeparator);
 }
-function toNamespacedPath1(path) {
-    return path;
+function stripSuffix(name, suffix) {
+    if (suffix.length >= name.length) {
+        return name;
+    }
+    const lenDiff = name.length - suffix.length;
+    for(let i = suffix.length - 1; i >= 0; --i){
+        if (name.charCodeAt(lenDiff + i) !== suffix.charCodeAt(i)) {
+            return name;
+        }
+    }
+    return name.slice(0, -suffix.length);
 }
-function dirname1(path) {
-    if (path.length === 0) return ".";
-    let end = -1;
+function lastPathSegment(path, isSep, start = 0) {
     let matchedNonSeparator = false;
-    for(let i = path.length - 1; i >= 1; --i){
-        if (isPosixPathSeparator(path.charCodeAt(i))) {
+    let end = path.length;
+    for(let i = path.length - 1; i >= start; --i){
+        if (isSep(path.charCodeAt(i))) {
             if (matchedNonSeparator) {
-                end = i;
+                start = i + 1;
                 break;
             }
-        } else {
+        } else if (!matchedNonSeparator) {
             matchedNonSeparator = true;
+            end = i + 1;
         }
     }
-    if (end === -1) {
-        return isPosixPathSeparator(path.charCodeAt(0)) ? "/" : ".";
-    }
-    return stripTrailingSeparators(path.slice(0, end), isPosixPathSeparator);
+    return path.slice(start, end);
 }
-function basename1(path, suffix = "") {
+function assertArgs1(path, suffix) {
     assertPath(path);
     if (path.length === 0) return path;
     if (typeof suffix !== "string") {
         throw new TypeError(`Suffix must be a string. Received ${JSON.stringify(suffix)}`);
     }
+}
+function posixBasename(path, suffix = "") {
+    assertArgs1(path, suffix);
     const lastSegment = lastPathSegment(path, isPosixPathSeparator);
     const strippedSegment = stripTrailingSeparators(lastSegment, isPosixPathSeparator);
     return suffix ? stripSuffix(strippedSegment, suffix) : strippedSegment;
 }
-function extname1(path) {
+function windowsBasename(path, suffix = "") {
+    assertArgs1(path, suffix);
+    let start = 0;
+    if (path.length >= 2) {
+        const drive = path.charCodeAt(0);
+        if (isWindowsDeviceRoot(drive)) {
+            if (path.charCodeAt(1) === 58) start = 2;
+        }
+    }
+    const lastSegment = lastPathSegment(path, isPathSeparator, start);
+    const strippedSegment = stripTrailingSeparators(lastSegment, isPathSeparator);
+    return suffix ? stripSuffix(strippedSegment, suffix) : strippedSegment;
+}
+function posixExtname(path) {
     assertPath(path);
     let startDot = -1;
     let startPart = 0;
@@ -2868,13 +2657,64 @@ function extname1(path) {
     }
     return path.slice(startDot, end);
 }
-function format1(pathObject) {
+function windowsExtname(path) {
+    assertPath(path);
+    let start = 0;
+    let startDot = -1;
+    let startPart = 0;
+    let end = -1;
+    let matchedSlash = true;
+    let preDotState = 0;
+    if (path.length >= 2 && path.charCodeAt(1) === 58 && isWindowsDeviceRoot(path.charCodeAt(0))) {
+        start = startPart = 2;
+    }
+    for(let i = path.length - 1; i >= start; --i){
+        const code = path.charCodeAt(i);
+        if (isPathSeparator(code)) {
+            if (!matchedSlash) {
+                startPart = i + 1;
+                break;
+            }
+            continue;
+        }
+        if (end === -1) {
+            matchedSlash = false;
+            end = i + 1;
+        }
+        if (code === 46) {
+            if (startDot === -1) startDot = i;
+            else if (preDotState !== 1) preDotState = 1;
+        } else if (startDot !== -1) {
+            preDotState = -1;
+        }
+    }
+    if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+        return "";
+    }
+    return path.slice(startDot, end);
+}
+function _format(sep, pathObject) {
+    const dir = pathObject.dir || pathObject.root;
+    const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+    if (!dir) return base;
+    if (base === sep) return dir;
+    if (dir === pathObject.root) return dir + base;
+    return dir + sep + base;
+}
+function assertArg2(pathObject) {
     if (pathObject === null || typeof pathObject !== "object") {
         throw new TypeError(`The "pathObject" argument must be of type Object. Received type ${typeof pathObject}`);
     }
+}
+function posixFormat(pathObject) {
+    assertArg2(pathObject);
     return _format("/", pathObject);
 }
-function parse3(path) {
+function windowsFormat(pathObject) {
+    assertArg2(pathObject);
+    return _format("\\", pathObject);
+}
+function posixParse(path) {
     assertPath(path);
     const ret = {
         root: "",
@@ -2942,42 +2782,210 @@ function parse3(path) {
     } else if (isAbsolute) ret.dir = "/";
     return ret;
 }
-function fromFileUrl1(url) {
+function windowsParse(path) {
+    assertPath(path);
+    const ret = {
+        root: "",
+        dir: "",
+        base: "",
+        ext: "",
+        name: ""
+    };
+    const len = path.length;
+    if (len === 0) return ret;
+    let rootEnd = 0;
+    let code = path.charCodeAt(0);
+    if (len > 1) {
+        if (isPathSeparator(code)) {
+            rootEnd = 1;
+            if (isPathSeparator(path.charCodeAt(1))) {
+                let j = 2;
+                let last = j;
+                for(; j < len; ++j){
+                    if (isPathSeparator(path.charCodeAt(j))) break;
+                }
+                if (j < len && j !== last) {
+                    last = j;
+                    for(; j < len; ++j){
+                        if (!isPathSeparator(path.charCodeAt(j))) break;
+                    }
+                    if (j < len && j !== last) {
+                        last = j;
+                        for(; j < len; ++j){
+                            if (isPathSeparator(path.charCodeAt(j))) break;
+                        }
+                        if (j === len) {
+                            rootEnd = j;
+                        } else if (j !== last) {
+                            rootEnd = j + 1;
+                        }
+                    }
+                }
+            }
+        } else if (isWindowsDeviceRoot(code)) {
+            if (path.charCodeAt(1) === 58) {
+                rootEnd = 2;
+                if (len > 2) {
+                    if (isPathSeparator(path.charCodeAt(2))) {
+                        if (len === 3) {
+                            ret.root = ret.dir = path;
+                            ret.base = "\\";
+                            return ret;
+                        }
+                        rootEnd = 3;
+                    }
+                } else {
+                    ret.root = ret.dir = path;
+                    return ret;
+                }
+            }
+        }
+    } else if (isPathSeparator(code)) {
+        ret.root = ret.dir = path;
+        ret.base = "\\";
+        return ret;
+    }
+    if (rootEnd > 0) ret.root = path.slice(0, rootEnd);
+    let startDot = -1;
+    let startPart = rootEnd;
+    let end = -1;
+    let matchedSlash = true;
+    let i = path.length - 1;
+    let preDotState = 0;
+    for(; i >= rootEnd; --i){
+        code = path.charCodeAt(i);
+        if (isPathSeparator(code)) {
+            if (!matchedSlash) {
+                startPart = i + 1;
+                break;
+            }
+            continue;
+        }
+        if (end === -1) {
+            matchedSlash = false;
+            end = i + 1;
+        }
+        if (code === 46) {
+            if (startDot === -1) startDot = i;
+            else if (preDotState !== 1) preDotState = 1;
+        } else if (startDot !== -1) {
+            preDotState = -1;
+        }
+    }
+    if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+        if (end !== -1) {
+            ret.base = ret.name = path.slice(startPart, end);
+        }
+    } else {
+        ret.name = path.slice(startPart, startDot);
+        ret.base = path.slice(startPart, end);
+        ret.ext = path.slice(startDot, end);
+    }
+    ret.base = ret.base || "\\";
+    if (startPart > 0 && startPart !== rootEnd) {
+        ret.dir = path.slice(0, startPart - 1);
+    } else ret.dir = ret.root;
+    return ret;
+}
+function assertArg3(url) {
     url = url instanceof URL ? url : new URL(url);
     if (url.protocol != "file:") {
         throw new TypeError("Must be a file URL.");
     }
+    return url;
+}
+function posixFromFileUrl(url) {
+    url = assertArg3(url);
     return decodeURIComponent(url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25"));
 }
-function toFileUrl1(path) {
-    if (!isAbsolute1(path)) {
+function windowsFromFileUrl(url) {
+    url = assertArg3(url);
+    let path = decodeURIComponent(url.pathname.replace(/\//g, "\\").replace(/%(?![0-9A-Fa-f]{2})/g, "%25")).replace(/^\\*([A-Za-z]:)(\\|$)/, "$1\\");
+    if (url.hostname != "") {
+        path = `\\\\${url.hostname}${path}`;
+    }
+    return path;
+}
+const WHITESPACE_ENCODINGS = {
+    "\u0009": "%09",
+    "\u000A": "%0A",
+    "\u000B": "%0B",
+    "\u000C": "%0C",
+    "\u000D": "%0D",
+    "\u0020": "%20"
+};
+function encodeWhitespace(string) {
+    return string.replaceAll(/[\s]/g, (c)=>{
+        return WHITESPACE_ENCODINGS[c] ?? c;
+    });
+}
+function posixToFileUrl(path) {
+    if (!posixIsAbsolute(path)) {
         throw new TypeError("Must be an absolute path.");
     }
     const url = new URL("file:///");
     url.pathname = encodeWhitespace(path.replace(/%/g, "%25").replace(/\\/g, "%5C"));
     return url;
 }
+function windowsToFileUrl(path) {
+    if (!windowsIsAbsolute(path)) {
+        throw new TypeError("Must be an absolute path.");
+    }
+    const [, hostname, pathname] = path.match(/^(?:[/\\]{2}([^/\\]+)(?=[/\\](?:[^/\\]|$)))?(.*)/);
+    const url = new URL("file:///");
+    url.pathname = encodeWhitespace(pathname.replace(/%/g, "%25"));
+    if (hostname != null && hostname != "localhost") {
+        url.hostname = hostname;
+        if (!url.hostname) {
+            throw new TypeError("Invalid hostname.");
+        }
+    }
+    return url;
+}
+const sep = "\\";
+const delimiter = ";";
+const mod = {
+    resolve: windowsResolve,
+    normalize: windowsNormalize,
+    isAbsolute: windowsIsAbsolute,
+    join: windowsJoin,
+    relative: windowsRelative,
+    toNamespacedPath: windowsToNamespacedPath,
+    dirname: windowsDirname,
+    basename: windowsBasename,
+    extname: windowsExtname,
+    format: windowsFormat,
+    parse: windowsParse,
+    fromFileUrl: windowsFromFileUrl,
+    toFileUrl: windowsToFileUrl,
+    sep: sep,
+    delimiter: delimiter
+};
+const sep1 = "/";
+const delimiter1 = ":";
 const mod1 = {
+    resolve: posixResolve,
+    normalize: posixNormalize,
+    isAbsolute: posixIsAbsolute,
+    join: posixJoin,
+    relative: posixRelative,
+    toNamespacedPath: posixToNamespacedPath,
+    dirname: posixDirname,
+    basename: posixBasename,
+    extname: posixExtname,
+    format: posixFormat,
+    parse: posixParse,
+    fromFileUrl: posixFromFileUrl,
+    toFileUrl: posixToFileUrl,
     sep: sep1,
-    delimiter: delimiter1,
-    resolve: resolve1,
-    normalize: normalize1,
-    isAbsolute: isAbsolute1,
-    join: join1,
-    relative: relative1,
-    toNamespacedPath: toNamespacedPath1,
-    dirname: dirname1,
-    basename: basename1,
-    extname: extname1,
-    format: format1,
-    parse: parse3,
-    fromFileUrl: fromFileUrl1,
-    toFileUrl: toFileUrl1
+    delimiter: delimiter1
 };
+function basename(path, suffix = "") {
+    return isWindows ? windowsBasename(path, suffix) : posixBasename(path, suffix);
+}
 const path = isWindows ? mod : mod1;
-const { join: join2 , normalize: normalize2  } = path;
-const path1 = isWindows ? mod : mod1;
-const { basename: basename2 , delimiter: delimiter2 , dirname: dirname2 , extname: extname2 , format: format2 , fromFileUrl: fromFileUrl2 , isAbsolute: isAbsolute2 , join: join3 , normalize: normalize3 , parse: parse4 , relative: relative2 , resolve: resolve2 , toFileUrl: toFileUrl2 , toNamespacedPath: toNamespacedPath2  } = path1;
+const { join , normalize  } = path;
+isWindows ? mod.delimiter : mod1.delimiter;
 class InputFile {
     consumed = false;
     fileData;
@@ -2988,11 +2996,11 @@ class InputFile {
         this.filename = filename;
     }
     guessFilename(file) {
-        if (typeof file === "string") return basename2(file);
+        if (typeof file === "string") return basename(file);
         if (typeof file !== "object") return undefined;
-        if ("url" in file) return basename2(file.url);
+        if ("url" in file) return basename(file.url);
         if (!(file instanceof URL)) return undefined;
-        return basename2(file.pathname) || basename2(file.hostname);
+        return basename(file.pathname) || basename(file.hostname);
     }
     toRaw() {
         if (this.consumed) {
@@ -3136,6 +3144,8 @@ function concatTransformer(prev, trans) {
     return (method, payload, signal)=>trans(prev, method, payload, signal);
 }
 class ApiClient {
+    token;
+    webhookReplyEnvelope;
     options;
     hasUsedWebhookReply;
     installedTransformers;
@@ -3212,8 +3222,6 @@ class ApiClient {
         if (data.ok) return data.result;
         else throw toGrammyError(data, method, payload);
     }
-    token;
-    webhookReplyEnvelope;
 }
 function createRawApi(token, options, webhookReplyEnvelope) {
     const client = new ApiClient(token, options, webhookReplyEnvelope);
@@ -4097,6 +4105,7 @@ const DEFAULT_UPDATE_TYPES = [
     "chat_join_request"
 ];
 class Bot extends Composer {
+    token;
     pollingRunning;
     pollingAbortController;
     lastTriedUpdateId;
@@ -4288,7 +4297,6 @@ a known bot info object.");
         debugErr(`Call to getUpdates failed, retrying in ${sleepSeconds} seconds ...`);
         await sleep(sleepSeconds);
     }
-    token;
 }
 async function withRetries(task, signal) {
     const INITIAL_DELAY = 50;
@@ -4725,6 +4733,7 @@ const InputMediaBuilder = {
 };
 export { InputMediaBuilder as InputMediaBuilder };
 class Keyboard {
+    keyboard;
     is_persistent;
     selective;
     one_time_keyboard;
@@ -4875,9 +4884,9 @@ class Keyboard {
         }
         return new Keyboard(source.map((row)=>row.map(toButton)));
     }
-    keyboard;
 }
 class InlineKeyboard {
+    inline_keyboard;
     constructor(inline_keyboard = [
         []
     ]){
@@ -5000,7 +5009,6 @@ class InlineKeyboard {
         if (source instanceof InlineKeyboard) return source.clone();
         return new InlineKeyboard(source.map((row)=>row.slice()));
     }
-    inline_keyboard;
 }
 function transpose(grid) {
     const transposed = [];
@@ -5093,6 +5101,10 @@ function lazySession(options = {}) {
     };
 }
 class PropertySession {
+    storage;
+    obj;
+    prop;
+    initial;
     key;
     value;
     promise;
@@ -5177,10 +5189,6 @@ class PropertySession {
             }
         }
     }
-    storage;
-    obj;
-    prop;
-    initial;
 }
 function fillDefaults(opts = {}) {
     let { getSessionKey =defaultGetSessionKey , initial , storage  } = opts;
@@ -5297,6 +5305,7 @@ function wrapStorage(storage) {
     };
 }
 class MemorySessionStorage {
+    timeToLive;
     storage;
     constructor(timeToLive){
         this.timeToLive = timeToLive;
@@ -5335,7 +5344,6 @@ class MemorySessionStorage {
     delete(key) {
         this.storage.delete(key);
     }
-    timeToLive;
 }
 function addExpiryDate(value, ttl) {
     if (ttl !== undefined && ttl < Infinity) {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "grammy",
     "description": "The Telegram Bot Framework.",
-    "version": "1.18.0",
+    "version": "1.18.1",
     "author": "KnorpelSenf",
     "license": "MIT",
     "engines": {