@mintlify/common 1.0.397 → 1.0.399

package/dist/mdx/lib/remark-utils.d.ts

@@ -1,8 +1,8 @@
-export function createMdxJsxAttribute(key: any, value: any): {
-    type: string;
-    name: any;
-    value: any;
-};
-export function toMdxJsxFlowElement(input: any): import("mdast").RootContent | undefined;
-export function getUnicodeId(title: any): string;
-export function getTOCTitle(node: any, i?: number, a?: any[]): any;
+import type { RootContent as HastRootContent } from 'hast';
+import type { RootContent as MdastRootContent } from 'mdast';
+import type { MdxJsxAttribute, MdxJsxAttributeValueExpression } from 'mdast-util-mdx-jsx';
+type RootContent = MdastRootContent | HastRootContent;
+export declare const createMdxJsxAttribute: (key: string, value: MdxJsxAttributeValueExpression | string | null | undefined | number | boolean) => MdxJsxAttribute;
+export declare function getUnicodeId(title: string): string;
+export declare const getTableOfContentsTitle: (node: RootContent, index?: number, children?: RootContent[]) => string;
+export {};

package/dist/mdx/lib/remark-utils.js

@@ -1,39 +1,37 @@
-import * as acorn from 'acorn';
-import { fromMarkdown } from 'mdast-util-from-markdown';
-import { mdxJsxFromMarkdown } from 'mdast-util-mdx-jsx';
-import { mdxJsx } from 'micromark-extension-mdx-jsx';
 export const createMdxJsxAttribute = (key, value) => {
     return {
         type: 'mdxJsxAttribute',
         name: key,
-        value,
+        // we want to cast here to avoid the type checker failing on number/boolean values
+        // which will get serialized properly, but just aren't added to the type
+        value: value,
     };
 };
