@kubb/agent 4.33.0 → 4.33.2

package/.output/server/node_modules/yaml-ast-parser/dist/src/mark.js

@@ -0,0 +1,62 @@
+'use strict';
+var common = require("./common");
+var Mark = (function () {
+    function Mark(name, buffer, position, line, column) {
+        this.name = name;
+        this.buffer = buffer;
+        this.position = position;
+        this.line = line;
+        this.column = column;
+    }
+    Mark.prototype.getSnippet = function (indent, maxLength) {
+        if (indent === void 0) { indent = 0; }
+        if (maxLength === void 0) { maxLength = 75; }
+        var head, start, tail, end, snippet;
+        if (!this.buffer) {
+            return null;
+        }
+        indent = indent || 4;
+        maxLength = maxLength || 75;
+        head = '';
+        start = this.position;
+        while (start > 0 && -1 === '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(start - 1))) {
+            start -= 1;
+            if (this.position - start > (maxLength / 2 - 1)) {
+                head = ' ... ';
+                start += 5;
+                break;
+            }
+        }
+        tail = '';
+        end = this.position;
+        while (end < this.buffer.length && -1 === '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(end))) {
+            end += 1;
+            if (end - this.position > (maxLength / 2 - 1)) {
+                tail = ' ... ';
+                end -= 5;
+                break;
+            }
+        }
+        snippet = this.buffer.slice(start, end);
+        return common.repeat(' ', indent) + head + snippet + tail + '\n' +
+            common.repeat(' ', indent + this.position - start + head.length) + '^';
+    };
+    Mark.prototype.toString = function (compact) {
+        if (compact === void 0) { compact = true; }
+        var snippet, where = '';
+        if (this.name) {
+            where += 'in "' + this.name + '" ';
+        }
+        where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1);
+        if (!compact) {
+            snippet = this.getSnippet();
+            if (snippet) {
+                where += ':\n' + snippet;
+            }
+        }
+        return where;
+    };
+    return Mark;
+}());
+module.exports = Mark;
+//# sourceMappingURL=mark.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/scalarInference.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function parseYamlBoolean(input) {
+    if (["true", "True", "TRUE"].lastIndexOf(input) >= 0) {
+        return true;
+    }
+    else if (["false", "False", "FALSE"].lastIndexOf(input) >= 0) {
+        return false;
+    }
+    throw "Invalid boolean \"" + input + "\"";
+}
+exports.parseYamlBoolean = parseYamlBoolean;
+function safeParseYamlInteger(input) {
+    if (input.lastIndexOf('0o', 0) === 0) {
+        return parseInt(input.substring(2), 8);
+    }
+    return parseInt(input);
+}
+function parseYamlInteger(input) {
+    var result = safeParseYamlInteger(input);
+    if (isNaN(result)) {
+        throw "Invalid integer \"" + input + "\"";
+    }
+    return result;
+}
+exports.parseYamlInteger = parseYamlInteger;
+function parseYamlFloat(input) {
+    if ([".nan", ".NaN", ".NAN"].lastIndexOf(input) >= 0) {
+        return NaN;
+    }
+    var infinity = /^([-+])?(?:\.inf|\.Inf|\.INF)$/;
+    var match = infinity.exec(input);
+    if (match) {
+        return (match[1] === '-') ? -Infinity : Infinity;
+    }
+    var result = parseFloat(input);
+    if (!isNaN(result)) {
+        return result;
+    }
+    throw "Invalid float \"" + input + "\"";
+}
+exports.parseYamlFloat = parseYamlFloat;
+var ScalarType;
+(function (ScalarType) {
+    ScalarType[ScalarType["null"] = 0] = "null";
+    ScalarType[ScalarType["bool"] = 1] = "bool";
+    ScalarType[ScalarType["int"] = 2] = "int";
+    ScalarType[ScalarType["float"] = 3] = "float";
+    ScalarType[ScalarType["string"] = 4] = "string";
+})(ScalarType = exports.ScalarType || (exports.ScalarType = {}));
+function determineScalarType(node) {
+    if (node === undefined) {
+        return ScalarType.null;
+    }
+    if (node.doubleQuoted || !node.plainScalar || node['singleQuoted']) {
+        return ScalarType.string;
+    }
+    var value = node.value;
+    if (["null", "Null", "NULL", "~", ''].indexOf(value) >= 0) {
+        return ScalarType.null;
+    }
+    if (value === null || value === undefined) {
+        return ScalarType.null;
+    }
+    if (["true", "True", "TRUE", "false", "False", "FALSE"].indexOf(value) >= 0) {
+        return ScalarType.bool;
+    }
+    var base10 = /^[-+]?[0-9]+$/;
+    var base8 = /^0o[0-7]+$/;
+    var base16 = /^0x[0-9a-fA-F]+$/;
+    if (base10.test(value) || base8.test(value) || base16.test(value)) {
+        return ScalarType.int;
+    }
+    var float = /^[-+]?(\.[0-9]+|[0-9]+(\.[0-9]*)?)([eE][-+]?[0-9]+)?$/;
+    var infinity = /^[-+]?(\.inf|\.Inf|\.INF)$/;
+    if (float.test(value) || infinity.test(value) || [".nan", ".NaN", ".NAN"].indexOf(value) >= 0) {
+        return ScalarType.float;
+    }
+    return ScalarType.string;
+}
+exports.determineScalarType = determineScalarType;
+//# sourceMappingURL=scalarInference.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/schema/core.js

