@kubb/agent 5.0.0-alpha.36 → 5.0.0-alpha.38

package/.output/server/node_modules/.nitro/ws@8.20.0/lib/subprotocol.js

@@ -1,62 +0,0 @@
-'use strict';
-
-const { tokenChars } = require('./validation');
-
-/**
- * Parses the `Sec-WebSocket-Protocol` header into a set of subprotocol names.
- *
- * @param {String} header The field value of the header
- * @return {Set} The subprotocol names
- * @public
- */
-function parse(header) {
-  const protocols = new Set();
-  let start = -1;
-  let end = -1;
-  let i = 0;
-
-  for (i; i < header.length; i++) {
-    const code = header.charCodeAt(i);
-
-    if (end === -1 && tokenChars[code] === 1) {
-      if (start === -1) start = i;
-    } else if (
-      i !== 0 &&
-      (code === 0x20 /* ' ' */ || code === 0x09) /* '\t' */
-    ) {
-      if (end === -1 && start !== -1) end = i;
-    } else if (code === 0x2c /* ',' */) {
-      if (start === -1) {
-        throw new SyntaxError(`Unexpected character at index ${i}`);
-      }
-
-      if (end === -1) end = i;
-
-      const protocol = header.slice(start, end);
-
-      if (protocols.has(protocol)) {
-        throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
-      }
-
-      protocols.add(protocol);
-      start = end = -1;
-    } else {
-      throw new SyntaxError(`Unexpected character at index ${i}`);
-    }
-  }
-
-  if (start === -1 || end !== -1) {
-    throw new SyntaxError('Unexpected end of input');
-  }
-
-  const protocol = header.slice(start, i);
-
-  if (protocols.has(protocol)) {
-    throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
-  }
-
-  protocols.add(protocol);
-  return protocols;
-}
-
-module.exports = { parse };

package/.output/server/node_modules/.nitro/ws@8.20.0/lib/validation.js

