@kubb/agent 4.33.1 → 4.33.2

package/.output/server/node_modules/@redocly/openapi-core/lib/format/codeframes.js

@@ -0,0 +1,177 @@
+import * as yamlAst from 'yaml-ast-parser';
+import { colorize, colorOptions } from '../logger.js';
+import { parsePointer } from '../ref-utils.js';
+const MAX_LINE_LENGTH = 150;
+const MAX_CODEFRAME_LINES = 3;
+export function getCodeframe(location, color) {
+    colorOptions.enabled = color;
+    const { start, end = { line: start.line, col: start.col + 1 }, source } = location;
+    const lines = source.getLines();
+    const startLineNum = start.line;
+    const endLineNum = Math.max(Math.min(end.line, lines.length), start.line);
+    let skipLines = Math.max(endLineNum - startLineNum - MAX_CODEFRAME_LINES + 1, 0);
+    if (skipLines < 2)
+        skipLines = 0; // do not skip one line
+    // Lines specified like this: ["prefix", "string"],
+    const prefixedLines = [];
+    let currentPad = 0;
+    for (let i = startLineNum; i <= endLineNum; i++) {
+        if (skipLines > 0 && i >= endLineNum - skipLines)
+            break;
+        const line = lines[i - 1] || '';
+        if (line !== '')
+            currentPad = padSize(line);
+        const startIdx = i === startLineNum ? start.col - 1 : currentPad;
+        const endIdx = i === endLineNum ? end.col - 1 : line.length;
+        prefixedLines.push([`${i}`, markLine(line, startIdx, endIdx, colorize.red)]);
+        if (!color)
+            prefixedLines.push(['', underlineLine(line, startIdx, endIdx)]);
+    }
+    if (skipLines > 0) {
+        prefixedLines.push([
+            `…`,
+            `${whitespace(currentPad)}${colorize.gray(`< ${skipLines} more lines >`)}`,
+        ]);
+        // print last line
+        prefixedLines.push([
+            `${endLineNum}`,
+            markLine(lines[endLineNum - 1], -1, end.col - 1, colorize.red),
+        ]);
+        if (!color)
+            prefixedLines.push(['', underlineLine(lines[endLineNum - 1], -1, end.col - 1)]);
+    }
+    return printPrefixedLines([
+        [`${startLineNum - 2}`, markLine(lines[startLineNum - 1 - 2])],
+        [`${startLineNum - 1}`, markLine(lines[startLineNum - 1 - 1])],
+        ...prefixedLines,
+        [`${endLineNum + 1}`, markLine(lines[endLineNum - 1 + 1])],
+        [`${endLineNum + 2}`, markLine(lines[endLineNum - 1 + 2])],
+    ]);
+    function markLine(line, startIdx = -1, endIdx = +Infinity, variant = colorize.gray) {
+        if (!color)
+            return line;
+        if (!line)
+            return line;
+        if (startIdx === -1) {
+            startIdx = padSize(line);
+        }
+        endIdx = Math.min(endIdx, line.length);
+        return (line.substr(0, startIdx) + variant(line.substring(startIdx, endIdx)) + line.substr(endIdx));
+    }
+}
+function printPrefixedLines(lines) {
+    const existingLines = lines.filter(([_, line]) => line !== undefined);
+    const padLen = Math.max(...existingLines.map(([prefix]) => prefix.length));
+    const dedentLen = Math.min(...existingLines.map(([_, line]) => (line === '' ? Infinity : padSize(line))));
+    return existingLines
+        .map(([prefix, line]) => colorize.gray(leftPad(padLen, prefix) + ' |') +
+        (line ? ' ' + limitLineLength(line.substring(dedentLen)) : ''))
+        .join('\n');
+}
+function limitLineLength(line, maxLen = MAX_LINE_LENGTH) {
+    const overflowLen = line.length - maxLen;
+    if (overflowLen > 0) {
+        const charsMoreText = colorize.gray(`...<${overflowLen} chars>`);
+        return line.substring(0, maxLen - charsMoreText.length) + charsMoreText;
+    }
+    else {
+        return line;
+    }
+}
+function underlineLine(line, startIdx = -1, endIdx = +Infinity) {
+    if (startIdx === -1) {
+        startIdx = padSize(line);
+    }
+    endIdx = Math.min(endIdx, line.length);
+    return whitespace(startIdx) + '^'.repeat(Math.max(endIdx - startIdx, 1));
+}
+function whitespace(len) {
+    return ' '.repeat(len);
+}
+function leftPad(len, str) {
+    return whitespace(len - str.length) + str;
+}
+function padSize(line) {
+    for (let i = 0; i < line.length; i++) {
+        if (line[i] !== ' ')
+            return i;
+    }
+    return line.length;
+}
+export function getLineColLocation(location) {
+    if (location.pointer === undefined)
+        return location;
+    const { source, pointer, reportOnKey } = location;
+    const ast = source.getAst(yamlAst.safeLoad);
+    const astNode = getAstNodeByPointer(ast, pointer, !!reportOnKey);
+    return {
+        ...location,
+        pointer: undefined,
+        ...positionsToLoc(source.body, astNode?.startPosition ?? 1, astNode?.endPosition ?? 1),
+    };
+}
+function positionsToLoc(source, startPos, endPos) {
+    let currentLine = 1;
+    let currentCol = 1;
+    let start = { line: 1, col: 1 };
+    for (let i = 0; i < endPos - 1; i++) {
+        if (i === startPos - 1) {
+            start = { line: currentLine, col: currentCol + 1 };
+        }
+        if (source[i] === '\n') {
+            currentLine++;
+            currentCol = 1;
+            if (i === startPos - 1) {
+                start = { line: currentLine, col: currentCol };
+            }
+            if (source[i + 1] === '\r')
+                i++; // TODO: test it
+            continue;
+        }
+        currentCol++;
+    }
+    const end = startPos === endPos ? { ...start } : { line: currentLine, col: currentCol + 1 };
+    return { start, end };
+}
+export function getAstNodeByPointer(root, pointer, reportOnKey) {
+    const pointerSegments = parsePointer(pointer.substr(2));
+    if (root === undefined) {
+        return undefined;
+    }
+    let currentNode = root;
+    for (const key of pointerSegments) {
+        if (currentNode.kind === yamlAst.Kind.MAP) {
+            const mapping = currentNode.mappings.find((m) => m.key.value === key);
+            if (!mapping)
+                break;
+            currentNode = mapping;
+            if (!mapping?.value)
+                break; // If node has value - return value, if not - return node itself
+            currentNode = mapping.value;
+        }
+        else if (currentNode.kind === yamlAst.Kind.SEQ) {
+            const elem = currentNode.items[parseInt(key, 10)];
+            if (!elem)
+                break;
+            currentNode = elem;
+        }
+    }
+    if (!reportOnKey) {
+        return currentNode;
+    }
+    else {
+        const parent = currentNode.parent;
+        if (!parent)
+            return currentNode;
+        if (parent.kind === yamlAst.Kind.SEQ) {
+            return currentNode;
+        }
+        else if (parent.kind === yamlAst.Kind.MAPPING) {
+            return parent.key;
+        }
+        else {
+            return currentNode;
+        }
+    }
+}
+//# sourceMappingURL=codeframes.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/format/format.js