@@ -0,0 +1,8 @@
+'use strict';
+var schema_1 = require("../schema");
+module.exports = new schema_1.Schema({
+    include: [
+        require('./json')
+    ]
+});
+//# sourceMappingURL=core.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/schema/default_full.js

@@ -0,0 +1,14 @@
+'use strict';
+var schema_1 = require("../schema");
+var schema = new schema_1.Schema({
+    include: [
+        require('./default_safe')
+    ],
+    explicit: [
+        require('../type/js/undefined'),
+        require('../type/js/regexp')
+    ]
+});
+schema_1.Schema.DEFAULT = schema;
+module.exports = schema;
+//# sourceMappingURL=default_full.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/schema/default_safe.js

@@ -0,0 +1,19 @@
+'use strict';
+var schema_1 = require("../schema");
+var schema = new schema_1.Schema({
+    include: [
+        require('./core')
+    ],
+    implicit: [
+        require('../type/timestamp'),
+        require('../type/merge')
+    ],
+    explicit: [
+        require('../type/binary'),
+        require('../type/omap'),
+        require('../type/pairs'),
+        require('../type/set')
+    ]
+});
+module.exports = schema;
+//# sourceMappingURL=default_safe.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/schema/failsafe.js

@@ -0,0 +1,10 @@
+'use strict';
+var schema_1 = require("../schema");
+module.exports = new schema_1.Schema({
+    explicit: [
+        require('../type/str'),
+        require('../type/seq'),
+        require('../type/map')
+    ]
+});
+//# sourceMappingURL=failsafe.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/schema/json.js

@@ -0,0 +1,14 @@
+'use strict';
+var schema_1 = require("../schema");
+module.exports = new schema_1.Schema({
+    include: [
+        require('./failsafe')
+    ],
+    implicit: [
+        require('../type/null'),
+        require('../type/bool'),
+        require('../type/int'),
+        require('../type/float')
+    ]
+});
+//# sourceMappingURL=json.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/schema.js

@@ -0,0 +1,78 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+var common = require("./common");
+var YAMLException = require("./exception");
+var type_1 = require("./type");
+function compileList(schema, name, result) {
+    var exclude = [];
+    schema.include.forEach(function (includedSchema) {
+        result = compileList(includedSchema, name, result);
+    });
+    schema[name].forEach(function (currentType) {
+        result.forEach(function (previousType, previousIndex) {
+            if (previousType.tag === currentType.tag) {
+                exclude.push(previousIndex);
+            }
+        });
+        result.push(currentType);
+    });
+    return result.filter(function (type, index) {
+        return -1 === exclude.indexOf(index);
+    });
+}
+function compileMap() {
+    var result = {}, index, length;
+    function collectType(type) {
+        result[type.tag] = type;
+    }
+    for (index = 0, length = arguments.length; index < length; index += 1) {
+        arguments[index].forEach(collectType);
+    }
+    return result;
+}
+var Schema = (function () {
+    function Schema(definition) {
+        this.include = definition.include || [];
+        this.implicit = definition.implicit || [];
+        this.explicit = definition.explicit || [];
+        this.implicit.forEach(function (type) {
+            if (type.loadKind && 'scalar' !== type.loadKind) {
+                throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');
+            }
+        });
+        this.compiledImplicit = compileList(this, 'implicit', []);
+        this.compiledExplicit = compileList(this, 'explicit', []);
+        this.compiledTypeMap = compileMap(this.compiledImplicit, this.compiledExplicit);
+    }
+    Schema.DEFAULT = null;
+    Schema.create = function createSchema() {
+        var schemas, types;
+        switch (arguments.length) {
+            case 1:
+                schemas = Schema.DEFAULT;
+                types = arguments[0];
+                break;
+            case 2:
+                schemas = arguments[0];
+                types = arguments[1];
+                break;
+            default:
+                throw new YAMLException('Wrong number of arguments for Schema.create function');
+        }
+        schemas = common.toArray(schemas);
+        types = common.toArray(types);
+        if (!schemas.every(function (schema) { return schema instanceof Schema; })) {
+            throw new YAMLException('Specified list of super schemas (or a single Schema object) contains a non-Schema object.');
+        }
+        if (!types.every(function (type) { return type instanceof type_1.Type; })) {
+            throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.');
+        }
+        return new Schema({
+            include: schemas,
+            explicit: types
+        });
+    };
+    return Schema;
+}());
+exports.Schema = Schema;
+//# sourceMappingURL=schema.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/type/binary.js