@@ -1,152 +0,0 @@
-'use strict';
-
-const { isUtf8 } = require('buffer');
-
-const { hasBlob } = require('./constants');
-
-//
-// Allowed token characters:
-//
-// '!', '#', '$', '%', '&', ''', '*', '+', '-',
-// '.', 0-9, A-Z, '^', '_', '`', a-z, '|', '~'
-//
-// tokenChars[32] === 0 // ' '
-// tokenChars[33] === 1 // '!'
-// tokenChars[34] === 0 // '"'
-// ...
-//
-// prettier-ignore
-const tokenChars = [
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 - 15
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31
-  0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, // 32 - 47
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, // 48 - 63
-  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 - 79
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, // 80 - 95
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 - 111
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0 // 112 - 127
-];
-
-/**
- * Checks if a status code is allowed in a close frame.
- *
- * @param {Number} code The status code
- * @return {Boolean} `true` if the status code is valid, else `false`
- * @public
- */
-function isValidStatusCode(code) {
-  return (
-    (code >= 1000 &&
-      code <= 1014 &&
-      code !== 1004 &&
-      code !== 1005 &&
-      code !== 1006) ||
-    (code >= 3000 && code <= 4999)
-  );
-}
-
-/**
- * Checks if a given buffer contains only correct UTF-8.
- * Ported from https://www.cl.cam.ac.uk/%7Emgk25/ucs/utf8_check.c by
- * Markus Kuhn.
- *
- * @param {Buffer} buf The buffer to check
- * @return {Boolean} `true` if `buf` contains only correct UTF-8, else `false`
- * @public
- */
-function _isValidUTF8(buf) {
-  const len = buf.length;
-  let i = 0;
-
-  while (i < len) {
-    if ((buf[i] & 0x80) === 0) {
-      // 0xxxxxxx
-      i++;
-    } else if ((buf[i] & 0xe0) === 0xc0) {
-      // 110xxxxx 10xxxxxx
-      if (
-        i + 1 === len ||
-        (buf[i + 1] & 0xc0) !== 0x80 ||
-        (buf[i] & 0xfe) === 0xc0 // Overlong
-      ) {
-        return false;
-      }
-
-      i += 2;
-    } else if ((buf[i] & 0xf0) === 0xe0) {
-      // 1110xxxx 10xxxxxx 10xxxxxx
-      if (
-        i + 2 >= len ||
-        (buf[i + 1] & 0xc0) !== 0x80 ||
-        (buf[i + 2] & 0xc0) !== 0x80 ||
-        (buf[i] === 0xe0 && (buf[i + 1] & 0xe0) === 0x80) || // Overlong
-        (buf[i] === 0xed && (buf[i + 1] & 0xe0) === 0xa0) // Surrogate (U+D800 - U+DFFF)
-      ) {
-        return false;
-      }
-
-      i += 3;
-    } else if ((buf[i] & 0xf8) === 0xf0) {
-      // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-      if (
-        i + 3 >= len ||
-        (buf[i + 1] & 0xc0) !== 0x80 ||
-        (buf[i + 2] & 0xc0) !== 0x80 ||
-        (buf[i + 3] & 0xc0) !== 0x80 ||
-        (buf[i] === 0xf0 && (buf[i + 1] & 0xf0) === 0x80) || // Overlong
-        (buf[i] === 0xf4 && buf[i + 1] > 0x8f) ||
-        buf[i] > 0xf4 // > U+10FFFF
-      ) {
-        return false;
-      }
-
-      i += 4;
-    } else {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-/**
- * Determines whether a value is a `Blob`.
- *
- * @param {*} value The value to be tested
- * @return {Boolean} `true` if `value` is a `Blob`, else `false`
- * @private
- */
-function isBlob(value) {
-  return (
-    hasBlob &&
-    typeof value === 'object' &&
-    typeof value.arrayBuffer === 'function' &&
-    typeof value.type === 'string' &&
-    typeof value.stream === 'function' &&
-    (value[Symbol.toStringTag] === 'Blob' ||
-      value[Symbol.toStringTag] === 'File')
-  );
-}
-
-module.exports = {
-  isBlob,
-  isValidStatusCode,
-  isValidUTF8: _isValidUTF8,
-  tokenChars
-};
-
-if (isUtf8) {
-  module.exports.isValidUTF8 = function (buf) {
-    return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);
-  };
-} /* istanbul ignore else  */ else if (!process.env.WS_NO_UTF_8_VALIDATE) {
-  try {
-    const isValidUTF8 = require('utf-8-validate');
-
-    module.exports.isValidUTF8 = function (buf) {
-      return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
-    };
-  } catch (e) {
-    // Continue regardless of the error.
-  }
-}

package/.output/server/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/bundle.js

@@ -1,302 +0,0 @@
-"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 });
-const ref_js_1 = __importDefault(require("./ref.js"));
-const pointer_js_1 = __importDefault(require("./pointer.js"));
-const url = __importStar(require("./util/url.js"));
-/**
- * Bundles all external JSON references into the main JSON schema, thus resulting in a schema that
- * only has *internal* references, not any *external* references.
- * This method mutates the JSON schema object, adding new references and re-mapping existing ones.
- *
- * @param parser
- * @param options
- */
-function bundle(parser, options) {
-    // console.log('Bundling $ref pointers in %s', parser.$refs._root$Ref.path);
-    // Build an inventory of all $ref pointers in the JSON Schema
-    const inventory = [];
-    crawl(parser, "schema", parser.$refs._root$Ref.path + "#", "#", 0, inventory, parser.$refs, options);
-    // Remap all $ref pointers
-    remap(inventory);
-}
-/**
- * Recursively crawls the given value, and inventories all JSON references.
- *
- * @param parent - The object containing the value to crawl. If the value is not an object or array, it will be ignored.
- * @param key - The property key of `parent` to be crawled
- * @param path - The full path of the property being crawled, possibly with a JSON Pointer in the hash
- * @param pathFromRoot - The path of the property being crawled, from the schema root
- * @param indirections
- * @param inventory - An array of already-inventoried $ref pointers
- * @param $refs
- * @param options
- */
-function crawl(parent, key, path, pathFromRoot, indirections, inventory, $refs, options) {
-    const obj = key === null ? parent : parent[key];
-    const bundleOptions = (options.bundle || {});
-    const isExcludedPath = bundleOptions.excludedPathMatcher || (() => false);
-    if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj) && !isExcludedPath(pathFromRoot)) {
-        if (ref_js_1.default.isAllowed$Ref(obj)) {
-            inventory$Ref(parent, key, path, pathFromRoot, indirections, inventory, $refs, options);
-        }
-        else {
-            // Crawl the object in a specific order that's optimized for bundling.
-            // This is important because it determines how `pathFromRoot` gets built,
-            // which later determines which keys get dereferenced and which ones get remapped
-            const keys = Object.keys(obj).sort((a, b) => {
-                // Most people will expect references to be bundled into the the "definitions" property,
-                // so we always crawl that property first, if it exists.
-                if (a === "definitions" || a === "$defs") {
-                    return -1;
-                }
-                else if (b === "definitions" || b === "$defs") {
-                    return 1;
-                }
-                else {
-                    // Otherwise, crawl the keys based on their length.
-                    // This produces the shortest possible bundled references
-                    return a.length - b.length;
-                }
-            });
-            for (const key of keys) {
-                const keyPath = pointer_js_1.default.join(path, key);
-                const keyPathFromRoot = pointer_js_1.default.join(pathFromRoot, key);
-                const value = obj[key];
-                if (ref_js_1.default.isAllowed$Ref(value)) {
-                    inventory$Ref(obj, key, path, keyPathFromRoot, indirections, inventory, $refs, options);
-                }
-                else {
-                    crawl(obj, key, keyPath, keyPathFromRoot, indirections, inventory, $refs, options);
-                }
-                // We need to ensure that we have an object to work with here because we may be crawling
-                // an `examples` schema and `value` may be nullish.
-                if (value && typeof value === "object" && !Array.isArray(value)) {
-                    if ("$ref" in value) {
-                        bundleOptions?.onBundle?.(value["$ref"], obj[key], obj, key);
-                    }
-                }
-            }
-        }
-    }
-}
-/**
- * Inventories the given JSON Reference (i.e. records detailed information about it so we can
- * optimize all $refs in the schema), and then crawls the resolved value.
- *
- * @param $refParent - The object that contains a JSON Reference as one of its keys
- * @param $refKey - The key in `$refParent` that is a JSON Reference
- * @param path - The full path of the JSON Reference at `$refKey`, possibly with a JSON Pointer in the hash
- * @param indirections - unknown
- * @param pathFromRoot - The path of the JSON Reference at `$refKey`, from the schema root
- * @param inventory - An array of already-inventoried $ref pointers
- * @param $refs
- * @param options
- */
-function inventory$Ref($refParent, $refKey, path, pathFromRoot, indirections, inventory, $refs, options) {
-    const $ref = $refKey === null ? $refParent : $refParent[$refKey];
-    const $refPath = url.resolve(path, $ref.$ref);
-    const pointer = $refs._resolve($refPath, pathFromRoot, options);
-    if (pointer === null) {
-        return;
-    }
-    const parsed = pointer_js_1.default.parse(pathFromRoot);
-    const depth = parsed.length;
-    const file = url.stripHash(pointer.path);
-    const hash = url.getHash(pointer.path);
-    const external = file !== $refs._root$Ref.path;
-    const extended = ref_js_1.default.isExtended$Ref($ref);
-    indirections += pointer.indirections;
-    const existingEntry = findInInventory(inventory, $refParent, $refKey);
-    if (existingEntry) {
-        // This $Ref has already been inventoried, so we don't need to process it again
-        if (depth < existingEntry.depth || indirections < existingEntry.indirections) {
-            removeFromInventory(inventory, existingEntry);
-        }
-        else {
-            return;
-        }
-    }
-    inventory.push({
-        $ref, // The JSON Reference (e.g. {$ref: string})
-        parent: $refParent, // The object that contains this $ref pointer
-        key: $refKey, // The key in `parent` that is the $ref pointer
-        pathFromRoot, // The path to the $ref pointer, from the JSON Schema root
-        depth, // How far from the JSON Schema root is this $ref pointer?
-        file, // The file that the $ref pointer resolves to
-        hash, // The hash within `file` that the $ref pointer resolves to
-        value: pointer.value, // The resolved value of the $ref pointer
-        circular: pointer.circular, // Is this $ref pointer DIRECTLY circular? (i.e. it references itself)
-        extended, // Does this $ref extend its resolved value? (i.e. it has extra properties, in addition to "$ref")
-        external, // Does this $ref pointer point to a file other than the main JSON Schema file?
-        indirections, // The number of indirect references that were traversed to resolve the value
-    });
-    // Recursively crawl the resolved value
-    if (!existingEntry || external) {
-        crawl(pointer.value, null, pointer.path, pathFromRoot, indirections + 1, inventory, $refs, options);
-    }
-}
-/**
- * Re-maps every $ref pointer, so that they're all relative to the root of the JSON Schema.
- * Each referenced value is dereferenced EXACTLY ONCE.  All subsequent references to the same
- * value are re-mapped to point to the first reference.
- *
- * @example: {
- *    first: { $ref: somefile.json#/some/part },
- *    second: { $ref: somefile.json#/another/part },
- *    third: { $ref: somefile.json },
- *    fourth: { $ref: somefile.json#/some/part/sub/part }
- *  }
- *
- * In this example, there are four references to the same file, but since the third reference points
- * to the ENTIRE file, that's the only one we need to dereference.  The other three can just be
- * remapped to point inside the third one.
- *
- * On the other hand, if the third reference DIDN'T exist, then the first and second would both need
- * to be dereferenced, since they point to different parts of the file. The fourth reference does NOT
- * need to be dereferenced, because it can be remapped to point inside the first one.
- *
- * @param inventory
- */
-function remap(inventory) {
-    // Group & sort all the $ref pointers, so they're in the order that we need to dereference/remap them
-    inventory.sort((a, b) => {
-        if (a.file !== b.file) {
-            // Group all the $refs that point to the same file
-            return a.file < b.file ? -1 : +1;
-        }
-        else if (a.hash !== b.hash) {
-            // Group all the $refs that point to the same part of the file
-            return a.hash < b.hash ? -1 : +1;
-        }
-        else if (a.circular !== b.circular) {
-            // If the $ref points to itself, then sort it higher than other $refs that point to this $ref
-            return a.circular ? -1 : +1;
-        }
-        else if (a.extended !== b.extended) {
-            // If the $ref extends the resolved value, then sort it lower than other $refs that don't extend the value
-            return a.extended ? +1 : -1;
-        }
-        else if (a.indirections !== b.indirections) {
-            // Sort direct references higher than indirect references
-            return a.indirections - b.indirections;
-        }
-        else if (a.depth !== b.depth) {
-            // Sort $refs by how close they are to the JSON Schema root
-            return a.depth - b.depth;
-        }
-        else {
-            // Determine how far each $ref is from the "definitions" property.
-            // Most people will expect references to be bundled into the the "definitions" property if possible.
-            const aDefinitionsIndex = Math.max(a.pathFromRoot.lastIndexOf("/definitions"), a.pathFromRoot.lastIndexOf("/$defs"));
-            const bDefinitionsIndex = Math.max(b.pathFromRoot.lastIndexOf("/definitions"), b.pathFromRoot.lastIndexOf("/$defs"));
-            if (aDefinitionsIndex !== bDefinitionsIndex) {
-                // Give higher priority to the $ref that's closer to the "definitions" property
-                return bDefinitionsIndex - aDefinitionsIndex;
-            }
-            else {
-                // All else is equal, so use the shorter path, which will produce the shortest possible reference
-                return a.pathFromRoot.length - b.pathFromRoot.length;
-            }
-        }
-    });
-    let file, hash, pathFromRoot;
-    for (const entry of inventory) {
-        // console.log('Re-mapping $ref pointer "%s" at %s', entry.$ref.$ref, entry.pathFromRoot);
-        if (!entry.external) {
-            // This $ref already resolves to the main JSON Schema file
-            entry.$ref.$ref = entry.hash;
-        }
-        else if (entry.file === file && entry.hash === hash) {
-            // This $ref points to the same value as the prevous $ref, so remap it to the same path
-            entry.$ref.$ref = pathFromRoot;
-        }
-        else if (entry.file === file && entry.hash.indexOf(hash + "/") === 0) {
-            // This $ref points to a sub-value of the prevous $ref, so remap it beneath that path
-            entry.$ref.$ref = pointer_js_1.default.join(pathFromRoot, pointer_js_1.default.parse(entry.hash.replace(hash, "#")));
-        }
-        else {
-            // We've moved to a new file or new hash
-            file = entry.file;
-            hash = entry.hash;
-            pathFromRoot = entry.pathFromRoot;
-            // This is the first $ref to point to this value, so dereference the value.
-            // Any other $refs that point to the same value will point to this $ref instead
-            entry.$ref = entry.parent[entry.key] = ref_js_1.default.dereference(entry.$ref, entry.value);
-            if (entry.circular) {
-                // This $ref points to itself
-                entry.$ref.$ref = entry.pathFromRoot;
-            }
-        }
-    }
-    // we want to ensure that any $refs that point to another $ref are remapped to point to the final value
-    // let hadChange = true;
-    // while (hadChange) {
-    //   hadChange = false;
-    //   for (const entry of inventory) {
-    //     if (entry.$ref && typeof entry.$ref === "object" && "$ref" in entry.$ref) {
-    //       const resolved = inventory.find((e: InventoryEntry) => e.pathFromRoot === entry.$ref.$ref);
-    //       if (resolved) {
-    //         const resolvedPointsToAnotherRef =
-    //           resolved.$ref && typeof resolved.$ref === "object" && "$ref" in resolved.$ref;
-    //         if (resolvedPointsToAnotherRef && entry.$ref.$ref !== resolved.$ref.$ref) {
-    //           // console.log('Re-mapping $ref pointer "%s" at %s', entry.$ref.$ref, entry.pathFromRoot);
-    //           entry.$ref.$ref = resolved.$ref.$ref;
-    //           hadChange = true;
-    //         }
-    //       }
-    //     }
-    //   }
-    // }
-}
-/**
- * TODO
- */
-function findInInventory(inventory, $refParent, $refKey) {
-    for (const existingEntry of inventory) {
-        if (existingEntry && existingEntry.parent === $refParent && existingEntry.key === $refKey) {
-            return existingEntry;
-        }
-    }
-    return undefined;
-}
-function removeFromInventory(inventory, entry) {
-    const index = inventory.indexOf(entry);
-    inventory.splice(index, 1);
-}
-exports.default = bundle;