@kubb/agent 4.33.1 → 4.33.3

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

@@ -0,0 +1,573 @@
+import * as redoclyConfig from '@redocly/config';
+import path from 'node:path';
+import { specVersions, getTypes } from '../oas-types.js';
+import { isAbsoluteUrl } from '../ref-utils.js';
+import { normalizeTypes } from '../types/index.js';
+import { isCustomRuleId } from '../utils/is-custom-rule-id.js';
+import { omit } from '../utils/omit.js';
+import { listOf, mapOf } from './index.js';
+import { getNodeTypesFromJSONSchema } from './json-schema-adapter.js';
+const builtInOAS2Rules = [
+    'info-contact',
+    'operation-operationId',
+    'tag-description',
+    'tags-alphabetical',
+    'info-license-strict',
+    'info-license',
+    'no-ambiguous-paths',
+    'no-enum-type-mismatch',
+    'no-http-verbs-in-paths',
+    'no-identical-paths',
+    'no-invalid-parameter-examples',
+    'no-invalid-schema-examples',
+    'no-path-trailing-slash',
+    'operation-2xx-response',
+    'operation-4xx-response',
+    'operation-description',
+    'operation-operationId-unique',
+    'operation-operationId-url-safe',
+    'operation-parameters-unique',
+    'operation-singular-tag',
+    'operation-summary',
+    'operation-tag-defined',
+    'parameter-description',
+    'path-declaration-must-exist',
+    'path-http-verbs-order',
+    'path-not-include-query',
+    'path-params-defined',
+    'path-parameters-defined',
+    'path-segment-plural',
+    'paths-kebab-case',
+    'required-string-property-missing-min-length',
+    'response-contains-header',
+    'scalar-property-missing-example',
+    'security-defined',
+    'spec-strict-refs',
+    'no-required-schema-properties-undefined',
+    'no-schema-type-mismatch',
+    'boolean-parameter-prefixes',
+    'request-mime-type',
+    'response-contains-property',
+    'response-mime-type',
+    'no-duplicated-tag-names',
+];
+const builtInOAS3Rules = [
+    'info-contact',
+    'operation-operationId',
+    'tag-description',
+    'tags-alphabetical',
+    'info-license-strict',
+    'info-license',
+    'no-ambiguous-paths',
+    'no-enum-type-mismatch',
+    'no-http-verbs-in-paths',
+    'no-identical-paths',
+    'no-invalid-parameter-examples',
+    'no-invalid-schema-examples',
+    'no-path-trailing-slash',
+    'operation-2xx-response',
+    'operation-4xx-response',
+    'operation-description',
+    'operation-operationId-unique',
+    'operation-operationId-url-safe',
+    'operation-parameters-unique',
+    'operation-singular-tag',
+    'operation-summary',
+    'operation-tag-defined',
+    'parameter-description',
+    'path-declaration-must-exist',
+    'path-http-verbs-order',
+    'path-not-include-query',
+    'path-params-defined',
+    'path-parameters-defined',
+    'path-segment-plural',
+    'paths-kebab-case',
+    'required-string-property-missing-min-length',
+    'response-contains-header',
+    'scalar-property-missing-example',
+    'security-defined',
+    'spec-strict-refs',
+    'no-required-schema-properties-undefined',
+    'no-schema-type-mismatch',
+    'boolean-parameter-prefixes',
+    'component-name-unique',
+    'no-empty-servers',
+    'no-example-value-and-externalValue',
+    'no-invalid-media-type-examples',
+    'no-server-example.com',
+    'no-server-trailing-slash',
+    'no-server-variables-empty-enum',
+    'no-undefined-server-variable',
+    'no-unused-components',
+    'operation-4xx-problem-details-rfc7807',
+    'request-mime-type',
+    'response-contains-property',
+    'response-mime-type',
+    'spec-components-invalid-map-name',
+    'array-parameter-serialization',
+    'no-duplicated-tag-names',
+    'nullable-type-sibling',
+    'spec-no-invalid-tag-parents',
+    'spec-no-invalid-encoding-combinations',
+    'spec-discriminator-defaultMapping',
+    'spec-example-values',
+    'spec-querystring-parameters',
+];
+const builtInAsync2Rules = [
+    'info-contact',
+    'info-license-strict',
+    'operation-operationId',
+    'tag-description',
+    'tags-alphabetical',
+    'channels-kebab-case',
+    'no-channel-trailing-slash',
+    'no-duplicated-tag-names',
+    'no-required-schema-properties-undefined',
+    'no-enum-type-mismatch',
+    'no-schema-type-mismatch',
+];
+const builtInAsync3Rules = [
+    'info-contact',
+    'info-license-strict',
+    'operation-operationId',
+    'tag-description',
+    'tags-alphabetical',
+    'channels-kebab-case',
+    'no-channel-trailing-slash',
+    'no-duplicated-tag-names',
+    'no-required-schema-properties-undefined',
+    'no-enum-type-mismatch',
+    'no-schema-type-mismatch',
+];
+const builtInArazzo1Rules = [
+    'sourceDescription-type',
+    'workflowId-unique',
+    'stepId-unique',
+    'sourceDescription-name-unique',
+    'sourceDescriptions-not-empty',
+    'workflow-dependsOn',
+    'outputs-defined',
+    'parameters-unique',
+    'step-onSuccess-unique',
+    'step-onFailure-unique',
+    'respect-supported-versions',
+    'requestBody-replacements-unique',
+    'no-criteria-xpath',
+    'criteria-unique',
+    'no-x-security-scheme-name-without-openapi',
+    'x-security-scheme-required-values',
+    'no-x-security-both-scheme-and-scheme-name',
+    'no-required-schema-properties-undefined',
+    'no-enum-type-mismatch',
+    'no-schema-type-mismatch',
+    'x-security-scheme-name-reference',
+];
+const builtInOverlay1Rules = ['info-contact'];
+const builtInOpenRpc1Rules = [
+    'info-contact',
+    'info-license',
+    'no-unused-components',
+    'spec-no-duplicated-method-params',
+    'spec-no-required-params-after-optional',
+];
+const builtInCommonRules = ['struct', 'no-unresolved-refs'];
+const builtInRules = [
+    ...builtInOAS2Rules,
+    ...builtInOAS3Rules,
+    ...builtInAsync2Rules,
+    ...builtInAsync3Rules,
+    ...builtInArazzo1Rules,
+    ...builtInOverlay1Rules,
+    ...builtInOpenRpc1Rules,
+    ...builtInCommonRules,
+];
+const configGovernanceProperties = {
+    extends: {
+        name: 'Extends',
+        properties: {},
+        items: (node) => {
+            // check if it's preset name
+            if (typeof node === 'string' && !isAbsoluteUrl(node) && !path.extname(node)) {
+                return { type: 'string' };
+            }
+            return {
+                ...ConfigGovernance,
+                directResolveAs: { name: 'ConfigGovernance', ...ConfigGovernance },
+            };
+        },
+        description: 'Use extends to inherit rules and their configurations from other rulesets.',
+        documentationLink: 'https://redocly.com/docs/cli/configuration/reference/extends#extends',
+    },
+    plugins: { type: 'array', items: { type: 'string' } },
+    rules: 'Rules',
+    oas2Rules: 'Rules',
+    oas3_0Rules: 'Rules',
+    oas3_1Rules: 'Rules',
+    oas3_2Rules: 'Rules',
+    async2Rules: 'Rules',
+    async3Rules: 'Rules',
+    arazzo1Rules: 'Rules',
+    overlay1Rules: 'Rules',
+    openrpc1Rules: 'Rules',
+    preprocessors: 'Preprocessors',
+    oas2Preprocessors: 'Preprocessors',
+    oas3_0Preprocessors: 'Preprocessors',
+    oas3_1Preprocessors: 'Preprocessors',
+    oas3_2Preprocessors: 'Preprocessors',
+    async2Preprocessors: 'Preprocessors',
+    async3Preprocessors: 'Preprocessors',
+    arazzo1Preprocessors: 'Preprocessors',
+    overlay1Preprocessors: 'Preprocessors',
+    openrpc1Preprocessors: 'Preprocessors',
+    decorators: 'Decorators',
+    oas2Decorators: 'Decorators',
+    oas3_0Decorators: 'Decorators',
+    oas3_1Decorators: 'Decorators',
+    oas3_2Decorators: 'Decorators',
+    async2Decorators: 'Decorators',
+    async3Decorators: 'Decorators',
+    arazzo1Decorators: 'Decorators',
+    overlay1Decorators: 'Decorators',
+    openrpc1Decorators: 'Decorators',
+};
+const ConfigGovernance = {
+    properties: configGovernanceProperties,
+};
+const createConfigRoot = (nodeTypes) => ({
+    ...nodeTypes.rootRedoclyConfigSchema,
+    properties: {
+        ...nodeTypes.rootRedoclyConfigSchema.properties,
+        ...ConfigGovernance.properties,
+        apis: 'ConfigApis', // Override apis with internal format
+        telemetry: { enum: ['on', 'off'] },
+        resolve: {
+            properties: {
+                http: 'ConfigHTTP',
+                doNotResolveExamples: { type: 'boolean' },
+            },
+        },
+    },
+});
+const ConfigApis = {
+    properties: {},
+    additionalProperties: 'ConfigApisProperties',
+    description: 'The `apis` configuration section is used when a project contains multiple API descriptions to set up different rules and settings for individual APIs. It allows defining specific configurations for each API, which must be identified by a unique name.',
+    documentationLink: 'https://redocly.com/docs/cli/configuration/reference/apis',
+};
+const createConfigApisProperties = (nodeTypes) => ({
+    ...nodeTypes['rootRedoclyConfigSchema.apis_additionalProperties'],
+    properties: {
+        ...nodeTypes['rootRedoclyConfigSchema.apis_additionalProperties']?.properties,
+        ...omit(ConfigGovernance.properties, ['plugins']), // plugins are not allowed in apis
+    },
+});
+const ConfigHTTP = {
+    properties: {
+        headers: {
+            type: 'array',
+            items: {
+                type: 'string',
+            },
+        },
+    },
+};
+const Rules = {
+    properties: {},
+    description: 'The rules configuration blocks set up linting rules and their severity. You can configure built-in rules, add configurable rules, and rules from plugins.',
+    documentationLink: 'https://redocly.com/docs/cli/configuration/reference/rules#rules',
+    additionalProperties: (value, key) => {
+        if (key.startsWith('rule/')) {
+            if (typeof value === 'string') {
+                return { enum: ['error', 'warn', 'off'] };
+            }
+            else {
+                return 'ConfigurableRule';
+            }
+        }
+        else if (builtInRules.includes(key) || isCustomRuleId(key)) {
+            if (typeof value === 'string') {
+                return { enum: ['error', 'warn', 'off'] };
+            }
+            else {
+                return 'BuiltinRule';
+            }
+        }
+        else if (key === 'metadata-schema' || key === 'custom-fields-schema') {
+            return 'Schema';
+        }
+        // Otherwise is considered as invalid
+        return;
+    },
+};
+const BuiltinRule = {
+    properties: {
+        severity: { enum: ['error', 'warn', 'off'] },
+    },
+    additionalProperties: {},
+    required: ['severity'],
+    description: 'Built-in rules are the default linting rules included with Redocly CLI. They enforce widely accepted API design standards and best practices. Each built-in rule has a default severity of error, but you can change the severity or turn off any built-in rule in your configuration file.',
+    documentationLink: 'https://redocly.com/docs/cli/rules/built-in-rules',
+};
+const Decorators = {
+    properties: {},
+    additionalProperties: {},
+    description: 'Decorators define transformations that can be applied to the API document during the bundle step.',
+    documentationLink: 'https://redocly.com/docs/cli/configuration/reference/decorators',
+};
+const Preprocessors = {
+    properties: {},
+    additionalProperties: {},
+    description: 'Preprocessors define transformations that can be applied to the API document before bundling.',
+    documentationLink: 'https://redocly.com/docs/cli/configuration/reference/preprocessors',
+};
+// TODO: add better type tree for this
+const Schema = {
+    properties: {
+        properties: mapOf('Schema'),
+    },
+    additionalProperties: {},
+};
+function createAssertionDefinitionSubject(nodeNames) {
+    return {
+        properties: {
+            type: {
+                enum: [...new Set(['any', ...nodeNames, 'SpecExtension'])],
+                description: 'REQUIRED. Locates the OpenAPI node type that the lint command evaluates.',
+            },
+            property: (value) => {
+                if (Array.isArray(value)) {
+                    return {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Property name corresponding to the OpenAPI node type. If a list of properties is provided, assertions evaluate against each property in the sequence. If not provided (or null), assertions evaluate against the key names for the subject node type.',
+                        documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#property-example',
+                    };
+                }
+                else if (value === null) {
+                    return null;
+                }
+                else {
+                    return {
+                        type: 'string',
+                        description: 'Property name corresponding to the OpenAPI node type. If a list of properties is provided, assertions evaluate against each property in the sequence. If not provided (or null), assertions evaluate against the key names for the subject node type.',
+                        documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#property-example',
+                    };
+                }
+            },
+            filterInParentKeys: {
+                type: 'array',
+                items: { type: 'string' },
+                description: `The name of the subject's parent key that locates where assertions run. An example value given the subject Operation could be filterInParentKeys: [get, put] means that only GET and PUT operations are evaluated for the assertions.`,
+                documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#mutuallyrequired-example',
+            },
+            filterOutParentKeys: {
+                type: 'array',
+                items: { type: 'string' },
+                description: `The name of the subject's parent key that excludes where assertions run. An example value given the subject Operation could be filterOutParentKeys: [delete] means that all operations except DELETE operations are evaluated for the assertions.`,
+            },
+            matchParentKeys: {
+                type: 'string',
+                description: `Applies a regex pattern to the subject's parent keys to determine where assertions run. An example value given the subject Operation could be matchParentKeys: /^p/ means that POST, PUT, and PATCH operations are evaluated for the assertions.`,
+            },
+        },
+        required: ['type'],
+        description: 'REQUIRED. Narrows the subject further by specifying its type, and optionally property, filterParentKeys, etc.',
+        documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#subject-object',
+    };
+}
+function createScorecardLevelsItems(nodeTypes) {
+    return {
+        ...nodeTypes[redoclyConfig.CONFIG_NODE_TYPE_NAMES.ScorecardClassicLevel],
+        properties: {
+            ...nodeTypes[redoclyConfig.CONFIG_NODE_TYPE_NAMES.ScorecardClassicLevel]?.properties,
+            ...configGovernanceProperties,
+        },
+    };
+}
+const Assertions = {
+    properties: {
+        enum: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Asserts a value is within a predefined list of values. Providing a single value in a list is an equality check.',
+            documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#enum-example',
+        },
+        pattern: {
+            type: 'string',
+            description: 'Asserts a value matches a regex pattern.',
+            documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#pattern-example',
+        },
+        notPattern: {
+            type: 'string',
+            description: `Asserts a value doesn't match a regex pattern.`,
+            documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#notpattern-example',
+        },
+        casing: {
+            enum: [
+                'camelCase',
+                'kebab-case',
+                'snake_case',
+                'PascalCase',
+                'MACRO_CASE',
+                'COBOL-CASE',
+                'flatcase',
+            ],
+            description: 'Asserts a casing style. Supported styles are: camelCase, kebab-case, snake_case, PascalCase, MACRO_CASE, COBOL-CASE, flatcase.',
+            documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#casing-example',
+        },
+        mutuallyExclusive: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Asserts that listed properties (key names only) are mutually exclusive.',
+            documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#mutuallyexclusive-example',
+        },
+        mutuallyRequired: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Asserts that listed properties (key names only) are mutually required.',
+            documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#mutuallyrequired-example',
+        },
+        required: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Asserts all listed values are defined.',
+            documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#required-example',
+        },
+        requireAny: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Asserts that at least one of the listed properties (key names only) is defined. ',
+            documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#requireany-example',
+        },
+        disallowed: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Asserts all listed values are not defined.',
+            documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#disallowed-example',
+        },
+        defined: {
+            type: 'boolean',
+            description: 'Asserts a property is defined.',
+            documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#defined-example',
+        },
+        nonEmpty: {
+            type: 'boolean',
+            description: 'Asserts a property is not empty.',
+            documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#nonempty-example',
+        },
+        minLength: {
+            type: 'integer',
+            description: 'Asserts a minimum length (inclusive) of a string or list (array).',
+            documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#minlength-example',
+        },
+        maxLength: {
+            type: 'integer',
+            description: 'Asserts a maximum length (inclusive) of a string or list (array).',
+            documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#maxlength-example',
+        },
+        ref: (value) => typeof value === 'string'
+            ? {
+                type: 'string',
+                description: `Asserts a reference object presence in object's property. A boolean value of true means the property has a $ref defined. A boolean value of false means the property has not defined a $ref (it has an in-place value). A string value means that the $ref is defined and the unresolved value must match the pattern (for example, '/paths/.*.yaml$/').`,
+                documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#ref-example',
+            }
+            : {
+                type: 'boolean',
+                description: `Asserts a reference object presence in object's property. A boolean value of true means the property has a $ref defined. A boolean value of false means the property has not defined a $ref (it has an in-place value). A string value means that the $ref is defined and the unresolved value must match the pattern (for example, '/paths/.*.yaml$/').`,
+                documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#ref-example',
+            },
+        const: (value) => {
+            if (typeof value === 'string') {
+                return {
+                    type: 'string',
+                    description: 'Asserts equality of a value. The behavior is the same as the enum assertion with exactly one value.',
+                    documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#const-example',
+                };
+            }
+            if (typeof value === 'number') {
+                return {
+                    type: 'number',
+                    description: 'Asserts equality of a value. The behavior is the same as the enum assertion with exactly one value.',
+                    documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#const-example',
+                };
+            }
+            if (typeof value === 'boolean') {
+                return {
+                    type: 'boolean',
+                    description: 'Asserts equality of a value. The behavior is the same as the enum assertion with exactly one value.',
+                    documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#const-example',
+                };
+            }
+            else {
+                return;
+            }
+        },
+    },
+    additionalProperties: (_value, key) => {
+        if (/^\w+\/\w+$/.test(key))
+            return {};
+        return;
+    },
+    description: 'A minimum of one assertion property is required to be defined.',
+    documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#assertion-object',
+};
+const Where = {
+    properties: {
+        subject: 'Subject',
+        assertions: 'Assertions',
+    },
+    required: ['subject', 'assertions'],
+    description: 'The where object is part of a where list which must be defined in order from the root node. Each node can only be used in one where object for each assertion. Each subsequent node must be a descendant of the previous one. Rules that use multiple where objects must target each one on a different node. However, the same node could be used in the last where object and in the root subject object. Nodes may be skipped in between the subject node types of the where list and those defined in the root subject type.',
+    documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#where-object',
+};
+const ConfigurableRule = {
+    properties: {
+        subject: 'Subject',
+        assertions: 'Assertions',
+        where: listOf('Where'),
+        message: { type: 'string' },
+        suggest: { type: 'array', items: { type: 'string' } },
+        severity: { enum: ['error', 'warn', 'off'] },
+    },
+    required: ['subject', 'assertions'],
+    description: 'Configurable rule definitions enforce your custom API design standards. Add or edit your configurable rules in the configuration file. A configurable rule is a rule that starts with a rule/ prefix followed by a unique rule name. Rule names display in the lint log if the assertions fail. More than one configurable rule may be defined, and any configurable rule may have multiple assertions.',
+    documentationLink: 'https://redocly.com/docs/cli/rules/configurable-rules#configurable-rule-object',
+};
+export function createConfigTypes(extraSchemas, config) {
+    const nodeNames = specVersions.flatMap((version) => {
+        const types = config ? config.extendTypes(getTypes(version), version) : getTypes(version);
+        return Object.keys(types);
+    });
+    // Create types based on external schemas
+    const { ctx: nodeTypes } = getNodeTypesFromJSONSchema('rootRedoclyConfigSchema', extraSchemas);
+    return {
+        ...CoreConfigTypes,
+        ConfigRoot: createConfigRoot(nodeTypes), // This is the REAL config root type
+        ConfigApisProperties: createConfigApisProperties(nodeTypes),
+        Subject: createAssertionDefinitionSubject(nodeNames),
+        ...nodeTypes,
+        [redoclyConfig.CONFIG_NODE_TYPE_NAMES.ScorecardClassicLevel]: createScorecardLevelsItems(nodeTypes),
+    };
+}
+const CoreConfigTypes = {
+    ConfigurableRule,
+    ConfigApis,
+    ConfigGovernance,
+    ConfigHTTP,
+    Where,
+    BuiltinRule,
+    Schema,
+    Rules,
+    Decorators,
+    Preprocessors,
+    Assertions,
+};
+// FIXME: remove this once we remove `theme` from the schema
+const { theme: _, ...propertiesWithoutTheme } = redoclyConfig.rootRedoclyConfigSchema.properties;
+const redoclyConfigSchemaWithoutTheme = {
+    ...redoclyConfig.rootRedoclyConfigSchema,
+    properties: propertiesWithoutTheme,
+};
+export const ConfigTypes = createConfigTypes(redoclyConfigSchemaWithoutTheme);
+export const NormalizedConfigTypes = normalizeTypes(ConfigTypes);
+//# sourceMappingURL=redocly-yaml.js.map

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