@@ -0,0 +1,92 @@
+'use strict';
+var NodeBuffer = require('buffer').Buffer;
+var type_1 = require("../type");
+var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r';
+function resolveYamlBinary(data) {
+    if (null === data) {
+        return false;
+    }
+    var code, idx, bitlen = 0, len = 0, max = data.length, map = BASE64_MAP;
+    for (idx = 0; idx < max; idx++) {
+        code = map.indexOf(data.charAt(idx));
+        if (code > 64) {
+            continue;
+        }
+        if (code < 0) {
+            return false;
+        }
+        bitlen += 6;
+    }
+    return (bitlen % 8) === 0;
+}
+function constructYamlBinary(data) {
+    var code, idx, tailbits, input = data.replace(/[\r\n=]/g, ''), max = input.length, map = BASE64_MAP, bits = 0, result = [];
+    for (idx = 0; idx < max; idx++) {
+        if ((idx % 4 === 0) && idx) {
+            result.push((bits >> 16) & 0xFF);
+            result.push((bits >> 8) & 0xFF);
+            result.push(bits & 0xFF);
+        }
+        bits = (bits << 6) | map.indexOf(input.charAt(idx));
+    }
+    tailbits = (max % 4) * 6;
+    if (tailbits === 0) {
+        result.push((bits >> 16) & 0xFF);
+        result.push((bits >> 8) & 0xFF);
+        result.push(bits & 0xFF);
+    }
+    else if (tailbits === 18) {
+        result.push((bits >> 10) & 0xFF);
+        result.push((bits >> 2) & 0xFF);
+    }
+    else if (tailbits === 12) {
+        result.push((bits >> 4) & 0xFF);
+    }
+    if (NodeBuffer) {
+        return new NodeBuffer(result);
+    }
+    return result;
+}
+function representYamlBinary(object) {
+    var result = '', bits = 0, idx, tail, max = object.length, map = BASE64_MAP;
+    for (idx = 0; idx < max; idx++) {
+        if ((idx % 3 === 0) && idx) {
+            result += map[(bits >> 18) & 0x3F];
+            result += map[(bits >> 12) & 0x3F];
+            result += map[(bits >> 6) & 0x3F];
+            result += map[bits & 0x3F];
+        }
+        bits = (bits << 8) + object[idx];
+    }
+    tail = max % 3;
+    if (tail === 0) {
+        result += map[(bits >> 18) & 0x3F];
+        result += map[(bits >> 12) & 0x3F];
+        result += map[(bits >> 6) & 0x3F];
+        result += map[bits & 0x3F];
+    }
+    else if (tail === 2) {
+        result += map[(bits >> 10) & 0x3F];
+        result += map[(bits >> 4) & 0x3F];
+        result += map[(bits << 2) & 0x3F];
+        result += map[64];
+    }
+    else if (tail === 1) {
+        result += map[(bits >> 2) & 0x3F];
+        result += map[(bits << 4) & 0x3F];
+        result += map[64];
+        result += map[64];
+    }
+    return result;
+}
+function isBinary(object) {
+    return NodeBuffer && NodeBuffer.isBuffer(object);
+}
+module.exports = new type_1.Type('tag:yaml.org,2002:binary', {
+    kind: 'scalar',
+    resolve: resolveYamlBinary,
+    construct: constructYamlBinary,
+    predicate: isBinary,
+    represent: representYamlBinary
+});
+//# sourceMappingURL=binary.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/type/bool.js

