@mintlify/common 1.0.1221 → 1.0.1222

package/dist/mdx/islands/sha256.js

@@ -0,0 +1,71 @@
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+const at = (words, index) => { var _a; return (_a = words[index]) !== null && _a !== void 0 ? _a : 0; };
+export const sha256Hex = (input) => {
+    const bytes = new TextEncoder().encode(input);
+    const bitLength = bytes.length * 8;
+    const paddedLength = Math.ceil((bytes.length + 9) / 64) * 64;
+    const data = new Uint8Array(paddedLength);
+    data.set(bytes);
+    data[bytes.length] = 0x80;
+    const view = new DataView(data.buffer);
+    view.setUint32(paddedLength - 8, Math.floor(bitLength / 0x100000000));
+    view.setUint32(paddedLength - 4, bitLength >>> 0);
+    const h = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const w = new Uint32Array(64);
+    for (let offset = 0; offset < paddedLength; offset += 64) {
+        for (let i = 0; i < 16; i++)
+            w[i] = view.getUint32(offset + i * 4);
+        for (let i = 16; i < 64; i++) {
+            const w15 = at(w, i - 15);
+            const w2 = at(w, i - 2);
+            const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ (w15 >>> 3);
+            const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ (w2 >>> 10);
+            w[i] = (at(w, i - 16) + s0 + at(w, i - 7) + s1) >>> 0;
+        }
+        let a = at(h, 0);
+        let b = at(h, 1);
+        let c = at(h, 2);
+        let d = at(h, 3);
+        let e = at(h, 4);
+        let f = at(h, 5);
+        let g = at(h, 6);
+        let hh = at(h, 7);
+        for (let i = 0; i < 64; i++) {
+            const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+            const ch = (e & f) ^ (~e & g);
+            const t1 = (hh + s1 + ch + at(K, i) + at(w, i)) >>> 0;
+            const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const t2 = (s0 + maj) >>> 0;
+            hh = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        h[0] = (at(h, 0) + a) >>> 0;
+        h[1] = (at(h, 1) + b) >>> 0;
+        h[2] = (at(h, 2) + c) >>> 0;
+        h[3] = (at(h, 3) + d) >>> 0;
+        h[4] = (at(h, 4) + e) >>> 0;
+        h[5] = (at(h, 5) + f) >>> 0;
+        h[6] = (at(h, 6) + g) >>> 0;
+        h[7] = (at(h, 7) + hh) >>> 0;
+    }
+    return Array.from(h, (word) => word.toString(16).padStart(8, '0')).join('');
+};

package/dist/mdx/islands/static-expressions.d.ts

@@ -0,0 +1,24 @@
+import type { Expression, Identifier, Node as EstreeNode } from 'estree-jsx';
+export { UNSAFE_OBJECT_KEYS as UNSAFE_KEYS } from '../static-object-keys.js';
+export type ConstEntry = {
+    expression: Expression | undefined;
+};
+type ParenthesizedExpression = {
+    type: 'ParenthesizedExpression';
+    expression: Expression;
+};
+export type Failure = {
+    reason: 'function' | 'jsx' | 'identifier' | 'const' | 'key' | 'expression';
+    name?: string;
+};
+type Converted = {
+    ok: true;
+    expression: Expression;
+} | ({
+    ok: false;
+} & Failure);
+export declare const IDENTIFIER_NAME: RegExp;
+export declare const literal: (value: string | number | boolean | null) => Expression;
+export declare const identifier: (name: string) => Identifier;
+export declare const toStaticExpression: (node: EstreeNode | ParenthesizedExpression | null | undefined, consts: Map<string, ConstEntry> | undefined, usedConsts: Set<string>) => Converted;
+export declare const valueToExpression: (value: unknown, depth?: number) => Expression | undefined;

package/dist/mdx/islands/static-expressions.js

@@ -0,0 +1,169 @@
+import { UNSAFE_OBJECT_KEYS as UNSAFE_KEYS } from '../static-object-keys.js';
+export { UNSAFE_OBJECT_KEYS as UNSAFE_KEYS } from '../static-object-keys.js';
+export const IDENTIFIER_NAME = /^[A-Za-z_$][\w$]*$/;
+export const literal = (value) => ({
+    type: 'Literal',
+    value,
+});
+export const identifier = (name) => ({ type: 'Identifier', name });
+const unwrapParentheses = (node) => node.type === 'ParenthesizedExpression' ? unwrapParentheses(node.expression) : node;
+export const toStaticExpression = (node, consts, usedConsts) => {
+    if (!node)
+        return { ok: false, reason: 'expression' };
+    switch (node.type) {
+        case 'ParenthesizedExpression':
+            return toStaticExpression(node.expression, consts, usedConsts);
+        case 'Literal': {
+            if ('regex' in node || 'bigint' in node)
+                return { ok: false, reason: 'expression' };
+            const { value } = node;
+            if (value === null ||
+                typeof value === 'string' ||
+                typeof value === 'boolean' ||
+                (typeof value === 'number' && Number.isFinite(value))) {
+                return { ok: true, expression: literal(value) };
+            }
+            return { ok: false, reason: 'expression' };
+        }
+        case 'TemplateLiteral': {
+            if (node.expressions.length > 0)
+                return { ok: false, reason: 'expression' };
+            return {
+                ok: true,
+                expression: literal(node.quasis.map((quasi) => { var _a; return (_a = quasi.value.cooked) !== null && _a !== void 0 ? _a : quasi.value.raw; }).join('')),
+            };
+        }
+        case 'UnaryExpression': {
+            const argument = unwrapParentheses(node.argument);
+            if (node.operator === '-' &&
+                argument.type === 'Literal' &&
+                typeof argument.value === 'number' &&
+                Number.isFinite(argument.value)) {
+                return {
+                    ok: true,
+                    expression: {
+                        type: 'UnaryExpression',
+                        operator: '-',
+                        prefix: true,
+                        argument: literal(argument.value),
+                    },
+                };
+            }
+            return { ok: false, reason: 'expression' };
+        }
+        case 'ArrayExpression': {
+            const elements = [];
+            for (const element of node.elements) {
+                if (!element || element.type === 'SpreadElement')
+                    return { ok: false, reason: 'expression' };
+                const converted = toStaticExpression(element, consts, usedConsts);
+                if (!converted.ok)
+                    return converted;
+                elements.push(converted.expression);
+            }
+            return { ok: true, expression: { type: 'ArrayExpression', elements } };
+        }
+        case 'ObjectExpression': {
+            const properties = [];
+            for (const property of node.properties) {
+                if (property.type === 'SpreadElement' || property.computed) {
+                    return { ok: false, reason: 'expression' };
+                }
+                if (property.kind !== 'init' || property.method)
+                    return { ok: false, reason: 'function' };
+                let key;
+                if (property.key.type === 'Identifier') {
+                    key = property.key.name;
+                }
+                else if (property.key.type === 'Literal' &&
+                    (typeof property.key.value === 'string' || typeof property.key.value === 'number')) {
+                    key = String(property.key.value);
+                }
+                if (key === undefined)
+                    return { ok: false, reason: 'expression' };
+                if (UNSAFE_KEYS.has(key))
+                    return { ok: false, reason: 'key', name: key };
+                const converted = toStaticExpression(property.value, consts, usedConsts);
+                if (!converted.ok)
+                    return converted;
+                const staticProperty = {
+                    type: 'Property',
+                    key: IDENTIFIER_NAME.test(key) ? identifier(key) : literal(key),
+                    value: converted.expression,
+                    kind: 'init',
+                    method: false,
+                    shorthand: false,
+                    computed: false,
+                };
+                properties.push(staticProperty);
+            }
+            return { ok: true, expression: { type: 'ObjectExpression', properties } };
+        }
+        case 'Identifier': {
+            if (node.name === 'undefined')
+                return { ok: true, expression: identifier('undefined') };
+            const entry = consts === null || consts === void 0 ? void 0 : consts.get(node.name);
+            if (!entry)
+                return { ok: false, reason: 'identifier', name: node.name };
+            if (!entry.expression)
+                return { ok: false, reason: 'const', name: node.name };
+            usedConsts.add(node.name);
+            return { ok: true, expression: identifier(node.name) };
+        }
+        case 'ArrowFunctionExpression':
+        case 'FunctionExpression':
+            return { ok: false, reason: 'function' };
+        case 'JSXElement':
+        case 'JSXFragment':
+            return { ok: false, reason: 'jsx' };
+        default:
+            return { ok: false, reason: 'expression' };
+    }
+};
+export const valueToExpression = (value, depth = 0) => {
+    if (depth > 32)
+        return undefined;
+    if (value === undefined)
+        return identifier('undefined');
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+        return literal(value);
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            return undefined;
+        return value < 0 || Object.is(value, -0)
+            ? { type: 'UnaryExpression', operator: '-', prefix: true, argument: literal(-value) }
+            : literal(value);
+    }
+    if (Array.isArray(value)) {
+        const elements = [];
+        for (const element of value) {
+            const converted = valueToExpression(element, depth + 1);
+            if (!converted)
+                return undefined;
+            elements.push(converted);
+        }
+        return { type: 'ArrayExpression', elements };
+    }
+    if (typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype) {
+        const properties = [];
+        for (const [key, entry] of Object.entries(value)) {
+            if (UNSAFE_KEYS.has(key))
+                return undefined;
+            const converted = valueToExpression(entry, depth + 1);
+            if (!converted)
+                return undefined;
+            properties.push({
+                type: 'Property',
+                key: IDENTIFIER_NAME.test(key) ? identifier(key) : literal(key),
+                value: converted,
+                kind: 'init',
+                method: false,
+                shorthand: false,
+                computed: false,
+            });
+        }
+        return { type: 'ObjectExpression', properties };
+    }
+    return undefined;
+};