@@ -0,0 +1,365 @@
+import * as path from 'node:path';
+import { env, isBrowser } from '../env.js';
+import { colorOptions, colorize, logger } from '../logger.js';
+import { isAbsoluteUrl } from '../ref-utils.js';
+import { getCodeframe, getLineColLocation } from './codeframes.js';
+const ERROR_MESSAGE = {
+    INVALID_SEVERITY_LEVEL: 'Invalid severity level; accepted values: error or warn',
+};
+const BG_COLORS = {
+    warn: (str) => colorize.bgYellow(colorize.black(str)),
+    error: colorize.bgRed,
+};
+const COLORS = {
+    warn: colorize.yellow,
+    error: colorize.red,
+};
+const SEVERITY_NAMES = {
+    warn: 'Warning',
+    error: 'Error',
+};
+const CODECLIMATE_SEVERITY_MAPPING = {
+    error: 'critical',
+    warn: 'minor',
+};
+const MAX_SUGGEST = +(env.REDOCLY_CLI_LINT_MAX_SUGGESTIONS ?? 5);
+function severityToNumber(severity) {
+    return severity === 'error' ? 1 : 2;
+}
+export function getTotals(problems) {
+    let errors = 0;
+    let warnings = 0;
+    let ignored = 0;
+    for (const m of problems) {
+        if (m.ignored) {
+            ignored++;
+            continue;
+        }
+        if (m.severity === 'error')
+            errors++;
+        if (m.severity === 'warn')
+            warnings++;
+    }
+    return {
+        errors,
+        warnings,
+        ignored,
+    };
+}
+export function formatProblems(problems, opts) {
+    const { maxProblems = 100, cwd = isBrowser ? '' : process.cwd(), format = 'codeframe', color = colorOptions.enabled, totals = getTotals(problems), version = '2.0', command, } = opts;
+    colorOptions.enabled = color; // force colors if specified
+    const totalProblems = problems.length;
+    problems = problems.filter((m) => !m.ignored);
+    const ignoredProblems = totalProblems - problems.length;
+    problems = problems
+        .sort((a, b) => severityToNumber(a.severity) - severityToNumber(b.severity))
+        .slice(0, maxProblems);
+    if (!totalProblems && format !== 'json')
+        return;
+    switch (format) {
+        case 'json':
+            outputJSON();
+            break;
+        case 'codeframe':
+            for (let i = 0; i < problems.length; i++) {
+                const problem = problems[i];
+                if (command === 'bundle') {
+                    logger.info(`${formatCodeframe(problem, i)}\n`);
+                }
+                else {
+                    logger.output(`${formatCodeframe(problem, i)}\n`);
+                }
+            }
+            break;
+        case 'stylish': {
+            const groupedByFile = groupByFiles(problems);
+            for (const [file, { ruleIdPad, locationPad: positionPad, fileProblems }] of Object.entries(groupedByFile)) {
+                logger.output(`${colorize.blue(isAbsoluteUrl(file) ? file : path.relative(cwd, file))}:\n`);
+                for (let i = 0; i < fileProblems.length; i++) {
+                    const problem = fileProblems[i];
+                    logger.output(`${formatStylish(problem, positionPad, ruleIdPad)}\n`);
+                }
+                logger.output('\n');
+            }
+            break;
+        }
+        case 'markdown': {
+            const groupedByFile = groupByFiles(problems);
+            for (const [file, { fileProblems }] of Object.entries(groupedByFile)) {
+                logger.output(`## Lint: ${isAbsoluteUrl(file) ? file : path.relative(cwd, file)}\n\n`);
+                logger.output(`| Severity | Location | Problem | Message |\n`);
+                logger.output(`|---|---|---|---|\n`);
+                for (let i = 0; i < fileProblems.length; i++) {
+                    const problem = fileProblems[i];
+                    logger.output(`${formatMarkdown(problem)}\n`);
+                }
+                logger.output('\n');
+                if (totals.errors > 0) {
+                    logger.output(`Validation failed\nErrors: ${totals.errors}\n`);
+                }
+                else {
+                    logger.output('Validation successful\n');
+                }
+                if (totals.warnings > 0) {
+                    logger.output(`Warnings: ${totals.warnings}\n`);
+                }
+                logger.output('\n');
+            }
+            break;
+        }
+        case 'checkstyle': {
+            const groupedByFile = groupByFiles(problems);
+            logger.output('<?xml version="1.0" encoding="UTF-8"?>\n');
+            logger.output('<checkstyle version="4.3">\n');
+            for (const [file, { fileProblems }] of Object.entries(groupedByFile)) {
+                logger.output(`<file name="${xmlEscape(isAbsoluteUrl(file) ? file : path.relative(cwd, file))}">\n`);
+                fileProblems.forEach(formatCheckstyle);
+                logger.output(`</file>\n`);
+            }
+            logger.output(`</checkstyle>\n`);
+            break;
+        }
+        case 'codeclimate':
+            outputForCodeClimate();
+            break;
+        case 'summary':
+            formatSummary(problems);
+            break;
+        case 'github-actions':
+            outputForGithubActions(problems, cwd);
+    }
+    if (totalProblems - ignoredProblems > maxProblems) {
+        logger.info(`< ... ${totalProblems - maxProblems} more problems hidden > ${colorize.gray('increase with `--max-problems N`')}\n`);
+    }
+    function outputForCodeClimate() {
+        const issues = problems.map((p) => {
+            const location = p.location[0]; // TODO: support multiple location
+            const lineCol = getLineColLocation(location);
+            return {
+                description: p.message,
+                location: {
+                    path: isAbsoluteUrl(location.source.absoluteRef)
+                        ? location.source.absoluteRef
+                        : path.relative(cwd, location.source.absoluteRef),
+                    lines: {
+                        begin: lineCol.start.line,
+                    },
+                },
+                severity: CODECLIMATE_SEVERITY_MAPPING[p.severity],
+                fingerprint: `${p.ruleId}${p.location.length > 0 ? '-' + p.location[0].pointer : ''}`,
+            };
+        });
+        logger.output(JSON.stringify(issues, null, 2));
+    }
+    function outputJSON() {
+        const resultObject = {
+            totals,
+            version,
+            problems: problems.map((p) => {
+                const problem = {
+                    ...p,
+                    location: p.location.map((location) => ({
+                        ...location,
+                        source: {
+                            ref: isAbsoluteUrl(location.source.absoluteRef)
+                                ? location.source.absoluteRef
+                                : path.relative(cwd, location.source.absoluteRef),
+                        },
+                    })),
+                    from: p.from
+                        ? {
+                            ...p.from,
+                            source: {
+                                ref: isAbsoluteUrl(p.from?.source.absoluteRef)
+                                    ? p.from?.source.absoluteRef
+                                    : path.relative(cwd, p.from?.source.absoluteRef || cwd),
+                            },
+                        }
+                        : undefined,
+                };
+                if (env.FORMAT_JSON_WITH_CODEFRAMES) {
+                    const location = p.location[0]; // TODO: support multiple locations
+                    const loc = getLineColLocation(location);
+                    problem.codeframe = getCodeframe(loc, color);
+                }
+                return problem;
+            }),
+        };
+        logger.output(JSON.stringify(resultObject, null, 2));
+    }
+    function getBgColor(problem) {
+        const { severity } = problem;
+        if (!BG_COLORS[severity]) {
+            throw new Error(ERROR_MESSAGE.INVALID_SEVERITY_LEVEL);
+        }
+        return BG_COLORS[severity];
+    }
+    function formatCodeframe(problem, idx) {
+        const bgColor = getBgColor(problem);
+        const location = problem.location[0]; // TODO: support multiple locations
+        const relativePath = isAbsoluteUrl(location.source.absoluteRef)
+            ? location.source.absoluteRef
+            : path.relative(cwd, location.source.absoluteRef);
+        const loc = getLineColLocation(location);
+        const atPointer = location.pointer ? colorize.gray(`at ${location.pointer}`) : '';
+        const fileWithLoc = `${relativePath}:${loc.start.line}:${loc.start.col}`;
+        return (`[${idx + 1}] ${bgColor(fileWithLoc)} ${atPointer}\n\n` +
+            `${problem.message}\n\n` +
+            formatDidYouMean(problem) +
+            getCodeframe(loc, color) +
+            '\n\n' +
+            formatFrom(cwd, problem.from) +
+            `${SEVERITY_NAMES[problem.severity]} was generated by the ${colorize.blue(problem.ruleId)} rule.\n\n`);
+    }
+    function formatStylish(problem, locationPad, ruleIdPad) {
+        const color = COLORS[problem.severity];
+        if (!SEVERITY_NAMES[problem.severity]) {
+            return 'Error not found severity. Please check your config file. Allowed values: `warn,error,off`';
+        }
+        const severityName = color(SEVERITY_NAMES[problem.severity].toLowerCase().padEnd(7));
+        const { start } = problem.location[0];
+        return `  ${`${start.line}:${start.col}`.padEnd(locationPad)}  ${severityName}  ${problem.ruleId.padEnd(ruleIdPad)}  ${problem.message}`;
+    }
+    function formatMarkdown(problem) {
+        if (!SEVERITY_NAMES[problem.severity]) {
+            return 'Error not found severity. Please check your config file. Allowed values: `warn,error,off`';
+        }
+        const severityName = SEVERITY_NAMES[problem.severity].toLowerCase();
+        const { start } = problem.location[0];
+        return `| ${severityName} | line ${`${start.line}:${start.col}`} | [${problem.ruleId}](https://redocly.com/docs/cli/rules/${problem.ruleId}/) | ${problem.message.replaceAll('\n', '<br>')} |`;
+    }
+    function formatCheckstyle(problem) {
+        const { line, col } = problem.location[0].start;
+        const severity = problem.severity == 'warn' ? 'warning' : 'error';
+        const message = xmlEscape(problem.message);
+        const source = xmlEscape(problem.ruleId);
+        logger.output(`<error line="${line}" column="${col}" severity="${severity}" message="${message}" source="${source}" />\n`);
+    }
+}
+function formatSummary(problems) {
+    const counts = {};
+    for (const problem of problems) {
+        counts[problem.ruleId] = counts[problem.ruleId] || { count: 0, severity: problem.severity };
+        counts[problem.ruleId].count++;
+    }
+    const sorted = Object.entries(counts).sort(([, a], [, b]) => {
+        const severityDiff = severityToNumber(a.severity) - severityToNumber(b.severity);
+        return severityDiff || b.count - a.count;
+    });
+    for (const [ruleId, info] of sorted) {
+        const color = COLORS[info.severity];
+        const severityName = color(SEVERITY_NAMES[info.severity].toLowerCase().padEnd(7));
+        logger.output(`${severityName} ${ruleId}: ${info.count}\n`);
+    }
+    logger.output('\n');
+}
+function formatFrom(cwd, location) {
+    if (!location)
+        return '';
+    const relativePath = path.relative(cwd, location.source.absoluteRef);
+    const loc = getLineColLocation(location);
+    const fileWithLoc = `${relativePath}:${loc.start.line}:${loc.start.col}`;
+    const atPointer = location.pointer ? colorize.gray(`at ${location.pointer}`) : '';
+    return `referenced from ${colorize.blue(fileWithLoc)} ${atPointer} \n\n`;
+}
+function formatDidYouMean(problem) {
+    if (problem.suggest.length === 0)
+        return '';
+    if (problem.suggest.length === 1) {
+        return `Did you mean: ${problem.suggest[0]} ?\n\n`;
+    }
+    else {
+        return `Did you mean:\n  - ${problem.suggest.slice(0, MAX_SUGGEST).join('\n  - ')}\n\n`;
+    }
+}
+const groupByFiles = (problems) => {
+    const fileGroups = {};
+    for (const problem of problems) {
+        const absoluteRef = problem.location[0].source.absoluteRef; // TODO: multiple errors
+        fileGroups[absoluteRef] = fileGroups[absoluteRef] || {
+            fileProblems: [],
+            ruleIdPad: 0,
+            locationPad: 0,
+        };
+        const mappedProblem = { ...problem, location: problem.location.map(getLineColLocation) };
+        fileGroups[absoluteRef].fileProblems.push(mappedProblem);
+        fileGroups[absoluteRef].ruleIdPad = Math.max(problem.ruleId.length, fileGroups[absoluteRef].ruleIdPad);
+        fileGroups[absoluteRef].locationPad = Math.max(Math.max(...mappedProblem.location.map((loc) => `${loc.start.line}:${loc.start.col}`.length)), fileGroups[absoluteRef].locationPad);
+    }
+    return fileGroups;
+};
+function xmlEscape(s) {
+    // eslint-disable-next-line no-control-regex
+    return s.replace(/[<>&"'\x00-\x1F\x7F\u0080-\uFFFF]/gu, (char) => {
+        switch (char) {
+            case '<':
+                return '&lt;';
+            case '>':
+                return '&gt;';
+            case '&':
+                return '&amp;';
+            case '"':
+                return '&quot;';
+            case "'":
+                return '&apos;';
+            default:
+                return `&#${char.charCodeAt(0)};`;
+        }
+    });
+}
+function outputForGithubActions(problems, cwd) {
+    for (const problem of problems) {
+        for (const location of problem.location.map(getLineColLocation)) {
+            let command;
+            switch (problem.severity) {
+                case 'error':
+                    command = 'error';
+                    break;
+                case 'warn':
+                    command = 'warning';
+                    break;
+            }
+            const suggest = formatDidYouMean(problem);
+            const message = suggest !== '' ? problem.message + '\n\n' + suggest : problem.message;
+            const properties = {
+                title: problem.ruleId,
+                file: isAbsoluteUrl(location.source.absoluteRef)
+                    ? location.source.absoluteRef
+                    : path.relative(cwd, location.source.absoluteRef),
+                line: location.start.line,
+                col: location.start.col,
+                endLine: location.end?.line,
+                endColumn: location.end?.col,
+            };
+            logger.output(`::${command} ${formatProperties(properties)}::${escapeMessage(message)}\n`);
+        }
+    }
+    function formatProperties(props) {
+        return Object.entries(props)
+            .filter(([, v]) => v !== null && v !== undefined)
+            .map(([k, v]) => `${k}=${escapeProperty(v)}`)
+            .join(',');
+    }
+    function toString(v) {
+        if (v === null || v === undefined) {
+            return '';
+        }
+        else if (typeof v === 'string' || v instanceof String) {
+            return v;
+        }
+        return JSON.stringify(v);
+    }
+    function escapeMessage(v) {
+        return toString(v).replace(/%/g, '%25').replace(/\r/g, '%0D').replace(/\n/g, '%0A');
+    }
+    function escapeProperty(v) {
+        return toString(v)
+            .replace(/%/g, '%25')
+            .replace(/\r/g, '%0D')
+            .replace(/\n/g, '%0A')
+            .replace(/:/g, '%3A')
+            .replace(/,/g, '%2C');
+    }
+}
+//# sourceMappingURL=format.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/index.js