@@ -0,0 +1,32 @@
+"use strict";
+'use strict';
+var type_1 = require("../type");
+function resolveYamlBoolean(data) {
+    if (null === data) {
+        return false;
+    }
+    var max = data.length;
+    return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) ||
+        (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'));
+}
+function constructYamlBoolean(data) {
+    return data === 'true' ||
+        data === 'True' ||
+        data === 'TRUE';
+}
+function isBoolean(object) {
+    return '[object Boolean]' === Object.prototype.toString.call(object);
+}
+module.exports = new type_1.Type('tag:yaml.org,2002:bool', {
+    kind: 'scalar',
+    resolve: resolveYamlBoolean,
+    construct: constructYamlBoolean,
+    predicate: isBoolean,
+    represent: {
+        lowercase: function (object) { return object ? 'true' : 'false'; },
+        uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; },
+        camelcase: function (object) { return object ? 'True' : 'False'; }
+    },
+    defaultStyle: 'lowercase'
+});
+//# sourceMappingURL=bool.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/type/float.js

@@ -0,0 +1,95 @@
+'use strict';
+var common = require("../common");
+var type_1 = require("../type");
+var YAML_FLOAT_PATTERN = new RegExp('^(?:[-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+][0-9]+)?' +
+    '|\\.[0-9_]+(?:[eE][-+][0-9]+)?' +
+    '|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*' +
+    '|[-+]?\\.(?:inf|Inf|INF)' +
+    '|\\.(?:nan|NaN|NAN))$');
+function resolveYamlFloat(data) {
+    if (null === data) {
+        return false;
+    }
+    var value, sign, base, digits;
+    if (!YAML_FLOAT_PATTERN.test(data)) {
+        return false;
+    }
+    return true;
+}
+function constructYamlFloat(data) {
+    var value, sign, base, digits;
+    value = data.replace(/_/g, '').toLowerCase();
+    sign = '-' === value[0] ? -1 : 1;
+    digits = [];
+    if (0 <= '+-'.indexOf(value[0])) {
+        value = value.slice(1);
+    }
+    if ('.inf' === value) {
+        return (1 === sign) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+    }
+    else if ('.nan' === value) {
+        return NaN;
+    }
+    else if (0 <= value.indexOf(':')) {
+        value.split(':').forEach(function (v) {
+            digits.unshift(parseFloat(v, 10));
+        });
+        value = 0.0;
+        base = 1;
+        digits.forEach(function (d) {
+            value += d * base;
+            base *= 60;
+        });
+        return sign * value;
+    }
+    return sign * parseFloat(value, 10);
+}
+function representYamlFloat(object, style) {
+    if (isNaN(object)) {
+        switch (style) {
+            case 'lowercase':
+                return '.nan';
+            case 'uppercase':
+                return '.NAN';
+            case 'camelcase':
+                return '.NaN';
+        }
+    }
+    else if (Number.POSITIVE_INFINITY === object) {
+        switch (style) {
+            case 'lowercase':
+                return '.inf';
+            case 'uppercase':
+                return '.INF';
+            case 'camelcase':
+                return '.Inf';
+        }
+    }
+    else if (Number.NEGATIVE_INFINITY === object) {
+        switch (style) {
+            case 'lowercase':
+                return '-.inf';
+            case 'uppercase':
+                return '-.INF';
+            case 'camelcase':
+                return '-.Inf';
+        }
+    }
+    else if (common.isNegativeZero(object)) {
+        return '-0.0';
+    }
+    return object.toString(10);
+}
+function isFloat(object) {
+    return ('[object Number]' === Object.prototype.toString.call(object)) &&
+        (0 !== object % 1 || common.isNegativeZero(object));
+}
+module.exports = new type_1.Type('tag:yaml.org,2002:float', {
+    kind: 'scalar',
+    resolve: resolveYamlFloat,
+    construct: constructYamlFloat,
+    predicate: isFloat,
+    represent: representYamlFloat,
+    defaultStyle: 'lowercase'
+});
+//# sourceMappingURL=float.js.map

package/.output/server/node_modules/yaml-ast-parser/dist/src/type/int.js

