@deffa5556/bail 1.0.6

package/lib/Telegram/core/helpers/args.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.argsParser = argsParser;
+const SINGLE_QUOTE = "'";
+const DOUBLE_QUOTE = '"';
+function argsParser(str, entities = [], entityOffset = 0) {
+    const mentions = {};
+    for (const entity of entities) // extract all text_mentions into an { offset: length } map
+        if (entity.type === 'text_mention' || entity.type === 'text_link')
+            mentions[entity.offset - entityOffset] = entity.length;
+    const args = [];
+    let done = 0;
+    let inside = undefined;
+    let buf = '';
+    function flush(to) {
+        if (done !== to)
+            args.push(buf + str.slice(done, to)), (inside = undefined);
+        buf = '';
+        done = to + 1;
+    }
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        // quick lookup length of mention starting at i
+        const mention = mentions[i];
+        if (mention) {
+            // if we're inside a quote, eagerly flush existing state
+            flush(i);
+            // this also consumes current index, so decrement
+            done--;
+            // fast forward to end of mention
+            i += mention;
+            flush(i);
+        }
+        else if (char === SINGLE_QUOTE || char === DOUBLE_QUOTE)
+            if (inside)
+                if (inside === char)
+                    flush(i);
+                else
+                    continue;
+            else
+                flush(i), (inside = char);
+        else if (char === ' ')
+            if (inside)
+                continue;
+            else
+                flush(i);
+        else if (char === '\n')
+            flush(i);
+        else if (char === '\\')
+            (buf += str.slice(done, i)), (done = ++i); // skip parsing the next char
+        else
+            continue;
+    }
+    if (done < str.length)
+        flush(str.length);
+    return args;
+}

package/lib/Telegram/core/helpers/check.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasProp = hasProp;
+exports.hasPropType = hasPropType;
+exports.is2D = is2D;
+/**
+ * Checks if a given object has a property with a given name.
+ *
+ * Example invocation:
+ * ```js
+ * let obj = { 'foo': 'bar', 'baz': () => {} }
+ * hasProp(obj, 'foo') // true
+ * hasProp(obj, 'baz') // true
+ * hasProp(obj, 'abc') // false
+ * ```
+ *
+ * @param obj An object to test
+ * @param prop The name of the property
+ */
+function hasProp(obj, prop) {
+    return obj !== undefined && prop in obj;
+}
+/**
+ * Checks if a given object has a property with a given name.
+ * Furthermore performs a `typeof` check on the property if it exists.
+ *
+ * Example invocation:
+ * ```js
+ * let obj = { 'foo': 'bar', 'baz': () => {} }
+ * hasPropType(obj, 'foo', 'string') // true
+ * hasPropType(obj, 'baz', 'function') // true
+ * hasPropType(obj, 'abc', 'number') // false
+ * ```
+ *
+ * @param obj An object to test
+ * @param prop The name of the property
+ * @param type The type the property is expected to have
+ */
+function hasPropType(obj, prop, type) {
+    return hasProp(obj, prop) && type === typeof obj[prop];
+}
+/**
+ * Checks if the supplied array has two dimensions or not.
+ *
+ * Example invocations:
+ * is2D([]) // false
+ * is2D([[]]) // true
+ * is2D([[], []]) // true
+ * is2D([42]) // false
+ *
+ * @param arr an array with one or two dimensions
+ */
+function is2D(arr) {
+    return Array.isArray(arr[0]);
+}

package/lib/Telegram/core/helpers/compact.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compactOptions = compactOptions;
+function compactOptions(options) {
+    if (!options) {
+        return options;
+    }
+    const compacted = {};
+    for (const key in options)
+        if (
+        // todo(mkr): replace with Object.hasOwn in v5 (Node 16+)
+        Object.prototype.hasOwnProperty.call(options, key) &&
+            options[key] !== undefined)
+            compacted[key] = options[key];
+    return compacted;
+}