-export const toMdxJsxFlowElement = (input) => {
-    const tree = fromMarkdown(input, {
-        extensions: [mdxJsx({ acorn: acorn, addResult: true })],
-        mdastExtensions: [mdxJsxFromMarkdown()],
-    });
-    return tree.children[0];
-};
-export const getUnicodeId = (title) => {
+export function getUnicodeId(title) {
     return encodeURIComponent(title.toLowerCase().trim().replace(/\s+/g, '-'));
-};
-export const getTOCTitle = (node, i = 1, a = []) => {
-    var _a, _b, _c;
-    if (node.name === 'Update') {
-        const labelAttr = node.attributes.find((attr) => attr.name === 'label');
-        return labelAttr.value;
+}
+const EMPTY_CHILDREN = [];
+export const getTableOfContentsTitle = (node, index = 1, children = EMPTY_CHILDREN) => {
+    var _a;
+    if ('name' in node && node.name === 'Update') {
+        const labelAttr = node.attributes.find((attr) => 'name' in attr && attr.name === 'label' && typeof attr.value === 'string');
+        return (_a = labelAttr === null || labelAttr === void 0 ? void 0 : labelAttr.value) !== null && _a !== void 0 ? _a : '';
     }
-    if ((node.type === 'text' &&
-        (((_a = a[i - 1]) === null || _a === void 0 ? void 0 : _a.type) !== 'mdxJsxFlowElement' || !((_c = (_b = a[i - 1]) === null || _b === void 0 ? void 0 : _b.value) === null || _c === void 0 ? void 0 : _c.startsWith('<small')))) ||
-        node.type === 'inlineCode') {
+    const lastChild = children[index - 1];
+    const isText = node.type === 'text';
+    const isInlineCode = node.type === 'inlineCode';
+    const isLastChildMdx = (lastChild === null || lastChild === void 0 ? void 0 : lastChild.type) !== 'mdxJsxFlowElement';
+    const isLastChildSmall = lastChild &&
+        'value' in lastChild &&
+        typeof lastChild.value === 'string' &&
+        !lastChild.value.startsWith('<small');
+    if (isInlineCode || (isText && (isLastChildMdx || isLastChildSmall))) {
         return node.value;
     }
-    if (node.children) {
+    if ('children' in node && Array.isArray(node.children)) {
         let title = '';
-        node.children.forEach((node, i, a) => {
-            title += getTOCTitle(node, i, a);
+        node.children.forEach((subNode, index, children) => {
+            title += getTableOfContentsTitle(subNode, index, children);
         });
         return title;
     }

package/dist/mdx/plugins/rehype/rehypeCodeBlocks.js

@@ -5,7 +5,6 @@ function isElement(node, key = 'type', element = 'element') {
     return node != undefined && node[key] === element;
 }
 function addCodeBlocks(tree) {
-    const preTree = { children: [] };
     visit(tree, (node, i, parent) => {
         var _a, _b;
         if (parent == null || i == null || !isElement(node) || !isElement(node, 'tagName', 'pre')) {
@@ -18,6 +17,7 @@ function addCodeBlocks(tree) {
         let isExpandable = false;
         const isFlowElement = isElement(parent, 'type', flowElementType);
         const parentName = isFlowElement ? parent.name : undefined;
+        const properties = code.type === 'element' ? Object.entries(code.properties) : [];
         if (parentName && exampleNames.includes(parentName)) {
             const parentType = parentName.slice(0, -7);
             filename = i === 0 ? parentType : `${parentType} ${i + 1}`;
@@ -38,6 +38,13 @@ function addCodeBlocks(tree) {
             attributes: [
                 { type: 'mdxJsxAttribute', name: 'filename', value: filename !== null && filename !== void 0 ? filename : '' },
                 { type: 'mdxJsxAttribute', name: 'expandable', value: isExpandable.toString() },
+                ...properties
+                    .filter(([_key, val]) => val != null)
+                    .map(([key, val]) => ({
+                    type: 'mdxJsxAttribute',
+                    name: key,
+                    value: Array.isArray(val) ? val.join(' ') : val === null || val === void 0 ? void 0 : val.toString(),
+                })),
             ],
             data: { _mdxExplicitJsx: true },
             children: [],
@@ -45,7 +52,7 @@ function addCodeBlocks(tree) {
         wrap.children = [node];
         parent.children[i] = wrap;
     });
-    tree.children = [...preTree.children, ...tree.children];
+    tree.children = [...tree.children];
 }
 export function rehypeCodeBlocks() {
     return addCodeBlocks;

package/dist/mdx/plugins/rehype/rehypeMdxExtractEndpoint/parsers.d.ts

@@ -1,6 +1,6 @@
 import { MintConfig } from '@mintlify/models';
 import { DataSchema, DocsConfig, HttpMethod, SecurityOption, Server } from '@mintlify/validation';
-import { MdxJsxFlowElementHast } from 'mdast-util-mdx-jsx';
+import type { MdxJsxFlowElementHast } from 'mdast-util-mdx-jsx';
 import type { FieldLocation } from '../../../lib/mdx-utils.js';
 export declare const parseApiString: (apiString: string, config?: MintConfig | DocsConfig) => {
     servers?: Server[];

package/dist/mdx/plugins/rehype/rehypeMdxExtractEndpoint/parsers.js

@@ -1,15 +1,18 @@
+import { OpenAPIV3 } from 'openapi-types';
 import { getSecurityOptionsForAuthMethod } from '../../../../index.js';
 import { isAbsoluteUrl } from '../../../../isAbsoluteUrl.js';
 import { isDocsConfig } from '../../../../isDocsConfig.js';
 import { isMdxJsxAttribute, isParamFieldLocation } from '../../../lib/mdx-utils.js';
+const VALID_METHODS = Object.values(OpenAPIV3.HttpMethods);
 export const parseApiString = (apiString, config) => {
     const components = apiString.trim().split(/\s+/);
     if (!components[0] || !components[1] || components.length > 2) {
         throw new Error('improperly formatted api string');
     }
-    const [upperMethod, endpointStr] = components;
+    const upperMethod = components[0];
+    const endpointStr = components[1];
     const method = upperMethod.toLowerCase();
-    if (!['get', 'put', 'post', 'delete', 'patch', 'options', 'head', 'trace'].includes(method)) {
+    if (!VALID_METHODS.includes(method)) {
         throw new Error('invalid http method');
     }
     const { origin, path } = parseEndpoint(endpointStr);
@@ -204,7 +207,9 @@ export const parseTypeString = (typeString) => {
     const lowerTypeString = typeString.toLowerCase();
     const simpleSchemaType = typeStringToSchemaType[lowerTypeString];
     if (lowerTypeString.includes('|')) {
-        const [left, right] = lowerTypeString.split('|');
+        const splitLowerTypeString = lowerTypeString.split('|');
+        const left = splitLowerTypeString[0];
+        const right = splitLowerTypeString[1];
         if (left && right) {
             const leftSchema = parseTypeString(left.trim());
             const rightSchema = parseTypeString(right.trim());
@@ -238,7 +243,8 @@ export const parseTypeString = (typeString) => {
     const regexMatch = genericStringRegex.exec(lowerTypeString);
     if (regexMatch !== null) {
         // unpack capture group 1 (foo) and 2 (bar)
-        const [_, superType, subType] = regexMatch;
+        const superType = regexMatch[1];
+        const subType = regexMatch[2];
         if (superType && subType && typeStringToSchemaType[superType] === 'array') {
             // catches type strings like array<bar>
             // recursively determine the type of everything within the angle brackets

package/dist/mdx/plugins/rehype/rehypeRawComponents.d.ts

@@ -1 +1,2 @@
-export function rehypeRawComponents(): (tree: any) => void;
+import type { Pluggable } from 'unified';
+export declare const rehypeRawComponents: Pluggable;

package/dist/mdx/plugins/rehype/rehypeRawComponents.js

@@ -2,10 +2,13 @@ import { fromHtml } from 'hast-util-from-html';
 import { visit } from 'unist-util-visit';
 export const rehypeRawComponents = () => {
     return (tree) => {
-        visit(tree, 'raw', (raw, i, parent) => {
+        visit(tree, 'raw', (raw, index, parent) => {
             const rawAst = fromHtml(raw.value, { fragment: true });
-            if (parent && i) {
-                parent.children[i] = rawAst;
+            if (parent && index !== undefined) {
+                // @ts-expect-error we're passing a component of type Root to parent.children which
+                // is fine even though parent.children should only take RootContent, bc `remark`
+                // will flatten out Roots into single nodes of type RootContent when serializing
+                parent.children[index] = rawAst;
             }
         });
     };

package/dist/mdx/plugins/rehype/rehypeUnicodeIds.d.ts

@@ -1 +1,2 @@
-export function rehypeUnicodeIds(): (tree: any) => void;
+import type { Pluggable } from 'unified';
+export declare const rehypeUnicodeIds: Pluggable;

package/dist/mdx/plugins/rehype/rehypeUnicodeIds.js

@@ -1,17 +1,19 @@
 import { visit } from 'unist-util-visit';
-import { getUnicodeId, getTOCTitle } from '../../lib/remark-utils.js';
+import { getUnicodeId, getTableOfContentsTitle } from '../../lib/remark-utils.js';
 const DEEPLINKABLE_COMPONENTS = ['Heading', 'Update', 'Accordion'];
-export function rehypeUnicodeIds() {
+export const rehypeUnicodeIds = () => {
     return (tree) => {
         visit(tree, 'mdxJsxFlowElement', (node) => {
-            if (node && node.name && DEEPLINKABLE_COMPONENTS.includes(node.name)) {
-                const title = getTOCTitle(node);
+            if (node.name && DEEPLINKABLE_COMPONENTS.includes(node.name)) {
+                const title = getTableOfContentsTitle(node);
                 const encodedId = getUnicodeId(title);
-                const existingIdIndex = node.attributes.findIndex((attr) => attr.name === 'id');
-                if (existingIdIndex !== -1 && !node.attributes[existingIdIndex].value) {
+                const existingIdIndex = node.attributes.findIndex((attr) => 'name' in attr && attr.name === 'id');
+                if (existingIdIndex !== -1 &&
+                    node.attributes[existingIdIndex] &&
+                    !node.attributes[existingIdIndex].value) {
                     node.attributes[existingIdIndex].value = encodedId;
                 }
             }
         });
     };
-}
+};

package/dist/mdx/plugins/remark/remarkExtractChangelogFilters.d.ts

@@ -1 +1,3 @@
-export function remarkExtractChangelogFilters(mdxExtracts: any): (tree: any) => void;
+import type { Root } from 'mdast';
+import type { MdxExtracts } from '../../../types/index.js';
+export declare function remarkExtractChangelogFilters(mdxExtracts?: MdxExtracts): (tree: Root) => void;

package/dist/mdx/plugins/remark/remarkExtractChangelogFilters.js

@@ -1,43 +1,40 @@
 export function remarkExtractChangelogFilters(mdxExtracts) {
     return (tree) => {
+        var _a, _b;
         const tagCounts = new Map();
         for (let nodeIndex = 0; nodeIndex < tree.children.length; nodeIndex++) {
             const node = tree.children[nodeIndex];
-            if (node.type === 'mdxJsxFlowElement' && node.name === 'Update') {
-                const tagsAttribute = node.attributes.find((attr) => attr.name === 'tags');
-                if (tagsAttribute &&
-                    tagsAttribute.value &&
-                    tagsAttribute.value.type === 'mdxJsxAttributeValueExpression') {
-                    let tags = [];
-                    try {
-                        tags = JSON.parse(tagsAttribute.value.value);
-                    }
-                    catch (_a) {
-                        const isProgram = tagsAttribute.value.data.estree.type === 'Program';
-                        if (isProgram && tagsAttribute.value.data.estree.body.length === 1) {
-                            const body = tagsAttribute.value.data.estree.body[0];
-                            if (body.type === 'ExpressionStatement' &&
-                                body.expression.type === 'ArrayExpression') {
-                                tags = body.expression.elements
-                                    .map((element) => {
-                                    if (element.type === 'Literal') {
-                                        return element.value;
-                                    }
-                                    return null;
-                                })
-                                    .filter(Boolean);
-                            }
-                        }
-                    }
-                    if (Array.isArray(tags)) {
-                        tags.forEach((tag) => {
-                            if (!!tag.trim()) {
-                                tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
-                            }
-                        });
+            if (!node || node.type !== 'mdxJsxFlowElement' || node.name !== 'Update') {
+                continue;
+            }
+            const tagsAttribute = node.attributes.find((attr) => 'name' in attr && attr.name === 'tags');
+            if (!tagsAttribute || !tagsAttribute.value || typeof tagsAttribute.value !== 'object') {
+                continue;
+            }
+            let tags = [];
+            try {
+                tags = JSON.parse(tagsAttribute.value.value);
+            }
+            catch (_c) {
+                if (((_b = (_a = tagsAttribute.value.data) === null || _a === void 0 ? void 0 : _a.estree) === null || _b === void 0 ? void 0 : _b.body.length) === 1) {
+                    const body = tagsAttribute.value.data.estree.body[0];
+                    if ((body === null || body === void 0 ? void 0 : body.type) === 'ExpressionStatement' && body.expression.type === 'ArrayExpression') {
+                        tags = body.expression.elements
+                            .map((element) => {
+                            return (element === null || element === void 0 ? void 0 : element.type) === 'Literal' ? element.value : null;
+                        })
+                            .filter(Boolean);
                     }
                 }
             }
+            if (!Array.isArray(tags)) {
+                continue;
+            }
+            tags.forEach((tag) => {
+                if (!!tag.trim()) {
+                    tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
+                }
+            });
         }
         const filters = Array.from(tagCounts.entries())
             .map(([tag, count]) => ({

package/dist/mdx/plugins/remark/remarkExtractTableOfContents.d.ts

@@ -1 +1,3 @@
-export function remarkExtractTableOfContents(mdxExtracts: any): (tree: any) => void;
+import type { Root } from 'mdast';
+import type { MdxExtracts } from '../../../types/index.js';
+export declare const remarkExtractTableOfContents: (mdxExtracts?: MdxExtracts) => (tree: Root) => void;

package/dist/mdx/plugins/remark/remarkExtractTableOfContents.js

@@ -1,68 +1,84 @@
 import { slugifyWithCounter } from '@sindresorhus/slugify';
-import { createMdxJsxAttribute, getTOCTitle, getUnicodeId } from '../../lib/remark-utils.js';
+import { createMdxJsxAttribute, getTableOfContentsTitle, getUnicodeId, } from '../../lib/remark-utils.js';
+import { HEADING_LEVELS } from './remarkHeadingIds.js';
+const HEADING_NAMES = ['h1', 'h2', 'h3', 'h4'];
 export const remarkExtractTableOfContents = (mdxExtracts) => {
     // slugifyWithCounter adds a counter (eg. slug, slug-2, slug-3) to the end of the slug if the header
     // already exists. No counter is added for the first occurence.
     const slugify = slugifyWithCounter();
     return (tree) => {
+        var _a, _b, _c, _d;
         const contents = [];
         let hasTopLayer = false;
         for (let nodeIndex = 0; nodeIndex < tree.children.length; nodeIndex++) {
-            let node = tree.children[nodeIndex];
-            if ((node.type === 'heading' && [1, 2, 3, 4].includes(node.depth)) ||
-                (node.type === 'mdxJsxFlowElement' && ['h1', 'h2', 'h3', 'h4'].includes(node.name)) ||
-                (node.name === 'Update' &&
-                    node.attributes.some((attr) => node.type === 'mdxJsxFlowElement' && attr.name === 'label'))) {
-                let level;
-                if (node.name === 'Update') {
-                    level = 1;
-                    node.depth = 1;
-                }
-                else {
-                    level = node.depth ? node.depth : node.name.split('')[1];
-                }
-                let title = getTOCTitle(node);
-                const encodedTitle = getUnicodeId(title);
-                let slug;
-                // if encoded title is already percent-encoded, return it as is
-                // slugify doesn't support percent-encoded characters, like Chinese, Korean, etc.
-                if (/%[0-9A-F]{2}/.test(encodedTitle)) {
-                    slug = slugify(encodedTitle, {
-                        decamelize: false,
-                        preserveCharacters: ['%'],
-                        lowercase: false,
-                    });
-                }
-                else {
-                    slug = slugify(encodedTitle, { decamelize: false });
-                }
-                let mdxJsxAttributes;
-                if (node.name === 'Update') {
-                    mdxJsxAttributes = [...node.attributes, createMdxJsxAttribute('id', slug)];
-                }
-                else {
-                    mdxJsxAttributes = [
-                        createMdxJsxAttribute('level', level),
-                        createMdxJsxAttribute('id', slug),
-                        createMdxJsxAttribute('isAtRootLevel', true),
-                    ];
-                }
-                node.attributes = mdxJsxAttributes;
-                node.type = 'mdxJsxFlowElement';
-                node.name = node.name === 'Update' ? 'Update' : 'Heading';
-                const depth = node.depth;
-                if (level <= 2) {
-                    hasTopLayer = true;
-                    contents.push({ title, slug, depth, children: [] });
-                }
-                else {
-                    // Account if there is no first layer
-                    let arrToPushInto = contents;
-                    if (hasTopLayer) {
-                        arrToPushInto = contents[contents.length - 1].children;
-                    }
-                    arrToPushInto.push({ title, slug, depth, children: [] });
+            const node = tree.children[nodeIndex];
+            if (!node)
+                continue;
+            const isValidHeading = node.type === 'heading' && HEADING_LEVELS.includes(node.depth);
+            const isValidMdxHeading = node.type === 'mdxJsxFlowElement' && HEADING_NAMES.includes((_a = node.name) !== null && _a !== void 0 ? _a : '');
+            const isValidUpdate = node.type === 'mdxJsxFlowElement' &&
+                node.name === 'Update' &&
+                node.attributes.some((attr) => 'name' in attr && attr.name === 'label');
+            if (!isValidHeading && !isValidMdxHeading && !isValidUpdate) {
+                continue;
+            }
+            let level;
+            if ('name' in node && node.name === 'Update') {
+                level = 1;
+                // @ts-expect-error we're assigning to depth despite the node not containing depth in the type
+                node.depth = 1;
+            }
+            else if ('depth' in node) {
+                level = node.depth;
+            }
+            else if ('name' in node && ((_b = node.name) === null || _b === void 0 ? void 0 : _b[1])) {
+                const num = Number(node.name[1]);
+                level = !isNaN(num) ? num : undefined;
+            }
+            const title = getTableOfContentsTitle(node);
+            const encodedTitle = getUnicodeId(title);
+            let slug;
+            // if encoded title is already percent-encoded, return it as is
+            // slugify doesn't support percent-encoded characters, like Chinese, Korean, etc.
+            if (/%[0-9A-F]{2}/.test(encodedTitle)) {
+                slug = slugify(encodedTitle, {
+                    decamelize: false,
+                    preserveCharacters: ['%'],
+                    lowercase: false,
+                });
+            }
+            else {
+                slug = slugify(encodedTitle, { decamelize: false });
+            }
+            let mdxJsxAttributes;
+            if ('name' in node && node.name === 'Update') {
+                mdxJsxAttributes = [...node.attributes, createMdxJsxAttribute('id', slug)];
+            }
+            else if (level !== undefined) {
+                mdxJsxAttributes = [
+                    createMdxJsxAttribute('level', level),
+                    createMdxJsxAttribute('id', slug),
+                    createMdxJsxAttribute('isAtRootLevel', true),
+                ];
+            }
+            // @ts-expect-error we're assigning over 'attributes' if it doesn't exist
+            node.attributes = mdxJsxAttributes;
+            node.type = 'mdxJsxFlowElement';
+            // @ts-expect-error we're assigning over 'name' if it doesn't exist
+            node.name = node.name === 'Update' ? 'Update' : 'Heading';
+            // @ts-expect-error we've already written to 'depth' and so this should be safe
+            const depth = node.depth;
+            if (level !== undefined && Number(level) <= 2) {
+                hasTopLayer = true;
+                contents.push({ title, slug, depth, children: [] });
+            }
+            else {
+                // Account if there is no first layer
+                let arrToPushInto = contents;
+                if (hasTopLayer) {
+                    arrToPushInto = (_d = (_c = contents.at(-1)) === null || _c === void 0 ? void 0 : _c.children) !== null && _d !== void 0 ? _d : [];
                 }
+                arrToPushInto.push({ title, slug, depth, children: [] });
             }
         }
         if (mdxExtracts) {

package/dist/mdx/plugins/remark/remarkFrames.d.ts

@@ -1 +1,2 @@
-export function remarkFrames(): (tree: any) => void;
+import type { Root } from 'mdast';
+export declare const remarkFrames: () => (tree: Root) => void;

package/dist/mdx/plugins/remark/remarkFrames.js

@@ -1,37 +1,10 @@
-import { toMdxJsxFlowElement } from '../../lib/remark-utils.js';
 export const remarkFrames = () => {
     return (tree) => {
-        let preTree = { children: [] };
         tree.children = tree.children.map((node) => {
-            // Start of horizontal block: -- block
-            if (node.type === 'paragraph' &&
-                node.children.length === 1 &&
-                node.children[0].value === '-- block') {
-                node.type = 'jsx';
-                node.value = `<div className='grid md:grid-cols-2 md:gap-8'><div>`;
-            }
-            // Start a new column: -- column
-            if (node.type === 'paragraph' &&
-                node.children.length === 1 &&
-                node.children[0].value === '-- column') {
-                node.type = 'jsx';
-                node.value = `</div><div>`;
-            }
-            // End of horizontal block: -- /block
-            if (node.type === 'paragraph' &&
-                node.children.length === 1 &&
-                node.children[0].value === '-- /block') {
-                node.type = 'jsx';
-                node.value = `</div></div>`;
-            }
             if (node.type === 'mdxJsxFlowElement' && (node.name === 'Example' || node.name === 'Frame')) {
                 node.name = 'Frame';
             }
-            if (node.type === 'jsx') {
-                node = toMdxJsxFlowElement(node.value);
-            }
             return node;
         });
-        tree.children = [...preTree.children, ...tree.children];
     };
 };

package/dist/mdx/plugins/remark/remarkHeadingIds.d.ts

@@ -1,2 +1,3 @@
-import { Root } from 'mdast';
+import type { Root } from 'mdast';
+export declare const HEADING_LEVELS: number[];
 export declare const remarkHeadingIds: () => (tree: Root) => void;

package/dist/mdx/plugins/remark/remarkHeadingIds.js

@@ -1,12 +1,13 @@
 import { slugifyWithCounter } from '@sindresorhus/slugify';
 import { visit } from 'unist-util-visit';
 import { createMdxJsxAttribute, getUnicodeId } from '../../lib/remark-utils.js';
-import { getTOCTitle } from '../../lib/remark-utils.js';
+import { getTableOfContentsTitle } from '../../lib/remark-utils.js';
+export const HEADING_LEVELS = [1, 2, 3, 4];
 export const remarkHeadingIds = () => (tree) => {
     const slugify = slugifyWithCounter();
     visit(tree, 'heading', (node, _, parent) => {
-        if ([1, 2, 3, 4].includes(node.depth)) {
-            const title = getTOCTitle(node);
+        if (HEADING_LEVELS.includes(node.depth)) {
+            const title = getTableOfContentsTitle(node);
             const encodedTitle = getUnicodeId(title);
             let slug;
             // if encoded title is already percent-encoded, return it as is

package/dist/mdx/snippets/resolveImport/index.js

@@ -12,6 +12,10 @@ import { getAST } from '../../remark.js';
 import { findExport } from './findExport.js';
 import { injectToTopOfFileOfTree } from './injectToTopOfFile.js';
 import { resolveComponentWithContent } from './resolveComponentWithContent.js';
+const VALID_SPECIFIERS = [
+    MdxImportSpecifier.ImportSpecifier,
+    MdxImportSpecifier.RenamedImportSpecifier,
+];
 /**
  *
  * @param importSpecifier The name of the imported component we want to replace
@@ -20,7 +24,7 @@ import { resolveComponentWithContent } from './resolveComponentWithContent.js';
  * @returns
  */
 export const resolveImport = (importSpecifier, destinationPageContent, importedFileContent, exportMap) => __awaiter(void 0, void 0, void 0, function* () {
-    if ([MdxImportSpecifier.ImportSpecifier, MdxImportSpecifier.RenamedImportSpecifier].includes(importSpecifier.type)) {
+    if (VALID_SPECIFIERS.includes(importSpecifier.type)) {
         // normal import: import { Component } from '/snippets/Component.mdx'
         if ((importSpecifier.renamedName && exportMap[importSpecifier.renamedName]) ||
             exportMap[importSpecifier.name]) {

package/dist/openapi/parseOpenApiString.js

@@ -1,3 +1,5 @@
+import { OpenAPIV3 } from 'openapi-types';
+const VALID_METHODS = Object.values(OpenAPIV3.HttpMethods).concat('webhook');
 /**
  *
  * @param str either the openapi or api string defined in the frontmatter
@@ -27,7 +29,7 @@ export const potentiallyParseOpenApiString = (str) => {
     }
     if (method) {
         method = method.toLowerCase();
-        if (!['get', 'put', 'post', 'delete', 'patch', 'options', 'head', 'trace', 'webhook'].includes(method)) {
+        if (!VALID_METHODS.includes(method)) {
             // invalid http method
             return undefined;
         }
@@ -63,7 +65,7 @@ export const parseOpenApiString = (str) => {
         throw new Error('improperly formatted openapi string');
     }
     method = method.toLowerCase();
-    if (!['get', 'put', 'post', 'delete', 'patch', 'options', 'head', 'trace', 'webhook'].includes(method)) {
+    if (!VALID_METHODS.includes(method)) {
         throw new Error('invalid http method');
     }
     return {