@scalar/openapi-to-markdown 1.5.3 → 1.6.0

package/dist/render-schema.js

@@ -41,10 +41,12 @@ const getReferenceName = (ref) => {
 /** Only references that add nothing structural can be replaced by the schema they point to. */
 const getSharedName = (input, view) => {
     const ref = isObject(input) ? input.$ref : undefined;
-    if (typeof ref !== 'string' || typeof view.schema !== 'object')
+    if (typeof ref !== 'string' || typeof view.schema !== 'object') {
         return undefined;
-    if (Object.keys(input).some((key) => structuralKeywords.has(key)))
+    }
+    if (Object.keys(input).some((key) => structuralKeywords.has(key))) {
         return undefined;
+    }
     const structured = Boolean(view.allOf?.length || view.anyOf?.length || view.oneOf?.length || view.properties.length) ||
         view.not !== undefined ||
         view.items !== undefined ||
@@ -67,13 +69,16 @@ const getSharedIdentity = (input) => {
 const resolveMarkdownSchema = (input) => {
     const target = getResolvedRef(input);
     const merged = getResolvedRef(input, mergeSiblingReferences);
-    if (typeof target !== 'boolean')
+    if (typeof target !== 'boolean') {
         return merged;
+    }
     if (!isObject(merged) ||
-        !Object.keys(merged).some((key) => !['$ref', '$ref-value', '$global', '$status'].includes(key)))
+        !Object.keys(merged).some((key) => !['$ref', '$ref-value', '$global', '$status'].includes(key))) {
         return target;
-    if (target)
+    }
+    if (target) {
         return merged;
+    }
     // A false target remains impossible, even when siblings describe a type or annotations.
     return { ...merged, allOf: [false, ...(Array.isArray(merged.allOf) ? merged.allOf : [])] };
 };
@@ -85,19 +90,23 @@ const wrapperKeys = new Set([...annotationKeys, ...referenceKeys, '__scalar_', '
 const primitiveTypes = new Set(['string', 'number', 'integer', 'boolean', 'null']);
 /** Infer the JSON type of a literal, for `const` and `enum` schemas that do not declare one. */
 const getJsonType = (value) => {
-    if (value === null)
+    if (value === null) {
         return 'null';
-    if (Array.isArray(value))
+    }
+    if (Array.isArray(value)) {
         return 'array';
-    if (typeof value === 'number')
+    }
+    if (typeof value === 'number') {
         return Number.isInteger(value) ? 'integer' : 'number';
+    }
     return typeof value;
 };
 /** A schema that only allows `null`, as in `anyOf: [X, { type: 'null' }]`. */
 const isNullSchema = (input) => {
     const schema = getResolvedRef(input);
-    if (!isObject(schema))
+    if (!isObject(schema)) {
         return false;
+    }
     const type = Array.isArray(schema.type) && schema.type.length === 1 ? schema.type[0] : schema.type;
     return (type === 'null' &&
         Object.keys(schema).every((key) => key === 'type' || key === 'title' || key === 'description' || referenceKeys.has(key)));
@@ -114,37 +123,40 @@ const getWrapped = (value) => {
         value.not !== undefined ||
         value.discriminator ||
         value.enum ||
-        value.const !== undefined)
+        value.const !== undefined) {
         return undefined;
+    }
     const allOf = value.allOf ?? [];
     const anyOf = value.anyOf ?? [];
     const oneOf = value.oneOf ?? [];
-    if (allOf.length === 1 && !anyOf.length && !oneOf.length)
+    if (allOf.length === 1 && !anyOf.length && !oneOf.length) {
         return { core: allOf[0], nullable: false };
+    }
     const union = anyOf.length ? anyOf : oneOf;
-    if (allOf.length || (anyOf.length && oneOf.length) || union.length !== 2)
+    if (allOf.length || (anyOf.length && oneOf.length) || union.length !== 2) {
         return undefined;
+    }
     const core = union.filter((branch) => !isNullSchema(branch));
     return core.length === 1 ? { core: core[0], nullable: true } : undefined;
 };
 /** Join alternatives with `|`, keeping neighbouring plain types in one code span. */
 const joinAlternatives = (alternatives) => {
     // `array of string | null` would read as an array of nullable strings.
-    if (alternatives.length > 1)
-        alternatives = alternatives.map((alternative) => {
-            const only = alternative.length === 1 ? alternative[0] : undefined;
-            return only?.type === 'inlineCode' && only.value.startsWith('array of ')
-                ? [inlineCode(`(${only.value})`)]
-                : alternative;
-        });
+    const groupedAlternatives = alternatives.map((alternative) => {
+        const only = alternative.length === 1 ? alternative[0] : undefined;
+        return alternatives.length > 1 && only?.type === 'inlineCode' && only.value.startsWith('array of ')
+            ? [inlineCode(`(${only.value})`)]
+            : alternative;
+    });
     const nodes = [];
     let plain = [];
     const flushPlain = () => {
-        if (plain.length)
+        if (plain.length) {
             nodes.push(...(nodes.length ? [text(' | ')] : []), inlineCode(plain.join(' | ')));
+        }
         plain = [];
     };
-    for (const alternative of alternatives) {
+    for (const alternative of groupedAlternatives) {
         const only = alternative.length === 1 ? alternative[0] : undefined;
         if (only?.type === 'inlineCode') {
             plain.push(only.value);
@@ -163,8 +175,9 @@ export const createSchemaRenderer = ({ maxNodes = MAX_NODES } = {}) => {
     const unwrapping = new Set();
     const view = (input) => {
         const cached = typeof input === 'object' ? views.get(input) : undefined;
-        if (cached)
+        if (cached) {
             return cached;
+        }
         // Keep the linked document's nested identities and boolean schemas. Coercing a
         // second time here would discard boolean children and copy recursive targets.
         const schema = resolveMarkdownSchema(input);
@@ -173,9 +186,10 @@ export const createSchemaRenderer = ({ maxNodes = MAX_NODES } = {}) => {
         const properties = Object.entries(value.properties ?? {})
             .filter(([, child]) => typeof child === 'boolean' || (child !== null && typeof child === 'object'))
             .sort(([a], [b]) => Number(required.has(b)) - Number(required.has(a)) || a.localeCompare(b));
+        const booleanType = schema ? 'any' : 'never';
         let result = {
             ...value,
-            type: typeof schema === 'boolean' ? (schema ? 'any' : 'never') : value.type,
+            type: typeof schema === 'boolean' ? booleanType : value.type,
             schema: schema,
             required,
             properties,
@@ -189,18 +203,21 @@ export const createSchemaRenderer = ({ maxNodes = MAX_NODES } = {}) => {
             const annotations = Object.fromEntries(annotationKeys.flatMap((key) => (result[key] === undefined ? [] : [[key, result[key]]])));
             result = { ...inner, ...annotations, core: wrapped.core, nullable: wrapped.nullable || inner.nullable };
         }
-        if (typeof input === 'object')
+        if (typeof input === 'object') {
             views.set(input, result);
+        }
         return result;
     };
     const primitives = new WeakMap();
     /** Primitives, enums, consts and aliases of them, whose whole definition fits on one line. */
     const isPrimitive = (input) => {
-        if (typeof input !== 'object')
+        if (typeof input !== 'object') {
             return true;
+        }
         const cached = primitives.get(input);
-        if (cached !== undefined)
+        if (cached !== undefined) {
             return cached;
+        }
         // Assume a recursive alias is not primitive while it is being checked.
         primitives.set(input, false);
         const value = view(input);
@@ -248,16 +265,21 @@ export const createSchemaRenderer = ({ maxNodes = MAX_NODES } = {}) => {
     ];
     /** The declared types, or the types implied by `const`, `enum`, properties or items. */
     const getTypes = (value) => {
-        if (value.type !== undefined)
+        if (value.type !== undefined) {
             return [value.type].flat();
-        if (value.const !== undefined)
+        }
+        if (value.const !== undefined) {
             return [getJsonType(value.const)];
-        if (value.enum?.length)
+        }
+        if (value.enum?.length) {
             return [...new Set(value.enum.map(getJsonType))];
-        if (value.properties.length || isObject(value.additionalProperties))
+        }
+        if (value.properties.length || isObject(value.additionalProperties)) {
             return ['object'];
-        if (value.items !== undefined)
+        }
+        if (value.items !== undefined) {
             return ['array'];
+        }
         return [];
     };
     const forDocument = (models = {}, settings = {}, destinations) => {
@@ -270,14 +292,16 @@ export const createSchemaRenderer = ({ maxNodes = MAX_NODES } = {}) => {
         let nodeCount = 0;
         /** The reference a nested schema links to in linked mode, instead of expanding its target. */
         const getLink = (input) => {
-            if ((!linked && !destinations) || !isObject(input))
+            if ((!linked && !destinations) || !isObject(input)) {
                 return undefined;
+            }
             const ref = getRef(input);
             if (ref !== undefined) {
                 // A primitive alias is shorter than a link to it, and saves the reader a page.
                 const resolved = getResolvedRef(input) !== undefined;
-                if (!linked && !destinations?.has(getReferenceName(ref)))
+                if (!linked && !destinations?.has(getReferenceName(ref))) {
                     return undefined;
+                }
                 return resolved && inlinePrimitives && isPrimitive(input) ? undefined : ref;
             }
             const core = view(input).core;
@@ -300,11 +324,13 @@ export const createSchemaRenderer = ({ maxNodes = MAX_NODES } = {}) => {
                         (!structuralKeywords.has(key) ||
                             numericAnnotations.some((annotation) => annotation === key) ||
                             (key === 'additionalProperties' && entry === false)) &&
-                        !(key in own))
+                        !(key in own)) {
                         own[key] = entry;
+                    }
                 }
-                if (getRef(current) !== undefined)
+                if (getRef(current) !== undefined) {
                     break;
+                }
                 current = view(current).core;
             }
             return view(own);
@@ -323,8 +349,9 @@ export const createSchemaRenderer = ({ maxNodes = MAX_NODES } = {}) => {
                     complete: !structural,
                 };
             }
-            if (typeof value.schema === 'boolean')
+            if (typeof value.schema === 'boolean') {
                 return { nodes: [], complete: true };
+            }
             const types = getTypes(value);
             const alternatives = [];
             let complete = !value.properties.length &&
@@ -340,10 +367,12 @@ export const createSchemaRenderer = ({ maxNodes = MAX_NODES } = {}) => {
                 if (complete &&
                     !types.length &&
                     branches.length === union.length &&
-                    branches.every((branch, index) => branch.complete && branch.nodes.length && !hasAnnotations(getOwnView(union[index]))))
+                    branches.every((branch, index) => branch.complete && branch.nodes.length && !hasAnnotations(getOwnView(union[index])))) {
                     alternatives.push(...branches.map((branch) => branch.nodes));
-                else
+                }
+                else {
                     complete = false;
+                }
             }
             for (const type of types) {
                 if (type !== 'array' || value.items === undefined) {
@@ -361,53 +390,67 @@ export const createSchemaRenderer = ({ maxNodes = MAX_NODES } = {}) => {
                     ? [inlineCode(only.value.includes(' | ') ? `array of (${only.value})` : `array of ${only.value}`)]
                     : [text('array of '), ...(items.nodes.length > 1 ? [text('('), ...items.nodes, text(')')] : items.nodes)]);
             }
-            if (!types.length && value.items !== undefined)
+            if (!types.length && value.items !== undefined) {
                 complete = false;
+            }
             // Without a type to name, a nullable schema says so and leaves its structure to the lines below.
-            if (value.nullable && !types.includes('null'))
+            if (value.nullable && !types.includes('null')) {
                 alternatives.push(alternatives.length || complete ? [inlineCode('null')] : [text('nullable')]);
+            }
             // A schema without types or structure accepts any value.
-            if (!alternatives.length && complete)
+            if (!alternatives.length && complete) {
                 alternatives.push([inlineCode('any')]);
+            }
             return { nodes: joinAlternatives(alternatives), complete };
         };
         /** The one-line summary of a schema: its type, then its annotations. */
         const summarize = (input, { nested, label = getLabel(input, nested), showType = true, }) => {
             const linkedLabel = (nested || destinations !== undefined) && getLink(input) !== undefined;
             const value = linkedLabel ? getLinkAnnotations(input) : view(input);
-            if (typeof value.schema === 'boolean')
+            if (typeof value.schema === 'boolean') {
                 return { line: [text(value.schema ? 'any (true schema)' : 'never (false schema)')] };
+            }
             const nodes = showType ? [...label.nodes] : [];
             const add = (name, entry) => {
-                if (entry !== undefined)
+                if (entry !== undefined) {
                     nodes.push(text(`${nodes.length ? ', ' : ''}${name}: `), inlineCode(entry));
+                }
             };
             const flag = (name, entry) => {
-                if (entry)
+                if (entry) {
                     nodes.push(text(`${nodes.length ? ', ' : ''}${name}`));
+                }
             };
             // Later references to a shared schema point back to this name.
             const ref = getRef(input);
             if (!linkedLabel && value.name !== undefined) {
                 // In linked mode the expanded schema also has its own page.
-                if (linked && ref !== undefined)
+                if (linked && ref !== undefined) {
                     nodes.push(text(`${nodes.length ? ', ' : ''}schema: `), referenceNode(ref));
-                else
+                }
+                else {
                     add('schema', value.name);
+                }
             }
-            if (linkedLabel && value.type !== undefined)
+            if (linkedLabel && value.type !== undefined) {
                 add('type', [value.type].flat().join(' | '));
+            }
             add('format', value.format);
-            if (value.enum)
+            if (value.enum) {
                 add('possible values', value.enum.map((entry) => JSON.stringify(entry)).join(', '));
-            if (value.const !== undefined)
+            }
+            if (value.const !== undefined) {
                 add('const', JSON.stringify(value.const));
-            if (value.default !== undefined)
+            }
+            if (value.default !== undefined) {
                 add('default', JSON.stringify(value.default));
-            for (const key of numericAnnotations)
+            }
+            for (const key of numericAnnotations) {
                 add(key, value[key]);
-            for (const key of ['readOnly', 'writeOnly', 'deprecated'])
+            }
+            for (const key of ['readOnly', 'writeOnly', 'deprecated']) {
                 flag(key, value[key]);
+            }
             flag('no additional properties', value.additionalProperties === false);
             // A reference without its own description still says what it is, from the schema it links to.
             return { line: nodes, description: value.description ?? (linkedLabel ? view(input).description : undefined) };
@@ -420,18 +463,21 @@ export const createSchemaRenderer = ({ maxNodes = MAX_NODES } = {}) => {
                 : {};
             if (Object.keys(siblings).length && !options.hideDetails) {
                 const { line, description } = summarize(siblings, { nested: false, showType: false });
-                if (line.length)
+                if (line.length) {
                     nodes.push(paragraph(...line));
-                if (!options.hideDescription)
+                }
+                if (!options.hideDescription) {
                     nodes.push(...describe(description));
+                }
             }
             nodes.push(paragraph(emphasis(text('Schema '), inlineCode(name), text(` is shown ${location}.`))));
             return nodes;
         };
         /** Print a schema's summary line and description, unless the caller already did. */
         const header = (input, depth, options, showType = true) => {
-            if (options.hideDetails)
+            if (options.hideDetails) {
                 return [];
+            }
             const { line, description } = summarize(input, { nested: depth > 0, showType });
             return [...(line.length ? [paragraph(...line)] : []), ...(options.hideDescription ? [] : describe(description))];
         };
@@ -471,8 +517,9 @@ export const createSchemaRenderer = ({ maxNodes = MAX_NODES } = {}) => {
             // A wrapper prints its merged summary, then its core schema's structure.
             if (value.core !== undefined) {
                 const nodes = header(input, depth, options);
-                if (label.complete)
+                if (label.complete) {
                     return nodes;
+                }
                 return [
                     ...nodes,
                     ...render(value.core, depth, ancestors, {
@@ -492,18 +539,23 @@ export const createSchemaRenderer = ({ maxNodes = MAX_NODES } = {}) => {
                     const referenceOptions = options.name === undefined ? options : { ...options, hideDetails: true };
                     return reference(input, referenceOptions, previous.name, 'above');
                 }
-                if (value.name !== undefined && options.name === undefined && depth >= MAX_DEPTH && sections.has(shared))
+                if (value.name !== undefined && options.name === undefined && depth >= MAX_DEPTH && sections.has(shared)) {
                     return reference(input, options, value.name, 'below under Schemas');
+                }
             }
-            if (depth >= MAX_DEPTH)
+            if (depth >= MAX_DEPTH) {
                 return [paragraph(text('[Maximum schema depth reached]'))];
-            if (nodeCount >= maxNodes)
+            }
+            if (nodeCount >= maxNodes) {
                 return [paragraph(emphasis(text('[Schema output truncated]')))];
+            }
             nodeCount++;
-            if (shared && name !== undefined && !shown.has(shared))
+            if (shared && name !== undefined && !shown.has(shared)) {
                 shown.set(shared, { name, description: value.description });
-            if (typeof value.schema === 'boolean')
+            }
+            if (typeof value.schema === 'boolean') {
                 return header(input, depth, options);
+            }
             const childAncestors = [...ancestors, identity];
             const nodes = [];
             // Discriminator values that name a branch are printed beside it instead of in a separate list.
@@ -516,8 +568,9 @@ export const createSchemaRenderer = ({ maxNodes = MAX_NODES } = {}) => {
                     ['anyOf', 'Any of:'],
                     ['oneOf', 'One of:'],
                 ]) {
-                    if (!value[key]?.length)
+                    if (!value[key]?.length) {
                         continue;
+                    }
                     // One list item per branch keeps the boundary between branches visible.
                     const branches = value[key].map((child) => {
                         const blocks = render(child, depth + 1, childAncestors, { showType: true });
@@ -525,19 +578,22 @@ export const createSchemaRenderer = ({ maxNodes = MAX_NODES } = {}) => {
                         const values = key === 'allOf' || ref === undefined ? [] : mappings.filter(([, target]) => target === ref);
                         const first = blocks[0];
                         if (values.length && first?.type === 'paragraph') {
-                            for (const [name] of values)
+                            for (const [name] of values) {
                                 mapped.add(name);
+                            }
                             first.children.push(text(`${first.children.length ? ', ' : ''}${value.discriminator.propertyName}: `), inlineCode(values.map(([name]) => name).join(', ')));
                         }
                         return item(...blocks);
                     });
                     const discriminated = key !== 'allOf' && value.discriminator;
                     nodes.push(paragraph(strong(text(title)), ...(discriminated ? [text(' discriminated by '), inlineCode(value.discriminator.propertyName)] : [])), list(branches));
-                    if (discriminated)
+                    if (discriminated) {
                         discriminatorShown = true;
+                    }
                 }
-                if (value.not !== undefined)
+                if (value.not !== undefined) {
                     nodes.push(paragraph(strong(text('Not:'))), ...render(value.not, depth + 1, childAncestors));
+                }
             }
             // Child sections imply a single container type, but never its nullable alternatives.
             const impliedType = !options.showType &&
@@ -549,8 +605,9 @@ export const createSchemaRenderer = ({ maxNodes = MAX_NODES } = {}) => {
                 // A reference sibling may require a field declared only in the target schema.
                 const declared = new Set(value.properties.map(([name]) => name));
                 const required = [...value.required].filter((name) => !declared.has(name));
-                if (required.length)
+                if (required.length) {
                     nodes.push(paragraph(strong(text('Required fields:')), text(' '), inlineCode(required.join(', '))));
+                }
             }
             if (value.properties.length) {
                 const properties = value.properties.map(([name, schema]) => {
@@ -559,15 +616,17 @@ export const createSchemaRenderer = ({ maxNodes = MAX_NODES } = {}) => {
                     const title = [
                         strong(inlineCode(name), ...(value.required.has(name) ? [text(' (required)')] : [])),
                     ];
-                    if (line.length)
+                    if (line.length) {
                         title.push(text(': '), ...line);
+                    }
                     const blocks = [paragraph(...title), ...describe(description)];
-                    if (!childLabel.complete)
+                    if (!childLabel.complete) {
                         blocks.push(...render(schema, depth + 1, childAncestors, {
                             hideDetails: true,
                             hideDescription: true,
                             property: true,
                         }));
+                    }
                     return item(...blocks);
                 });
                 nodes.push(list(properties));
@@ -577,13 +636,15 @@ export const createSchemaRenderer = ({ maxNodes = MAX_NODES } = {}) => {
                 (value.type === 'array' || value.type === undefined || [value.type].flat().includes('array'))) {
                 nodes.push(paragraph(strong(text(options.property ? 'Items:' : 'Array of:'))), ...render(value.items, depth + 1, childAncestors));
             }
-            if (isObject(value.additionalProperties))
+            if (isObject(value.additionalProperties)) {
                 nodes.push(paragraph(strong(text('Additional properties:'))), ...render(value.additionalProperties, depth + 1, childAncestors));
+            }
             const unmapped = mappings.filter(([name]) => !mapped.has(name));
             if (value.discriminator && (!discriminatorShown || unmapped.length)) {
                 nodes.push(paragraph(strong(text('Discriminator:')), text(' '), inlineCode(value.discriminator.propertyName)));
-                if (unmapped.length)
+                if (unmapped.length) {
                     nodes.push(list(unmapped.map(([name, target]) => item(paragraph(inlineCode(name), text(': '), linked || destinations ? referenceNode(target) : inlineCode(target))))));
+                }
             }
             return nodes;
         };
@@ -600,34 +661,41 @@ export const createSchemaRenderer = ({ maxNodes = MAX_NODES } = {}) => {
             patternProperties: 'map',
         };
         const getExampleSchema = (input, root) => {
-            if (!isObject(input))
+            if (!isObject(input)) {
                 return input;
+            }
             if (!root && getLink(input) !== undefined) {
                 const types = getTypes(view(input));
                 return types.includes('array') && !types.includes('object') ? { type: 'array', items: {} } : { type: 'object' };
             }
             // Primitive references stay linked; a spread copy would lose the non-enumerable target.
             if (getRef(input) !== undefined) {
-                if (!root)
+                if (!root) {
                     return input;
+                }
                 // Merging keeps the `$ref` key, which must not be followed again.
                 const merged = getResolvedRef(input, mergeSiblingReferences);
-                if (!isObject(merged))
+                if (!isObject(merged)) {
                     return merged;
+                }
                 const { $ref: _ref, ...target } = merged;
                 return getExampleSchema(target, true);
             }
             const copy = { ...input };
             for (const [key, kind] of Object.entries(schemaKeywords)) {
                 const value = input[key];
-                if (kind === 'one')
+                if (kind === 'one') {
                     copy[key] = getExampleSchema(value, false);
-                else if (kind === 'list' && Array.isArray(value))
+                }
+                else if (kind === 'list' && Array.isArray(value)) {
                     copy[key] = value.map((entry) => getExampleSchema(entry, false));
-                else if (kind === 'map' && isObject(value))
+                }
+                else if (kind === 'map' && isObject(value)) {
                     copy[key] = Object.fromEntries(Object.entries(value).map(([name, entry]) => [name, getExampleSchema(entry, false)]));
-                if (copy[key] === undefined)
+                }
+                if (copy[key] === undefined) {
                     delete copy[key];
+                }
             }
             return copy;
         };

package/dist/render-security.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render-security.d.ts","sourceRoot":"","sources":["../src/render-security.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8DAA8D,CAAA;AACnG,OAAO,KAAK,EAAE,OAAO,EAA6B,WAAW,EAAE,MAAM,OAAO,CAAA;AAG5E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAsD5D;;;;GAIG;AACH,eAAO,MAAM,cAAc,GACzB,cAAc,eAAe,CAAC,UAAU,CAAC,EACzC,SAAS,WAAW,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC,iBAAiB,CAAC,EACtE,aAAa,iBAAiB,EAC9B,QAAO,OAAO,CAAC,OAAO,CAAK,KAC1B,OAAO,CAAC,WAAW,EAAE,CAsBvB,CAAA"}
+{"version":3,"file":"render-security.d.ts","sourceRoot":"","sources":["../src/render-security.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8DAA8D,CAAA;AACnG,OAAO,KAAK,EAAE,OAAO,EAA6B,WAAW,EAAE,MAAM,OAAO,CAAA;AAG5E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAwD5D;;;;GAIG;AACH,eAAO,MAAM,cAAc,GACzB,cAAc,eAAe,CAAC,UAAU,CAAC,EACzC,SAAS,WAAW,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC,iBAAiB,CAAC,EACtE,aAAa,iBAAiB,EAC9B,QAAO,OAAO,CAAC,OAAO,CAAK,KAC1B,OAAO,CAAC,WAAW,EAAE,CAgCvB,CAAA"}

package/dist/render-security.js

@@ -33,8 +33,9 @@ const summarizeScheme = (scheme) => {
                     ['refreshUrl', 'refresh'],
                 ]) {
                     // Coercion fills in optional URLs as empty strings.
-                    if (typeof urls[key] === 'string' && urls[key])
+                    if (typeof urls[key] === 'string' && urls[key]) {
                         nodes.push(text(`, ${label} `), inlineCode(urls[key]));
+                    }
                 }
             }
             return nodes;
@@ -53,14 +54,17 @@ const summarizeScheme = (scheme) => {
  * no authentication is required.
  */
 export const renderSecurity = async (requirements, schemes, description, level = 4) => {
-    if (!requirements)
+    if (!requirements) {
         return [];
+    }
     const nodes = [heading(level, text('Authentication'))];
-    if (!requirements.length)
+    if (!requirements.length) {
         nodes.push(paragraph(text('No authentication required.')));
+    }
     for (const [index, requirement] of requirements.entries()) {
-        if (index)
+        if (index) {
             nodes.push(paragraph(text('Or:')));
+        }
         const entries = Object.entries(requirement);
         if (!entries.length) {
             nodes.push(paragraph(text('No authentication required.')));
@@ -70,10 +74,12 @@ export const renderSecurity = async (requirements, schemes, description, level =
         for (const [name, scopes] of entries) {
             const scheme = getResolvedRef(schemes?.[name]);
             const line = [strong(text(name))];
-            if (scheme)
+            if (scheme) {
                 line.push(text(': '), ...summarizeScheme(scheme));
-            if (scopes?.length)
+            }
+            if (scopes?.length) {
                 line.push(text(', scopes: '), inlineCode(scopes.join(', ')));
+            }
             entriesNodes.push(item(paragraph(...line), ...(await description(scheme?.description))));
         }
         nodes.push(list(entriesNodes));

package/dist/render-tags.d.ts

@@ -0,0 +1,7 @@
+import type { TagObject } from '@scalar/workspace-store/schemas/v3.2/strict/tag';
+/** Keep tag ancestry visible without exceeding Markdown's six heading levels. */
+export declare const getTagSections: (tags: TagObject[], openapiVersion: string) => {
+    tag: TagObject;
+    title: string;
+}[];
+//# sourceMappingURL=render-tags.d.ts.map

package/dist/render-tags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-tags.d.ts","sourceRoot":"","sources":["../src/render-tags.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iDAAiD,CAAA;AAEhF,iFAAiF;AACjF,eAAO,MAAM,cAAc,GAAI,MAAM,SAAS,EAAE,EAAE,gBAAgB,MAAM,KAAG;IAAE,GAAG,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAwE3G,CAAA"}