package/lib/Telegram/core/helpers/deunionize.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deunionize = deunionize;
+/**
+ * Expose properties from all union variants.
+ * @deprectated
+ * @see https://github.com/telegraf/telegraf/issues/1388#issuecomment-791573609
+ * @see https://millsp.github.io/ts-toolbelt/modules/union_strict.html
+ */
+function deunionize(t) {
+    return t;
+}

package/lib/Telegram/core/helpers/formatting.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkOrMention = exports.join = exports.FmtString = void 0;
+exports.createFmt = createFmt;
+const util_1 = require("./util");
+class FmtString {
+    constructor(text, entities) {
+        this.text = text;
+        if (entities) {
+            this.entities = entities;
+            // force parse_mode to undefined if entities are present
+            this.parse_mode = undefined;
+        }
+    }
+    static normalise(content) {
+        if (content instanceof FmtString)
+            return content;
+        return new FmtString(String(content));
+    }
+}
+exports.FmtString = FmtString;
+const isArray = Array.isArray;
+/** Given a base FmtString and something to append to it, mutates the base */
+const _add = (base, next) => {
+    var _a;
+    const len = base.text.length;
+    if (next instanceof FmtString) {
+        base.text = `${base.text}${next.text}`;
+        // next.entities could be undefined and condition will fail
+        for (let i = 0; i < (((_a = next.entities) === null || _a === void 0 ? void 0 : _a.length) || 0); i++) {
+            // because of the above condition, next.entities[i] cannot be undefined
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const entity = next.entities[i];
+            // base.entities is ensured by caller
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            base.entities.push({ ...entity, offset: entity.offset + len });
+        }
+    }
+    else
+        base.text = `${base.text}${next}`;
+};
+/**
+ * Given an `Iterable<FmtString | string | Any>` and a separator, flattens the list into a single FmtString.
+ * Analogous to Array#join -> string, but for FmtString
+ */
+const join = (fragments, separator) => {
+    const result = new FmtString('');
+    // ensure entities array so loop doesn't need to check
+    result.entities = [];
+    const iter = fragments[Symbol.iterator]();
+    let curr = iter.next();
+    while (!curr.done) {
+        _add(result, curr.value);
+        curr = iter.next();
+        if (separator && !curr.done)
+            _add(result, separator);
+    }
+    // set parse_mode: undefined if entities are present
+    if (result.entities.length)
+        result.parse_mode = undefined;
+    // remove entities array if not relevant
+    else
+        delete result.entities;
+    return result;
+};
+exports.join = join;
+/** Internal constructor for all fmt helpers */
+function createFmt(kind, opts) {
+    return function fmt(parts, ...items) {
+        var _a;
+        parts = isArray(parts) ? parts : [parts];
+        const result = (0, exports.join)((0, util_1.zip)(parts, items));
+        if (kind) {
+            (_a = result.entities) !== null && _a !== void 0 ? _a : (result.entities = []);
+            result.entities.unshift({
+                type: kind,
+                offset: 0,
+                length: result.text.length,
+                ...opts,
+            });
+            result.parse_mode = undefined;
+        }
+        return result;
+    };
+}
+const linkOrMention = (content, data) => {
+    const { text, entities = [] } = FmtString.normalise(content);
+    entities.unshift(Object.assign(data, { offset: 0, length: text.length }));
+    return new FmtString(text, entities);
+};
+exports.linkOrMention = linkOrMention;