@@ -0,0 +1,155 @@
+'use strict';
+var common = require("../common");
+var type_1 = require("../type");
+function isHexCode(c) {
+    return ((0x30 <= c) && (c <= 0x39)) ||
+        ((0x41 <= c) && (c <= 0x46)) ||
+        ((0x61 <= c) && (c <= 0x66));
+}
+function isOctCode(c) {
+    return ((0x30 <= c) && (c <= 0x37));
+}
+function isDecCode(c) {
+    return ((0x30 <= c) && (c <= 0x39));
+}
+function resolveYamlInteger(data) {
+    if (null === data) {
+        return false;
+    }
+    var max = data.length, index = 0, hasDigits = false, ch;
+    if (!max) {
+        return false;
+    }
+    ch = data[index];
+    if (ch === '-' || ch === '+') {
+        ch = data[++index];
+    }
+    if (ch === '0') {
+        if (index + 1 === max) {
+            return true;
+        }
+        ch = data[++index];
+        if (ch === 'b') {
+            index++;
+            for (; index < max; index++) {
+                ch = data[index];
+                if (ch === '_') {
+                    continue;
+                }
+                if (ch !== '0' && ch !== '1') {
+                    return false;
+                }
+                hasDigits = true;
+            }
+            return hasDigits;
+        }
+        if (ch === 'x') {
+            index++;
+            for (; index < max; index++) {
+                ch = data[index];
+                if (ch === '_') {
+                    continue;
+                }
+                if (!isHexCode(data.charCodeAt(index))) {
+                    return false;
+                }
+                hasDigits = true;
+            }
+            return hasDigits;
+        }
+        for (; index < max; index++) {
+            ch = data[index];
+            if (ch === '_') {
+                continue;
+            }
+            if (!isOctCode(data.charCodeAt(index))) {
+                return false;
+            }
+            hasDigits = true;
+        }
+        return hasDigits;
+    }
+    for (; index < max; index++) {
+        ch = data[index];
+        if (ch === '_') {
+            continue;
+        }
+        if (ch === ':') {
+            break;
+        }
+        if (!isDecCode(data.charCodeAt(index))) {
+            return false;
+        }
+        hasDigits = true;
+    }
+    if (!hasDigits) {
+        return false;
+    }
+    if (ch !== ':') {
+        return true;
+    }
+    return /^(:[0-5]?[0-9])+$/.test(data.slice(index));
+}
+function constructYamlInteger(data) {
+    var value = data, sign = 1, ch, base, digits = [];
+    if (value.indexOf('_') !== -1) {
+        value = value.replace(/_/g, '');
+    }
+    ch = value[0];
+    if (ch === '-' || ch === '+') {
+        if (ch === '-') {
+            sign = -1;
+        }
+        value = value.slice(1);
+        ch = value[0];
+    }
+    if ('0' === value) {
+        return 0;
+    }
+    if (ch === '0') {
+        if (value[1] === 'b') {
+            return sign * parseInt(value.slice(2), 2);
+        }
+        if (value[1] === 'x') {
+            return sign * parseInt(value, 16);
+        }
+        return sign * parseInt(value, 8);
+    }
+    if (value.indexOf(':') !== -1) {
+        value.split(':').forEach(function (v) {
+            digits.unshift(parseInt(v, 10));
+        });
+        value = 0;
+        base = 1;
+        digits.forEach(function (d) {
+            value += (d * base);
+            base *= 60;
+        });
+        return sign * value;
+    }
+    return sign * parseInt(value, 10);
+}
+function isInteger(object) {
+    return ('[object Number]' === Object.prototype.toString.call(object)) &&
+        (0 === object % 1 && !common.isNegativeZero(object));
+}
+module.exports = new type_1.Type('tag:yaml.org,2002:int', {
+    kind: 'scalar',
+    resolve: resolveYamlInteger,
+    construct: constructYamlInteger,
+    predicate: isInteger,
+    represent: {
+        binary: function (object) { return '0b' + object.toString(2); },
+        octal: function (object) { return '0' + object.toString(8); },
+        decimal: function (object) { return object.toString(10); },
+        hexadecimal: function (object) { return '0x' + object.toString(16).toUpperCase(); }
+    },
+    defaultStyle: 'decimal',
+    styleAliases: {
+        binary: [2, 'bin'],
+        octal: [8, 'oct'],
+        decimal: [10, 'dec'],
+        hexadecimal: [16, 'hex']
+    }
+});
+//# sourceMappingURL=int.js.map