@@ -0,0 +1,3 @@
+export const VERSION_PATTERN = /^1\.0\.\d+(-.+)?$/;
+export const ARAZZO_VERSIONS_SUPPORTED_BY_RESPECT = ['1.0.1'];
+//# sourceMappingURL=arazzo.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/assign-config.js

@@ -0,0 +1,28 @@
+import { isPlainObject } from './is-plain-object.js';
+export const assignConfig = (target, obj) => {
+    if (!obj)
+        return;
+    for (const k of Object.keys(obj)) {
+        if (isPlainObject(target[k]) && typeof obj[k] === 'string') {
+            target[k] = { ...target[k], severity: obj[k] };
+        }
+        else {
+            target[k] = obj[k];
+        }
+    }
+};
+export function assignOnlyExistingConfig(target, obj) {
+    if (!obj)
+        return;
+    for (const k of Object.keys(obj)) {
+        if (!target.hasOwnProperty(k))
+            continue;
+        if (isPlainObject(target[k]) && typeof obj[k] === 'string') {
+            target[k] = { ...target[k], severity: obj[k] };
+        }
+        else {
+            target[k] = obj[k];
+        }
+    }
+}
+//# sourceMappingURL=assign-config.js.map

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

@@ -0,0 +1,36 @@
+/**
+ * Checks if two objects are deeply equal.
+ * Borrowed the source code from https://github.com/lukeed/dequal.
+ */
+export function dequal(foo, bar) {
+    let ctor, len;
+    if (foo === bar)
+        return true;
+    if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+        if (ctor === Date)
+            return foo.getTime() === bar.getTime();
+        if (ctor === RegExp)
+            return foo.toString() === bar.toString();
+        if (ctor === Array) {
+            if ((len = foo.length) === bar.length) {
+                while (len-- && dequal(foo[len], bar[len]))
+                    ;
+            }
+            return len === -1;
+        }
+        if (!ctor || typeof foo === 'object') {
+            len = 0;
+            for (ctor in foo) {
+                if (Object.prototype.hasOwnProperty.call(foo, ctor) &&
+                    ++len &&
+                    !Object.prototype.hasOwnProperty.call(bar, ctor))
+                    return false;
+                if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor]))
+                    return false;
+            }
+            return Object.keys(bar).length === len;
+        }
+    }
+    return foo !== foo && bar !== bar;
+}
+//# sourceMappingURL=dequal.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/does-yaml-file-exist.js

