node_modules: update (#322)

Co-authored-by: dawidd6 <9713907+dawidd6@users.noreply.github.com>
2026-09-17 09:06:48 +07:00 · 2026-09-15 13:00:32 +02:00
parent 4a3d0f9ca3
commit 67ce3558d6
174 changed files with 25661 additions and 5540 deletions
@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Encoder = void 0;
+exports.encode = encode;
+exports.wrap = wrap;
+const node_stream_1 = require("node:stream");
+/**
+ * Encodes a Buffer into a base64 encoded string
+ *
+ * @param buffer Buffer to convert
+ * @returns base64 encoded string
+ */
+function encode(buffer) {
+    if (typeof buffer === 'string') {
+        buffer = Buffer.from(buffer, 'utf-8');
+    }
+    return buffer.toString('base64');
+}
+/**
+ * Adds soft line breaks to a base64 string
+ *
+ * @param str base64 encoded string that might need line wrapping
+ * @param [lineLength=76] Maximum allowed length for a line
+ * @returns Soft-wrapped base64 encoded string
+ */
+function wrap(str, lineLength) {
+    str = (str || '').toString();
+    lineLength = lineLength || 76;
+    if (str.length <= lineLength) {
+        return str;
+    }
+    const result = [];
+    let pos = 0;
+    const chunkLength = lineLength * 1024;
+    const wrapRegex = new RegExp('.{' + lineLength + '}', 'g');
+    while (pos < str.length) {
+        const wrappedLines = str.substr(pos, chunkLength).replace(wrapRegex, '$&\r\n').trim();
+        result.push(wrappedLines);
+        pos += chunkLength;
+    }
+    return result.join('\r\n').trim();
+}
+/**
+ * Creates a transform stream for encoding data to base64 encoding
+ *
+ * @constructor
+ * @param options Stream options
+ * @param [options.lineLength=76] Maximum length for lines, set to false to disable wrapping
+ */
+class Encoder extends node_stream_1.Transform {
+    constructor(options) {
+        super();
+        this.options = options || {};
+        if (this.options.lineLength !== false) {
+            this.options.lineLength = this.options.lineLength || 76;
+        }
+        this._curLine = '';
+        this._remainingBytes = false;
+        this.inputBytes = 0;
+        this.outputBytes = 0;
+    }
+    /** @internal */
+    _transform(chunk, encoding, done) {
+        let buf = encoding !== 'buffer' ? Buffer.from(chunk, encoding) : chunk;
+        if (!buf || !buf.length) {
+            setImmediate(done);
+            return;
+        }
+        this.inputBytes += buf.length;
+        if (this._remainingBytes && this._remainingBytes.length) {
+            buf = Buffer.concat([this._remainingBytes, buf], this._remainingBytes.length + buf.length);
+            this._remainingBytes = false;
+        }
+        if (buf.length % 3) {
+            this._remainingBytes = buf.slice(buf.length - (buf.length % 3));
+            buf = buf.slice(0, buf.length - (buf.length % 3));
+        }
+        else {
+            this._remainingBytes = false;
+        }
+        let b64 = this._curLine + encode(buf);
+        if (this.options.lineLength) {
+            b64 = wrap(b64, this.options.lineLength);
+            // remove last line as it is still most probably incomplete
+            const lastLF = b64.lastIndexOf('\n');
+            if (lastLF < 0) {
+                this._curLine = b64;
+                b64 = '';
+            }
+            else if (lastLF === b64.length - 1) {
+                this._curLine = '';
+            }
+            else {
+                this._curLine = b64.substring(lastLF + 1);
+                b64 = b64.substring(0, lastLF + 1);
+            }
+        }
+        if (b64) {
+            this.outputBytes += b64.length;
+            this.push(Buffer.from(b64, 'ascii'));
+        }
+        setImmediate(done);
+    }
+    /** @internal */
+    _flush(done) {
+        if (this._remainingBytes && this._remainingBytes.length) {
+            this._curLine += encode(this._remainingBytes);
+        }
+        if (this._curLine) {
+            this._curLine = wrap(this._curLine, this.options.lineLength);
+            this.outputBytes += this._curLine.length;
+            this.push(Buffer.from(this._curLine, 'ascii'));
+            this._curLine = '';
+        }
+        done();
+    }
+}
+exports.Encoder = Encoder;