package/dist/mdx/islands/types.d.ts

@@ -0,0 +1,36 @@
+import type { Parent } from 'mdast';
+import type { MdxJsxFlowElement, MdxJsxTextElement } from 'mdast-util-mdx-jsx';
+export type IslandImport = {
+    local: string;
+    pkg: string;
+    imported: string;
+};
+export type IslandSpec = {
+    id: string;
+    pagePath: string;
+    kind: 'inline' | 'snippet';
+    imports: IslandImport[];
+    module: string;
+};
+export type IslandError = {
+    line?: number;
+    code?: 'side-effect-import-without-island';
+    message: string;
+};
+export type ExtractPackageIslandsOptions = {
+    packageNames: ReadonlySet<string>;
+    pagePath: string;
+    exportedConsts?: Record<string, unknown>;
+    packageSnippets?: ReadonlySet<string>;
+};
+export type IslandRoot = {
+    id: string;
+    name: string;
+    node: MdxJsxFlowElement | MdxJsxTextElement;
+    parent: Parent;
+};
+export type ExtractPackageIslandsResult = {
+    islands: IslandSpec[];
+    errors: IslandError[];
+    roots: IslandRoot[];
+};

package/dist/mdx/islands/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -17,6 +17,7 @@ import { visitParents } from 'unist-util-visit-parents';
 import { JSXParser } from '../../lib/jsxParser.js';
 import { decodeMdxFragmentCode } from '../../preprocessMdxFragmentCode.js';
 import { getAST } from '../../remark.js';