@@ -0,0 +1,7 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export function doesYamlFileExist(filePath) {
+    return ((path.extname(filePath) === '.yaml' || path.extname(filePath) === '.yml') &&
+        !!fs?.existsSync?.(filePath));
+}
+//# sourceMappingURL=does-yaml-file-exist.js.map

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

@@ -0,0 +1,3 @@
+export class HandledError extends Error {
+}
+//# sourceMappingURL=error.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/get-intersection-length.js

@@ -0,0 +1,11 @@
+export function getIntersectionLength(keys, properties) {
+    const props = new Set(properties);
+    let count = 0;
+    for (const key of keys) {
+        if (props.has(key)) {
+            count++;
+        }
+    }
+    return count;
+}
+//# sourceMappingURL=get-intersection-length.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/get-matching-status-code-range.js

@@ -0,0 +1,4 @@
+export function getMatchingStatusCodeRange(code) {
+    return `${code}`.replace(/^(\d)\d\d$/, (_, firstDigit) => `${firstDigit}XX`);
+}
+//# sourceMappingURL=get-matching-status-code-range.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/get-own.js

@@ -0,0 +1,4 @@
+export function getOwn(obj, key) {
+    return obj.hasOwnProperty(key) ? obj[key] : undefined;
+}
+//# sourceMappingURL=get-own.js.map