package/lib/Telegram/core/helpers/util.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.env = void 0;
+exports.fmtCaption = fmtCaption;
+exports.zip = zip;
+exports.indexed = indexed;
+exports.env = process.env;
+function fmtCaption(extra) {
+    if (!extra)
+        return;
+    const caption = extra.caption;
+    if (!caption || typeof caption === 'string')
+        return extra;
+    const { text, entities } = caption;
+    return {
+        ...extra,
+        caption: text,
+        ...(entities && {
+            caption_entities: entities,
+            parse_mode: undefined,
+        }),
+    };
+}
+function* zip(xs, ys) {
+    const x = xs[Symbol.iterator]();
+    const y = ys[Symbol.iterator]();
+    let x1 = x.next();
+    let y1 = y.next();
+    while (!x1.done) {
+        yield x1.value;
+        if (!y1.done)
+            yield y1.value;
+        x1 = x.next();
+        y1 = y.next();
+    }
+    while (!y1.done) {
+        yield y1.value;
+        y1 = y.next();
+    }
+}
+function indexed(target, indexer) {
+    return new Proxy(target, {
+        get: function (target, prop, receiver) {
+            if ((typeof prop === 'string' || typeof prop === 'number') &&
+                !isNaN(+prop))
+                return indexer.call(target, +prop);
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}

package/lib/Telegram/core/network/client.js

@@ -0,0 +1,330 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint @typescript-eslint/restrict-template-expressions: [ "error", { "allowNumber": true, "allowBoolean": true } ] */
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const promises_1 = require("fs/promises");
+const https = __importStar(require("https"));
+const path = __importStar(require("path"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const check_1 = require("../helpers/check");
+const compact_1 = require("../helpers/compact");
+const multipart_stream_1 = __importDefault(require("./multipart-stream"));
+const error_1 = __importDefault(require("./error"));
+const url_1 = require("url");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const debug = require('debug')('telegraf:client');
+const { isStream } = multipart_stream_1.default;
+const WEBHOOK_REPLY_METHOD_ALLOWLIST = new Set([
+    'answerCallbackQuery',
+    'answerInlineQuery',
+    'deleteMessage',
+    'leaveChat',
+    'sendChatAction',
+]);
+const DEFAULT_EXTENSIONS = {
+    audio: 'mp3',
+    photo: 'jpg',
+    sticker: 'webp',
+    video: 'mp4',
+    animation: 'mp4',
+    video_note: 'mp4',
+    voice: 'ogg',
+};
+const DEFAULT_OPTIONS = {
+    apiRoot: 'https://api.telegram.org',
+    apiMode: 'bot',
+    webhookReply: true,
+    agent: new https.Agent({
+        keepAlive: true,
+        keepAliveMsecs: 10000,
+    }),
+    attachmentAgent: undefined,
+    testEnv: false,
+};
+function includesMedia(payload) {
+    return Object.entries(payload).some(([key, value]) => {
+        if (key === 'link_preview_options')
+            return false;
+        if (Array.isArray(value)) {
+            return value.some(({ media }) => media && typeof media === 'object' && (media.source || media.url));
+        }
+        return (value &&
+            typeof value === 'object' &&
+            (((0, check_1.hasProp)(value, 'source') && value.source) ||
+                ((0, check_1.hasProp)(value, 'url') && value.url) ||
+                ((0, check_1.hasPropType)(value, 'media', 'object') &&
+                    (((0, check_1.hasProp)(value.media, 'source') && value.media.source) ||
+                        ((0, check_1.hasProp)(value.media, 'url') && value.media.url)))));
+    });
+}
+function replacer(_, value) {
+    if (value == null)
+        return undefined;
+    return value;
+}
+function buildJSONConfig(payload) {
+    return Promise.resolve({
+        method: 'POST',
+        compress: true,
+        headers: { 'content-type': 'application/json', connection: 'keep-alive' },
+        body: JSON.stringify(payload, replacer),
+    });
+}
+const FORM_DATA_JSON_FIELDS = [
+    'results',
+    'reply_markup',
+    'mask_position',
+    'shipping_options',
+    'errors',
+];
+async function buildFormDataConfig(payload, agent) {
+    for (const field of FORM_DATA_JSON_FIELDS) {
+        if ((0, check_1.hasProp)(payload, field) && typeof payload[field] !== 'string') {
+            payload[field] = JSON.stringify(payload[field]);
+        }
+    }
+    const boundary = crypto.randomBytes(32).toString('hex');
+    const formData = new multipart_stream_1.default(boundary);
+    await Promise.all(Object.keys(payload).map((key) => 
+    // @ts-expect-error payload[key] can obviously index payload, but TS doesn't trust us
+    attachFormValue(formData, key, payload[key], agent)));
+    return {
+        method: 'POST',
+        compress: true,
+        headers: {
+            'content-type': `multipart/form-data; boundary=${boundary}`,
+            connection: 'keep-alive',
+        },
+        body: formData,
+    };
+}
+async function attachFormValue(form, id, value, agent) {
+    if (value == null) {
+        return;
+    }
+    if (typeof value === 'string' ||
+        typeof value === 'boolean' ||
+        typeof value === 'number') {
+        form.addPart({
+            headers: { 'content-disposition': `form-data; name="${id}"` },
+            body: `${value}`,
+        });
+        return;
+    }
+    if (id === 'thumb' || id === 'thumbnail') {
+        const attachmentId = crypto.randomBytes(16).toString('hex');
+        await attachFormMedia(form, value, attachmentId, agent);
+        return form.addPart({
+            headers: { 'content-disposition': `form-data; name="${id}"` },
+            body: `attach://${attachmentId}`,
+        });
+    }
+    if (Array.isArray(value)) {
+        const items = await Promise.all(value.map(async (item) => {
+            var _a;
+            if (typeof item.media !== 'object') {
+                return await Promise.resolve(item);
+            }
+            const attachmentId = crypto.randomBytes(16).toString('hex');
+            await attachFormMedia(form, item.media, attachmentId, agent);
+            const thumb = (_a = item.thumb) !== null && _a !== void 0 ? _a : item.thumbnail;
+            if (typeof thumb === 'object') {
+                const thumbAttachmentId = crypto.randomBytes(16).toString('hex');
+                await attachFormMedia(form, thumb, thumbAttachmentId, agent);
+                return {
+                    ...item,
+                    media: `attach://${attachmentId}`,
+                    thumbnail: `attach://${thumbAttachmentId}`,
+                };
+            }
+            return { ...item, media: `attach://${attachmentId}` };
+        }));
+        return form.addPart({
+            headers: { 'content-disposition': `form-data; name="${id}"` },
+            body: JSON.stringify(items),
+        });
+    }
+    if (value &&
+        typeof value === 'object' &&
+        (0, check_1.hasProp)(value, 'media') &&
+        (0, check_1.hasProp)(value, 'type') &&
+        typeof value.media !== 'undefined' &&
+        typeof value.type !== 'undefined') {
+        const attachmentId = crypto.randomBytes(16).toString('hex');
+        await attachFormMedia(form, value.media, attachmentId, agent);
+        return form.addPart({
+            headers: { 'content-disposition': `form-data; name="${id}"` },
+            body: JSON.stringify({
+                ...value,
+                media: `attach://${attachmentId}`,
+            }),
+        });
+    }
+    return await attachFormMedia(form, value, id, agent);
+}
+async function attachFormMedia(form, media, id, agent) {
+    var _a, _b, _c;
+    let fileName = (_a = media.filename) !== null && _a !== void 0 ? _a : `${id}.${(_b = DEFAULT_EXTENSIONS[id]) !== null && _b !== void 0 ? _b : 'dat'}`;
+    if ('url' in media && media.url !== undefined) {
+        const timeout = 500000; // ms
+        const res = await (0, node_fetch_1.default)(media.url, { agent, timeout });
+        return form.addPart({
+            headers: {
+                'content-disposition': `form-data; name="${id}"; filename="${fileName}"`,
+            },
+            body: res.body,
+        });
+    }
+    if ('source' in media && media.source) {
+        let mediaSource = media.source;
+        if (typeof media.source === 'string') {
+            const source = await (0, promises_1.realpath)(media.source);
+            if ((await (0, promises_1.stat)(source)).isFile()) {
+                fileName = (_c = media.filename) !== null && _c !== void 0 ? _c : path.basename(media.source);
+                mediaSource = await fs.createReadStream(media.source);
+            }
+            else {
+                throw new TypeError(`Unable to upload '${media.source}', not a file`);
+            }
+        }
+        if (isStream(mediaSource) || Buffer.isBuffer(mediaSource)) {
+            form.addPart({
+                headers: {
+                    'content-disposition': `form-data; name="${id}"; filename="${fileName}"`,
+                },
+                body: mediaSource,
+            });
+        }
+    }
+}
+async function answerToWebhook(response, payload, options) {
+    if (!includesMedia(payload)) {
+        if (!response.headersSent) {
+            response.setHeader('content-type', 'application/json');
+        }
+        response.end(JSON.stringify(payload), 'utf-8');
+        return true;
+    }
+    const { headers, body } = await buildFormDataConfig(payload, options.attachmentAgent);
+    if (!response.headersSent) {
+        for (const [key, value] of Object.entries(headers)) {
+            response.setHeader(key, value);
+        }
+    }
+    await new Promise((resolve) => {
+        response.on('finish', resolve);
+        body.pipe(response);
+    });
+    return true;
+}
+function redactToken(error) {
+    error.message = error.message.replace(/\/(bot|user)(\d+):[^/]+\//, '/$1$2:[REDACTED]/');
+    throw error;
+}
+class ApiClient {
+    constructor(token, options, response) {
+        this.token = token;
+        this.response = response;
+        this.options = {
+            ...DEFAULT_OPTIONS,
+            ...(0, compact_1.compactOptions)(options),
+        };
+        if (this.options.apiRoot.startsWith('http://')) {
+            this.options.agent = undefined;
+        }
+    }
+    /**
+     * If set to `true`, first _eligible_ call will avoid performing a POST request.
+     * Note that such a call:
+     * 1. cannot report errors or return meaningful values,
+     * 2. resolves before bot API has a chance to process it,
+     * 3. prematurely confirms the update as processed.
+     *
+     * https://core.telegram.org/bots/faq#how-can-i-make-requests-in-response-to-updates
+     * https://github.com/telegraf/telegraf/pull/1250
+     */
+    set webhookReply(enable) {
+        this.options.webhookReply = enable;
+    }
+    get webhookReply() {
+        return this.options.webhookReply;
+    }
+    async callApi(method, payload, { signal } = {}) {
+        const { token, options, response } = this;
+        if (options.webhookReply &&
+            (response === null || response === void 0 ? void 0 : response.writableEnded) === false &&
+            WEBHOOK_REPLY_METHOD_ALLOWLIST.has(method)) {
+            debug('Call via webhook', method, payload);
+            // @ts-expect-error using webhookReply is an optimisation that doesn't respond with normal result
+            // up to the user to deal with this
+            return await answerToWebhook(response, { method, ...payload }, options);
+        }
+        if (!token) {
+            throw new error_1.default({
+                error_code: 401,
+                description: 'Bot Token is required',
+            });
+        }
+        debug('HTTP call', method, payload);
+        const config = includesMedia(payload)
+            ? await buildFormDataConfig({ method, ...payload }, options.attachmentAgent)
+            : await buildJSONConfig(payload);
+        const apiUrl = new url_1.URL(`./${options.apiMode}${token}${options.testEnv ? '/test' : ''}/${method}`, options.apiRoot);
+        config.agent = options.agent;
+        // @ts-expect-error AbortSignal shim is missing some props from Request.AbortSignal
+        config.signal = signal;
+        config.timeout = 500000; // ms
+        const res = await (0, node_fetch_1.default)(apiUrl, config).catch(redactToken);
+        if (res.status >= 500) {
+            const errorPayload = {
+                error_code: res.status,
+                description: res.statusText,
+            };
+            throw new error_1.default(errorPayload, { method, payload });
+        }
+        const data = await res.json();
+        if (!data.ok) {
+            debug('API call failed', data);
+            throw new error_1.default(data, { method, payload });
+        }
+        return data.result;
+    }
+}
+exports.default = ApiClient;

package/lib/Telegram/core/network/error.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramError = void 0;
+class TelegramError extends Error {
+    constructor(response, on = {}) {
+        super(`${response.error_code}: ${response.description}`);
+        this.response = response;
+        this.on = on;
+    }
+    get code() {
+        return this.response.error_code;
+    }
+    get description() {
+        return this.response.description;
+    }
+    get parameters() {
+        return this.response.parameters;
+    }
+}
+exports.TelegramError = TelegramError;
+exports.default = TelegramError;