+import { UNSAFE_OBJECT_KEYS as UNSAFE_KEYS } from '../../static-object-keys.js';
 import { getExportedFunctionNames } from './remarkMdxClientComponentBoundaries.js';
 const REMARK_REHYPE_OPTIONS = {
     allowDangerousHtml: true,
@@ -45,7 +46,6 @@ const UNKNOWN = Symbol('unknown');
  */
 const MAX_ANALYSIS_NODES = 50000;
 const MAX_ANALYSIS_DEPTH = 1000;
-const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 /**
  * Compile-time expansion of `<MDX>` inside `{…}` expressions.
  *

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

@@ -1,4 +1,7 @@
 import type { Root } from 'mdast';
-import { Parent } from 'unist';
+import type { MdxjsEsm } from 'mdast-util-mdx';
+import { Node, Parent } from 'unist';
 import { VFile } from 'vfile';
+export declare const injectedSnippetFile: (node: MdxjsEsm) => string | undefined;
+export declare const findSnippetCycle: (tree: Node, snippetTreeMap: Record<string, Root>) => string[] | undefined;
 export declare const remarkMdxInjectSnippets: (snippetTreeMap: Record<string, Root>) => (tree: Parent, file: VFile) => void;

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

@@ -1,25 +1,76 @@
 import { removePosition } from 'unist-util-remove-position';
 import { visit, SKIP } from 'unist-util-visit';
+export const injectedSnippetFile = (node) => {
+    const data = node.data;
+    return data && 'snippetFile' in data && typeof data.snippetFile === 'string'
+        ? data.snippetFile
+        : undefined;
+};
+const snippetFileOf = (node) => {
+    if (node.type !== 'mdxJsxFlowElement')
+        return undefined;
+    const mdxJsxFlowElement = node;
+    if (mdxJsxFlowElement.name !== 'Snippet')
+        return undefined;
+    const fileAttr = mdxJsxFlowElement.attributes.find((attr) => attr.type === 'mdxJsxAttribute' && attr.name === 'file');
+    return typeof (fileAttr === null || fileAttr === void 0 ? void 0 : fileAttr.value) === 'string' ? fileAttr.value : undefined;
+};
+export const findSnippetCycle = (tree, snippetTreeMap) => {
+    const acyclic = new Set();
+    const references = (node) => {
+        const names = [];
+        visit(node, (child) => {
+            const name = snippetFileOf(child);
+            if (name === undefined || !snippetTreeMap[name])
+                return;
+            names.push(name);
+            return SKIP;
+        });
+        return names;
+    };
+    const walk = (name, chain) => {
+        if (chain.includes(name))
+            return [...chain.slice(chain.indexOf(name)), name];
+        const snippet = snippetTreeMap[name];
+        if (acyclic.has(name) || !snippet)
+            return undefined;
+        for (const next of references(snippet)) {
+            const cycle = walk(next, [...chain, name]);
+            if (cycle)
+                return cycle;
+        }
+        acyclic.add(name);
+        return undefined;
+    };
+    for (const name of references(tree)) {
+        const cycle = walk(name, []);
+        if (cycle)
+            return cycle;
+    }
+    return undefined;
+};
 export const remarkMdxInjectSnippets = (snippetTreeMap) => (tree, file) => {
     visit(tree, (node, index, parent) => {
-        if (parent && index != null && node.type === 'mdxJsxFlowElement') {
-            const mdxJsxFlowElement = node;
-            if (mdxJsxFlowElement.name === 'Snippet') {
-                const fileAttr = mdxJsxFlowElement.attributes.find((attr) => attr.type === 'mdxJsxAttribute' && attr.name === 'file');
-                const name = fileAttr === null || fileAttr === void 0 ? void 0 : fileAttr.value;
-                if (typeof name === 'string') {
-                    const snippet = snippetTreeMap[name];
-                    if (snippet) {
-                        const fragment = structuredClone(snippet);
-                        removePosition(fragment);
-                        parent.children.splice(index, 1, ...fragment.children);
-                        return [SKIP, index];
-                    }
-                    else {
-                        file.message('Cannot expand missing snippet `' + name + '`', node, 'remark-mdx-inject-snippets');
-                    }
-                }
+        if (!parent || index == null)
+            return;
+        const name = snippetFileOf(node);
+        if (name === undefined)
+            return;
+        const snippet = snippetTreeMap[name];
+        if (snippet) {
+            const fragment = structuredClone(snippet);
+            removePosition(fragment);
+            for (const child of fragment.children) {
+                if (child.type !== 'mdxjsEsm')
+                    continue;
+                const data = Object.assign(Object.assign({}, child.data), { snippetFile: name });
+                child.data = data;
             }
+            parent.children.splice(index, 1, ...fragment.children);
+            return [SKIP, index];
+        }
+        else {
+            file.message('Cannot expand missing snippet `' + name + '`', node, 'remark-mdx-inject-snippets');
         }
     });
 };

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

@@ -1,5 +1,6 @@
 import { remove } from 'unist-util-remove';
 import { CONTINUE, visit } from 'unist-util-visit';
+import { UNSAFE_OBJECT_KEYS } from '../../static-object-keys.js';
 import { isMdxJsEsm } from '../../utils.js';
 const objectEstree = {
     type: 'Program',
@@ -214,7 +215,6 @@ export function rebuildStyleValue(properties) {
 function isJsxLikeNode(value) {
     return (typeof value === 'object' && value !== null && 'type' in value && typeof value.type === 'string');
 }
-const UNSAFE_OBJECT_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 export const MAX_PURE_DATA_DEPTH = 32;
 function isPureDataLiteral(node) {
     if (node.type !== 'Literal' || 'regex' in node || 'bigint' in node)

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

@@ -2,5 +2,6 @@ import type { Root } from 'mdast';
 type Options = {
     path?: string;
 };
+export declare const resolveRelativeUrl: (path: string, url: string, isPageLink: boolean) => string;
 export declare const remarkResolveRelativeLinks: (options?: Options) => (tree: Root) => void;
 export {};

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

@@ -23,14 +23,17 @@ const ATTR_BY_TAG = {
     img: 'src',
     source: 'src',
 };
+const baseDirOf = (path) => {
+    const dir = posix.dirname(path.replace(/^\/+/, '').replace(/\.mdx?$/i, ''));
+    return dir === '.' || dir === '' ? '/' : `/${dir}`;
+};
+export const resolveRelativeUrl = (path, url, isPageLink) => isRelative(url) ? resolveRelative(baseDirOf(path), url, isPageLink) : url;
 export const remarkResolveRelativeLinks = (options = {}) => {
     return (tree) => {
         const { path } = options;
         if (!path)
             return;
-        const stripped = path.replace(/^\/+/, '').replace(/\.mdx?$/i, '');
-        const dir = posix.dirname(stripped);
-        const baseDir = dir === '.' || dir === '' ? '/' : `/${dir}`;
+        const baseDir = baseDirOf(path);
         visit(tree, (node) => {
             if (node.type === 'link' || node.type === 'image') {
                 const linkOrImg = node;

package/dist/mdx/server-only/getMdx.d.ts

@@ -5,6 +5,15 @@ import type { PluggableList } from 'unified';
 import { MdxExtracts } from '../../index.js';
 import { createSnippetTreeMap, type Snippet } from './getMdx/snippets.js';
 type RunWithTracingFn = <T>(spanName: string, fn: () => Promise<T>) => Promise<T>;
+export type PackageBuildInput = {
+    baseUrl: string;
+    islands: Record<string, {
+        html?: string;
+        prefix: string;
+    }>;
+    packageNames: string[];
+    packageSnippets?: string[];
+};
 export type GetMdxType = {
     mdxSource: SerializeSuccess;
     mdxSourceWithNoJs: SerializeSuccess;
@@ -13,7 +22,7 @@ export type GetMdxType = {
     panelMdxSourceWithNoJs?: SerializeSuccess;
     parseFailed?: boolean;
 };
-export declare function getMdx({ path, content, metadata, snippets, subdomain, codeStyling, config, tailwindSelectors, pageType, trace, customLanguages, variables, rehypePlugins, remarkPlugins, earlyRemarkPlugins, allowedComponents, singlePass, }: {
+export declare function getMdx({ path, content, metadata, snippets, subdomain, codeStyling, config, tailwindSelectors, pageType, trace, customLanguages, variables, rehypePlugins, remarkPlugins, earlyRemarkPlugins, allowedComponents, packageBuild, singlePass, }: {
     path: string;
     content: string;
     metadata: PageMetaTags;
@@ -30,6 +39,7 @@ export declare function getMdx({ path, content, metadata, snippets, subdomain, c
     remarkPlugins?: PluggableList;
     earlyRemarkPlugins?: PluggableList;
     allowedComponents?: string[];
+    packageBuild?: PackageBuildInput;
     singlePass?: boolean;
 }): Promise<GetMdxType>;
 export { createSnippetTreeMap, type Snippet };