@kubb/agent 4.29.0 → 4.31.0

package/.output/server/node_modules/@msgpack/msgpack/dist/timestamp.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timestampExtension = exports.decodeTimestampExtension = exports.decodeTimestampToTimeSpec = exports.encodeTimestampExtension = exports.encodeDateToTimeSpec = exports.encodeTimeSpecToTimestamp = exports.EXT_TIMESTAMP = void 0;
+// https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type
+const DecodeError_1 = require("./DecodeError");
+const int_1 = require("./utils/int");
+exports.EXT_TIMESTAMP = -1;
+const TIMESTAMP32_MAX_SEC = 0x100000000 - 1; // 32-bit unsigned int
+const TIMESTAMP64_MAX_SEC = 0x400000000 - 1; // 34-bit unsigned int
+function encodeTimeSpecToTimestamp({ sec, nsec }) {
+    if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) {
+        // Here sec >= 0 && nsec >= 0
+        if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) {
+            // timestamp 32 = { sec32 (unsigned) }
+            const rv = new Uint8Array(4);
+            const view = new DataView(rv.buffer);
+            view.setUint32(0, sec);
+            return rv;
+        }
+        else {
+            // timestamp 64 = { nsec30 (unsigned), sec34 (unsigned) }
+            const secHigh = sec / 0x100000000;
+            const secLow = sec & 0xffffffff;
+            const rv = new Uint8Array(8);
+            const view = new DataView(rv.buffer);
+            // nsec30 | secHigh2
+            view.setUint32(0, (nsec << 2) | (secHigh & 0x3));
+            // secLow32
+            view.setUint32(4, secLow);
+            return rv;
+        }
+    }
+    else {
+        // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }
+        const rv = new Uint8Array(12);
+        const view = new DataView(rv.buffer);
+        view.setUint32(0, nsec);
+        (0, int_1.setInt64)(view, 4, sec);
+        return rv;
+    }
+}
+exports.encodeTimeSpecToTimestamp = encodeTimeSpecToTimestamp;
+function encodeDateToTimeSpec(date) {
+    const msec = date.getTime();
+    const sec = Math.floor(msec / 1e3);
+    const nsec = (msec - sec * 1e3) * 1e6;
+    // Normalizes { sec, nsec } to ensure nsec is unsigned.
+    const nsecInSec = Math.floor(nsec / 1e9);
+    return {
+        sec: sec + nsecInSec,
+        nsec: nsec - nsecInSec * 1e9,
+    };
+}
+exports.encodeDateToTimeSpec = encodeDateToTimeSpec;
+function encodeTimestampExtension(object) {
+    if (object instanceof Date) {
+        const timeSpec = encodeDateToTimeSpec(object);
+        return encodeTimeSpecToTimestamp(timeSpec);
+    }
+    else {
+        return null;
+    }
+}
+exports.encodeTimestampExtension = encodeTimestampExtension;
+function decodeTimestampToTimeSpec(data) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    // data may be 32, 64, or 96 bits
+    switch (data.byteLength) {
+        case 4: {
+            // timestamp 32 = { sec32 }
+            const sec = view.getUint32(0);
+            const nsec = 0;
+            return { sec, nsec };
+        }
+        case 8: {
+            // timestamp 64 = { nsec30, sec34 }
+            const nsec30AndSecHigh2 = view.getUint32(0);
+            const secLow32 = view.getUint32(4);
+            const sec = (nsec30AndSecHigh2 & 0x3) * 0x100000000 + secLow32;
+            const nsec = nsec30AndSecHigh2 >>> 2;
+            return { sec, nsec };
+        }
+        case 12: {
+            // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }
+            const sec = (0, int_1.getInt64)(view, 4);
+            const nsec = view.getUint32(0);
+            return { sec, nsec };
+        }
+        default:
+            throw new DecodeError_1.DecodeError(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${data.length}`);
+    }
+}
+exports.decodeTimestampToTimeSpec = decodeTimestampToTimeSpec;
+function decodeTimestampExtension(data) {
+    const timeSpec = decodeTimestampToTimeSpec(data);
+    return new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);
+}
+exports.decodeTimestampExtension = decodeTimestampExtension;
+exports.timestampExtension = {
+    type: exports.EXT_TIMESTAMP,
+    encode: encodeTimestampExtension,
+    decode: decodeTimestampExtension,
+};
+//# sourceMappingURL=timestamp.js.map

package/.output/server/node_modules/@msgpack/msgpack/dist/utils/int.js

@@ -0,0 +1,34 @@
+"use strict";
+// Integer Utility
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUint64 = exports.getInt64 = exports.setInt64 = exports.setUint64 = exports.UINT32_MAX = void 0;
+exports.UINT32_MAX = 4294967295;
+// DataView extension to handle int64 / uint64,
+// where the actual range is 53-bits integer (a.k.a. safe integer)
+function setUint64(view, offset, value) {
+    const high = value / 4294967296;
+    const low = value; // high bits are truncated by DataView
+    view.setUint32(offset, high);
+    view.setUint32(offset + 4, low);
+}
+exports.setUint64 = setUint64;
+function setInt64(view, offset, value) {
+    const high = Math.floor(value / 4294967296);
+    const low = value; // high bits are truncated by DataView
+    view.setUint32(offset, high);
+    view.setUint32(offset + 4, low);
+}
+exports.setInt64 = setInt64;
+function getInt64(view, offset) {
+    const high = view.getInt32(offset);
+    const low = view.getUint32(offset + 4);
+    return high * 4294967296 + low;
+}
+exports.getInt64 = getInt64;
+function getUint64(view, offset) {
+    const high = view.getUint32(offset);
+    const low = view.getUint32(offset + 4);
+    return high * 4294967296 + low;
+}
+exports.getUint64 = getUint64;
+//# sourceMappingURL=int.js.map

package/.output/server/node_modules/@msgpack/msgpack/dist/utils/prettyByte.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyByte = void 0;
+function prettyByte(byte) {
+    return `${byte < 0 ? "-" : ""}0x${Math.abs(byte).toString(16).padStart(2, "0")}`;
+}
+exports.prettyByte = prettyByte;
+//# sourceMappingURL=prettyByte.js.map

package/.output/server/node_modules/@msgpack/msgpack/dist/utils/stream.js

@@ -0,0 +1,40 @@
+"use strict";
+// utility for whatwg streams
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureAsyncIterable = exports.asyncIterableFromStream = exports.isAsyncIterable = void 0;
+function isAsyncIterable(object) {
+    return object[Symbol.asyncIterator] != null;
+}
+exports.isAsyncIterable = isAsyncIterable;
+function assertNonNull(value) {
+    if (value == null) {
+        throw new Error("Assertion Failure: value must not be null nor undefined");
+    }
+}
+async function* asyncIterableFromStream(stream) {
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                return;
+            }
+            assertNonNull(value);
+            yield value;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+exports.asyncIterableFromStream = asyncIterableFromStream;
+function ensureAsyncIterable(streamLike) {
+    if (isAsyncIterable(streamLike)) {
+        return streamLike;
+    }
+    else {
+        return asyncIterableFromStream(streamLike);
+    }
+}
+exports.ensureAsyncIterable = ensureAsyncIterable;
+//# sourceMappingURL=stream.js.map

package/.output/server/node_modules/@msgpack/msgpack/dist/utils/typedArrays.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDataView = exports.ensureUint8Array = void 0;
+function ensureUint8Array(buffer) {
+    if (buffer instanceof Uint8Array) {
+        return buffer;
+    }
+    else if (ArrayBuffer.isView(buffer)) {
+        return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    }
+    else if (buffer instanceof ArrayBuffer) {
+        return new Uint8Array(buffer);
+    }
+    else {
+        // ArrayLike<number>
+        return Uint8Array.from(buffer);
+    }
+}
+exports.ensureUint8Array = ensureUint8Array;
+function createDataView(buffer) {
+    if (buffer instanceof ArrayBuffer) {
+        return new DataView(buffer);
+    }
+    const bufferView = ensureUint8Array(buffer);
+    return new DataView(bufferView.buffer, bufferView.byteOffset, bufferView.byteLength);
+}
+exports.createDataView = createDataView;
+//# sourceMappingURL=typedArrays.js.map

package/.output/server/node_modules/@msgpack/msgpack/dist/utils/utf8.js

@@ -0,0 +1,167 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utf8DecodeTD = exports.TEXT_DECODER_THRESHOLD = exports.utf8DecodeJs = exports.utf8EncodeTE = exports.TEXT_ENCODER_THRESHOLD = exports.utf8EncodeJs = exports.utf8Count = void 0;
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+const int_1 = require("./int");
+const TEXT_ENCODING_AVAILABLE = (typeof process === "undefined" || ((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a["TEXT_ENCODING"]) !== "never") &&
+    typeof TextEncoder !== "undefined" &&
+    typeof TextDecoder !== "undefined";
+function utf8Count(str) {
+    const strLength = str.length;
+    let byteLength = 0;
+    let pos = 0;
+    while (pos < strLength) {
+        let value = str.charCodeAt(pos++);
+        if ((value & 0xffffff80) === 0) {
+            // 1-byte
+            byteLength++;
+            continue;
+        }
+        else if ((value & 0xfffff800) === 0) {
+            // 2-bytes
+            byteLength += 2;
+        }
+        else {
+            // handle surrogate pair
+            if (value >= 0xd800 && value <= 0xdbff) {
+                // high surrogate
+                if (pos < strLength) {
+                    const extra = str.charCodeAt(pos);
+                    if ((extra & 0xfc00) === 0xdc00) {
+                        ++pos;
+                        value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
+                    }
+                }
+            }
+            if ((value & 0xffff0000) === 0) {
+                // 3-byte
+                byteLength += 3;
+            }
+            else {
+                // 4-byte
+                byteLength += 4;
+            }
+        }
+    }
+    return byteLength;
+}
+exports.utf8Count = utf8Count;
+function utf8EncodeJs(str, output, outputOffset) {
+    const strLength = str.length;
+    let offset = outputOffset;
+    let pos = 0;
+    while (pos < strLength) {
+        let value = str.charCodeAt(pos++);
+        if ((value & 0xffffff80) === 0) {
+            // 1-byte
+            output[offset++] = value;
+            continue;
+        }
+        else if ((value & 0xfffff800) === 0) {
+            // 2-bytes
+            output[offset++] = ((value >> 6) & 0x1f) | 0xc0;
+        }
+        else {
+            // handle surrogate pair
+            if (value >= 0xd800 && value <= 0xdbff) {
+                // high surrogate
+                if (pos < strLength) {
+                    const extra = str.charCodeAt(pos);
+                    if ((extra & 0xfc00) === 0xdc00) {
+                        ++pos;
+                        value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
+                    }
+                }
+            }
+            if ((value & 0xffff0000) === 0) {
+                // 3-byte
+                output[offset++] = ((value >> 12) & 0x0f) | 0xe0;
+                output[offset++] = ((value >> 6) & 0x3f) | 0x80;
+            }
+            else {
+                // 4-byte
+                output[offset++] = ((value >> 18) & 0x07) | 0xf0;
+                output[offset++] = ((value >> 12) & 0x3f) | 0x80;
+                output[offset++] = ((value >> 6) & 0x3f) | 0x80;
+            }
+        }
+        output[offset++] = (value & 0x3f) | 0x80;
+    }
+}
+exports.utf8EncodeJs = utf8EncodeJs;
+const sharedTextEncoder = TEXT_ENCODING_AVAILABLE ? new TextEncoder() : undefined;
+exports.TEXT_ENCODER_THRESHOLD = !TEXT_ENCODING_AVAILABLE
+    ? int_1.UINT32_MAX
+    : typeof process !== "undefined" && ((_b = process === null || process === void 0 ? void 0 : process.env) === null || _b === void 0 ? void 0 : _b["TEXT_ENCODING"]) !== "force"
+        ? 200
+        : 0;
+function utf8EncodeTEencode(str, output, outputOffset) {
+    output.set(sharedTextEncoder.encode(str), outputOffset);
+}
+function utf8EncodeTEencodeInto(str, output, outputOffset) {
+    sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));
+}
+exports.utf8EncodeTE = (sharedTextEncoder === null || sharedTextEncoder === void 0 ? void 0 : sharedTextEncoder.encodeInto) ? utf8EncodeTEencodeInto : utf8EncodeTEencode;
+const CHUNK_SIZE = 4096;
+function utf8DecodeJs(bytes, inputOffset, byteLength) {
+    let offset = inputOffset;
+    const end = offset + byteLength;
+    const units = [];
+    let result = "";
+    while (offset < end) {
+        const byte1 = bytes[offset++];
+        if ((byte1 & 0x80) === 0) {
+            // 1 byte
+            units.push(byte1);
+        }
+        else if ((byte1 & 0xe0) === 0xc0) {
+            // 2 bytes
+            const byte2 = bytes[offset++] & 0x3f;
+            units.push(((byte1 & 0x1f) << 6) | byte2);
+        }
+        else if ((byte1 & 0xf0) === 0xe0) {
+            // 3 bytes
+            const byte2 = bytes[offset++] & 0x3f;
+            const byte3 = bytes[offset++] & 0x3f;
+            units.push(((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3);
+        }
+        else if ((byte1 & 0xf8) === 0xf0) {
+            // 4 bytes
+            const byte2 = bytes[offset++] & 0x3f;
+            const byte3 = bytes[offset++] & 0x3f;
+            const byte4 = bytes[offset++] & 0x3f;
+            let unit = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;
+            if (unit > 0xffff) {
+                unit -= 0x10000;
+                units.push(((unit >>> 10) & 0x3ff) | 0xd800);
+                unit = 0xdc00 | (unit & 0x3ff);
+            }
+            units.push(unit);
+        }
+        else {
+            units.push(byte1);
+        }
+        if (units.length >= CHUNK_SIZE) {
+            result += String.fromCharCode(...units);
+            units.length = 0;
+        }
+    }
+    if (units.length > 0) {
+        result += String.fromCharCode(...units);
+    }
+    return result;
+}
+exports.utf8DecodeJs = utf8DecodeJs;
+const sharedTextDecoder = TEXT_ENCODING_AVAILABLE ? new TextDecoder() : null;
+exports.TEXT_DECODER_THRESHOLD = !TEXT_ENCODING_AVAILABLE
+    ? int_1.UINT32_MAX
+    : typeof process !== "undefined" && ((_c = process === null || process === void 0 ? void 0 : process.env) === null || _c === void 0 ? void 0 : _c["TEXT_DECODER"]) !== "force"
+        ? 200
+        : 0;
+function utf8DecodeTD(bytes, inputOffset, byteLength) {
+    const stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);
+    return sharedTextDecoder.decode(stringBytes);
+}
+exports.utf8DecodeTD = utf8DecodeTD;
+//# sourceMappingURL=utf8.js.map

package/.output/server/node_modules/@msgpack/msgpack/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "@msgpack/msgpack",
+  "version": "2.8.0",
+  "description": "MessagePack for ECMA-262/JavaScript/TypeScript",
+  "author": "The MessagePack community",
+  "license": "ISC",
+  "main": "./dist/index.js",
+  "module": "./dist.es5+esm/index.mjs",
+  "cdn": "./dist.es5+umd/msgpack.min.js",
+  "unpkg": "./dist.es5+umd/msgpack.min.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "scripts": {
+    "build": "npm publish --dry-run",
+    "prepare": "npm run clean && webpack --bail && tsc --build tsconfig.dist.json tsconfig.dist.es5+esm.json && ts-node tools/esmify.ts dist.es5+esm/*.js dist.es5+esm/*/*.js",
+    "prepublishOnly": "run-p 'test:dist:*' && npm run test:browser",
+    "clean": "rimraf build dist dist.*",
+    "test": "mocha 'test/**/*.test.ts'",
+    "test:purejs": "TEXT_ENCODING=never mocha 'test/**/*.test.ts'",
+    "test:te": "TEXT_ENCODING=force mocha 'test/**/*.test.ts'",
+    "test:dist:purejs": "TS_NODE_PROJECT=tsconfig.test-dist-es5-purejs.json npm run test:purejs -- --reporter=dot",
+    "test:cover": "npm run cover:clean && npm-run-all 'test:cover:*' && npm run cover:report",
+    "test:cover:purejs": "npx nyc --no-clean npm run test:purejs",
+    "test:cover:te": "npx nyc --no-clean npm run test:te",
+    "test:deno": "deno test test/deno_test.ts",
+    "test:fuzz": "npm exec --yes -- jsfuzz@git+https://gitlab.com/gitlab-org/security-products/analyzers/fuzzers/jsfuzz.git --fuzzTime 60 --no-versifier test/decode.jsfuzz.js corpus",
+    "cover:clean": "rimraf .nyc_output coverage/",
+    "cover:report": "npx nyc report --reporter=text-summary --reporter=html --reporter=json",
+    "test:browser": "karma start --single-run",
+    "test:browser:firefox": "karma start --single-run --browsers FirefoxHeadless",
+    "test:browser:chrome": "karma start --single-run --browsers ChromeHeadless",
+    "test:watch:browser": "karma start --browsers ChromeHeadless,FirefoxHeadless",
+    "test:watch:nodejs": "mocha -w 'test/**/*.test.ts'",
+    "lint": "eslint --ext .ts src test",
+    "lint:fix": "prettier --loglevel=warn --write 'src/**/*.ts' 'test/**/*.ts' && eslint --fix --ext .ts src test",
+    "lint:print-config": "eslint --print-config .eslintrc.js",
+    "update-dependencies": "npx rimraf node_modules/ package-lock.json ; npm install ; npm audit fix --force ; git restore package.json ; npm install"
+  },
+  "homepage": "https://msgpack.org/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/msgpack/msgpack-javascript.git"
+  },
+  "bugs": {
+    "url": "https://github.com/msgpack/msgpack-javascript/issues"
+  },
+  "keywords": [
+    "msgpack",
+    "MessagePack",
+    "serialization",
+    "universal"
+  ],
+  "engines": {
+    "node": ">= 10"
+  },
+  "devDependencies": {
+    "@bitjourney/check-es-version-webpack-plugin": "latest",
+    "@types/lodash": "latest",
+    "@types/mocha": "latest",
+    "@types/node": "latest",
+    "@typescript-eslint/eslint-plugin": "latest",
+    "@typescript-eslint/parser": "latest",
+    "assert": "latest",
+    "blob-polyfill": "latest",
+    "buffer": "latest",
+    "core-js": "latest",
+    "eslint": "latest",
+    "eslint-config-prettier": "latest",
+    "eslint-plugin-import": "latest",
+    "eslint-plugin-tsdoc": "latest",
+    "ieee754": "latest",
+    "karma": "latest",
+    "karma-chrome-launcher": "latest",
+    "karma-cli": "latest",
+    "karma-firefox-launcher": "latest",
+    "karma-mocha": "latest",
+    "karma-sourcemap-loader": "latest",
+    "karma-webpack": "latest",
+    "lodash": "latest",
+    "mocha": "latest",
+    "msgpack-test-js": "latest",
+    "npm-run-all": "latest",
+    "prettier": "latest",
+    "rimraf": "latest",
+    "ts-loader": "latest",
+    "ts-node": "latest",
+    "tsconfig-paths": "latest",
+    "typescript": "latest",
+    "web-streams-polyfill": "latest",
+    "webpack": "latest",
+    "webpack-cli": "latest"
+  },
+  "files": [
+    "mod.ts",
+    "src/**/*.*",
+    "dist/**/*.*",
+    "dist.es5+umd/**/*.*",
+    "dist.es5+esm/**/*.*"
+  ]
+}