@@ -0,0 +1,49 @@
+export { doesYamlFileExist } from './utils/does-yaml-file-exist.js';
+export { dequal } from './utils/dequal.js';
+export { isEmptyObject } from './utils/is-empty-object.js';
+export { isNotEmptyArray } from './utils/is-not-empty-array.js';
+export { isNotEmptyObject } from './utils/is-not-empty-object.js';
+export { isPlainObject } from './utils/is-plain-object.js';
+export { isString } from './utils/is-string.js';
+export { isTruthy } from './utils/is-truthy.js';
+export { keysOf } from './utils/keys-of.js';
+export { pause } from './utils/pause.js';
+export { pluralize } from './utils/pluralize.js';
+export { readFileFromUrl } from './utils/read-file-from-url.js';
+export { slash } from './utils/slash.js';
+export { Oas2Types } from './types/oas2.js';
+export { Oas3Types } from './types/oas3.js';
+export { Oas3_1Types } from './types/oas3_1.js';
+export { Oas3_2Types } from './types/oas3_2.js';
+export { AsyncApi2Types } from './types/asyncapi2.js';
+export { AsyncApi3Types } from './types/asyncapi3.js';
+export { Arazzo1Types } from './types/arazzo.js';
+export { Overlay1Types } from './types/overlay.js';
+export { OpenRpcTypes } from './types/openrpc.js';
+export { ConfigTypes, createConfigTypes } from './types/redocly-yaml.js';
+export { createEntityTypes } from './types/entity.js';
+export { normalizeTypes } from './types/index.js';
+export { StatsOAS, StatsAsync2, StatsAsync3 } from './rules/other/stats.js';
+export { loadConfig, loadIgnoreConfig, createConfig, findConfig, resolvePlugins, ConfigValidationError, Config, // FIXME: export it as a type
+ } from './config/index.js';
+export * from './config/constants.js';
+export { Source, BaseResolver, ResolveError, resolveDocument, makeDocumentFromString, } from './resolve.js';
+export { YamlParseError } from './errors/yaml-parse-error.js';
+export { parseYaml, stringifyYaml } from './js-yaml/index.js';
+export { unescapePointerFragment, isRef, isAbsoluteUrl, getDir, resolvePath, escapePointerFragment, } from './ref-utils.js';
+export { detectSpec } from './detect-spec.js';
+export { getTypes } from './oas-types.js';
+export { getMajorSpecVersion } from './detect-spec.js';
+export { normalizeVisitors, } from './visitors.js';
+export { walkDocument, } from './walk.js';
+export { getAstNodeByPointer, getLineColLocation, getCodeframe } from './format/codeframes.js';
+export { formatProblems, getTotals } from './format/format.js';
+export { lint, lint as validate, lintDocument, lintFromString, lintConfig } from './lint.js';
+export { lintEntityFile, lintEntityWithScorecardLevel, lintSchema } from './lint-entity.js';
+export { bundle, bundleFromString } from './bundle/bundle.js';
+export { bundleDocument } from './bundle/bundle-document.js';
+export { mapTypeToComponent } from './bundle/bundle-visitor.js';
+export { logger } from './logger.js';
+export { HandledError } from './utils/error.js';
+export { isBrowser } from './env.js';
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/js-yaml/index.js

@@ -0,0 +1,11 @@
+// TODO: add a type for "types" https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/js-yaml/index.d.ts
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import { JSON_SCHEMA, types, load, dump } from 'js-yaml';
+const DEFAULT_SCHEMA_WITHOUT_TIMESTAMP = JSON_SCHEMA.extend({
+    implicit: [types.merge],
+    explicit: [types.binary, types.omap, types.pairs, types.set],
+});
+export const parseYaml = (str, opts) => load(str, { schema: DEFAULT_SCHEMA_WITHOUT_TIMESTAMP, ...opts });
+export const stringifyYaml = (obj, opts) => dump(obj, opts);
+//# sourceMappingURL=index.js.map