@scalar/openapi-to-markdown 0.5.44 → 1.0.0

package/dist/render-schema.js

@@ -0,0 +1,98 @@
+import { json2xml } from '@scalar/helpers/file/json2xml';
+import { getExampleFromSchema } from '@scalar/workspace-store/request-example';
+import { resolve } from '@scalar/workspace-store/resolve';
+import { inlineCode, item, list, paragraph, strong, text } from './markdown-nodes.js';
+/** Keep merged reference siblings and sorted properties stable throughout an export. */
+export const createSchemaRenderer = () => {
+    const views = new WeakMap();
+    const view = (input) => {
+        const cached = views.get(input);
+        if (cached)
+            return cached;
+        const schema = resolve.schema(input);
+        const value = schema;
+        const required = new Set(value.required ?? []);
+        const properties = Object.entries(value.properties ?? {})
+            .filter((entry) => entry[1] && typeof entry[1] === 'object')
+            .sort(([a], [b]) => Number(required.has(b)) - Number(required.has(a)) || a.localeCompare(b));
+        const result = { ...value, schema, required, properties };
+        views.set(input, result);
+        return result;
+    };
+    const details = (value, property = false) => {
+        const type = Array.isArray(value.type) ? value.type.join(' | ') : value.type;
+        const nodes = type || property ? [inlineCode(type || 'object')] : [];
+        if (value.format)
+            nodes.push(text(', format: '), inlineCode(value.format));
+        if (value.enum)
+            nodes.push(text(', possible values: '), inlineCode(value.enum.map((entry) => JSON.stringify(entry)).join(', ')));
+        if (value.default !== undefined)
+            nodes.push(text(', default: '), inlineCode(JSON.stringify(value.default)));
+        if (value.description)
+            nodes.push(text(` — ${value.description}`));
+        return nodes;
+    };
+    const render = (input, depth = 0, ancestors = []) => {
+        // The previous renderer expanded a resolved root before tracking child reference strings.
+        const identity = depth > 0 && '$ref' in input ? input.$ref : input;
+        if (depth >= 10 || ancestors.includes(identity)) {
+            return [paragraph({ type: 'emphasis', children: [text('[Circular Reference]')] })];
+        }
+        const value = view(input);
+        const childAncestors = [...ancestors, identity];
+        for (const [key, label] of [
+            ['allOf', 'All of:'],
+            ['anyOf', 'Any of:'],
+            ['oneOf', 'One of:'],
+        ]) {
+            if (value[key])
+                return [
+                    paragraph(strong(text(label))),
+                    ...value[key].flatMap((child) => render(child, depth + 1, childAncestors)),
+                ];
+        }
+        if (value.not)
+            return [paragraph(strong(text('Not:'))), ...render(value.not, depth + 1, childAncestors)];
+        if (value.type === 'object' || value.properties.length) {
+            const properties = value.properties.map(([name, schema]) => {
+                const child = view(schema);
+                const label = [inlineCode(name)];
+                if (value.required.has(name))
+                    label.push(text(' (required)'));
+                const blocks = [paragraph(strong(...label)), paragraph(...details(child, true))];
+                if (child.type === 'object' || child.properties.length) {
+                    blocks.push(...render(schema, depth + 1, childAncestors));
+                }
+                if (child.type === 'array' && child.items) {
+                    blocks.push(paragraph(strong(text('Items:'))), ...render(child.items, depth + 1, childAncestors));
+                }
+                return item(...blocks);
+            });
+            return properties.length ? [list(properties)] : [];
+        }
+        if (value.type === 'array' && value.items) {
+            const nodes = [paragraph(strong(text('Array of:'))), ...render(value.items, depth + 1, childAncestors)];
+            const constraints = [];
+            if (value.minItems !== undefined)
+                constraints.push(item(paragraph(text('Min items: '), inlineCode(value.minItems))));
+            if (value.maxItems !== undefined)
+                constraints.push(item(paragraph(text('Max items: '), inlineCode(value.maxItems))));
+            if (value.uniqueItems)
+                constraints.push(item(paragraph(text('Unique items: '), inlineCode(true))));
+            if (constraints.length)
+                nodes.push(list(constraints));
+            return nodes;
+        }
+        const nodes = details(value);
+        return nodes.length ? [paragraph(...nodes)] : [];
+    };
+    const example = (input, xml = false) => {
+        const value = getExampleFromSchema(view(input).schema, { xml });
+        return {
+            type: 'code',
+            lang: xml ? 'xml' : 'json',
+            value: xml ? json2xml(value) : (JSON.stringify(value, null, 2) ?? ''),
+        };
+    };
+    return { view, render, example };
+};

package/dist/render-security.d.ts

@@ -0,0 +1,6 @@
+import type { OpenApiDocument } from '@scalar/workspace-store/schemas/v3.2/strict/openapi-document';
+import type { RootContent } from 'mdast';
+import type { DescriptionParser } from './parse-description.js';
+/** Preserve OR between requirements and AND between schemes within a requirement. */
+export declare const renderSecurity: (requirements: OpenApiDocument["security"], schemes: NonNullable<OpenApiDocument["components"]>["securitySchemes"], description: DescriptionParser) => Promise<RootContent[]>;
+//# sourceMappingURL=render-security.d.ts.map

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

@@ -0,0 +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,EAAY,WAAW,EAAE,MAAM,OAAO,CAAA;AAGlD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAE5D,qFAAqF;AACrF,eAAO,MAAM,cAAc,GACzB,cAAc,eAAe,CAAC,UAAU,CAAC,EACzC,SAAS,WAAW,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC,iBAAiB,CAAC,EACtE,aAAa,iBAAiB,KAC7B,OAAO,CAAC,WAAW,EAAE,CA0BvB,CAAA"}

package/dist/render-security.js

@@ -0,0 +1,33 @@
+import { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref';
+import { heading, item, list, paragraph, strong, text } from './markdown-nodes.js';
+/** Preserve OR between requirements and AND between schemes within a requirement. */
+export const renderSecurity = async (requirements, schemes, description) => {
+    if (!requirements)
+        return [];
+    const nodes = [heading(4, text('Authentication'))];
+    if (!requirements.length)
+        nodes.push(paragraph(text('No authentication required.')));
+    for (const [index, requirement] of requirements.entries()) {
+        if (index)
+            nodes.push(paragraph(text('Or:')));
+        const entries = Object.entries(requirement);
+        if (!entries.length) {
+            nodes.push(paragraph(text('No authentication required.')));
+            continue;
+        }
+        const entriesNodes = [];
+        for (const [name, scopes] of entries) {
+            const blocks = [
+                paragraph(strong(text(name)), ...(scopes?.length ? [text(` Scopes: ${scopes.join(', ')}`)] : [])),
+            ];
+            const scheme = getResolvedRef(schemes?.[name]);
+            if (scheme) {
+                blocks.push({ type: 'code', value: JSON.stringify(scheme, null, 2) });
+                blocks.push(...(await description(scheme.description)));
+            }
+            entriesNodes.push(item(...blocks));
+        }
+        nodes.push(list(entriesNodes));
+    }
+    return nodes;
+};

package/dist/select-document.d.ts

@@ -0,0 +1,29 @@
+import type { HttpMethod } from '@scalar/helpers/http/http-methods';
+import type { OpenApiDocument } from '@scalar/workspace-store/schemas/v3.2/strict/openapi-document';
+/** Identify one operation by path and method, operation ID, or JSON pointer. */
+export type OperationSelector = {
+    path: string;
+    method: HttpMethod | Uppercase<HttpMethod>;
+} | {
+    operationId: string;
+} | {
+    pointer: string;
+};
+/** Select one reference page, or omit selectors for the whole document. */
+export type OpenApiRenderOptions = {
+    [Key in keyof PageSelectors]: Partial<Record<Exclude<keyof PageSelectors, Key>, never>> & Pick<PageSelectors, Key>;
+}[keyof PageSelectors] | Partial<Record<keyof PageSelectors, never>>;
+type PageSelectors = {
+    operation: OperationSelector;
+    tag: string;
+    model: string;
+    webhook: {
+        name: string;
+        method: HttpMethod | Uppercase<HttpMethod>;
+    };
+    introduction: true;
+};
+/** Scope after resolving references and migrating older documents. */
+export declare const selectDocument: (document: OpenApiDocument, options?: OpenApiRenderOptions) => OpenApiDocument;
+export {};
+//# sourceMappingURL=select-document.d.ts.map

package/dist/select-document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-document.d.ts","sourceRoot":"","sources":["../src/select-document.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AAInE,OAAO,KAAK,EAAE,eAAe,EAAkB,MAAM,8DAA8D,CAAA;AAEnH,gFAAgF;AAChF,MAAM,MAAM,iBAAiB,GACzB;IACE,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,UAAU,GAAG,SAAS,CAAC,UAAU,CAAC,CAAA;CAC3C,GACD;IACE,WAAW,EAAE,MAAM,CAAA;CACpB,GACD;IACE,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AACL,2EAA2E;AAC3E,MAAM,MAAM,oBAAoB,GAC5B;KACG,GAAG,IAAI,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,aAAa,EAAE,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,aAAa,EAAE,GAAG,CAAC;CACnH,CAAC,MAAM,aAAa,CAAC,GACtB,OAAO,CAAC,MAAM,CAAC,MAAM,aAAa,EAAE,KAAK,CAAC,CAAC,CAAA;AAE/C,KAAK,aAAa,GAAG;IACnB,SAAS,EAAE,iBAAiB,CAAA;IAC5B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,UAAU,GAAG,SAAS,CAAC,UAAU,CAAC,CAAA;KAAE,CAAA;IACrE,YAAY,EAAE,IAAI,CAAA;CACnB,CAAA;AAmKD,sEAAsE;AACtE,eAAO,MAAM,cAAc,GAAI,UAAU,eAAe,EAAE,UAAS,oBAAyB,KAAG,eA+M9F,CAAA"}

package/dist/select-document.js

@@ -0,0 +1,312 @@
+import { isObject } from '@scalar/helpers/object/is-object';
+import { getPathItemOperation, getResolvedPathItem } from '@scalar/workspace-store/helpers/for-each-path-item-operation';
+import { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref';
+const HTTP_METHODS = ['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'];
+const HTTP_METHOD_SET = new Set(HTTP_METHODS);
+const normalizeHttpMethod = (method) => {
+    const normalized = method.toLowerCase();
+    if (HTTP_METHOD_SET.has(normalized)) {
+        return normalized;
+    }
+    return null;
+};
+const normalizeJsonPointer = (pointer) => {
+    if (/~(?![01])/.test(pointer)) {
+        throw new Error(`Invalid JSON pointer escape in "${pointer}"`);
+    }
+    if (pointer.startsWith('#/')) {
+        return pointer.slice(1);
+    }
+    if (pointer.startsWith('/')) {
+        return pointer;
+    }
+    throw new Error(`Invalid JSON pointer "${pointer}". JSON pointers must start with "#/"`);
+};
+const parseJsonPointer = (pointer) => normalizeJsonPointer(pointer)
+    .slice(1)
+    .split('/')
+    .map((segment) => segment.replaceAll('~1', '/').replaceAll('~0', '~'));
+const getOperationSelectorFromPointer = (pointer) => {
+    const segments = parseJsonPointer(pointer);
+    if (segments.length !== 3 || segments[0] !== 'paths') {
+        throw new Error(`JSON pointer "${pointer}" must target an operation object under "/paths/{path}/{method}"`);
+    }
+    const path = segments[1];
+    const method = segments[2];
+    if (!path || !method) {
+        throw new Error(`JSON pointer "${pointer}" must target an operation object under "/paths/{path}/{method}"`);
+    }
+    return {
+        path,
+        method: method,
+    };
+};
+const getPathEntries = (document) => {
+    const paths = document.paths;
+    if (!isObject(paths)) {
+        return [];
+    }
+    return Object.entries(paths).flatMap(([path, pathItemRef]) => {
+        const pathItem = getResolvedPathItem(pathItemRef);
+        return pathItem ? [[path, pathItem]] : [];
+    });
+};
+const filterPathItemToSingleOperation = (pathItem, selectedMethod) => Object.fromEntries(Object.entries(pathItem).filter(([key]) => {
+    const method = normalizeHttpMethod(key);
+    return !method || method === selectedMethod;
+}));
+const findOperationByPathAndMethod = (document, selector) => {
+    const method = normalizeHttpMethod(selector.method);
+    if (!method) {
+        throw new Error(`Invalid HTTP method "${selector.method}". Supported methods: ${HTTP_METHODS.join(', ')}`);
+    }
+    const pathItemRef = document.paths?.[selector.path];
+    if (!getPathItemOperation(pathItemRef, method)) {
+        throw new Error(`Operation not found for path "${selector.path}" and method "${method.toUpperCase()}"`);
+    }
+    return {
+        path: selector.path,
+        method,
+    };
+};
+const findOperationsByOperationId = (document, operationId) => getPathEntries(document).flatMap(([path, pathItem]) => Object.entries(pathItem).flatMap(([methodKey, operation]) => {
+    const method = normalizeHttpMethod(methodKey);
+    if (!method || !isObject(operation)) {
+        return [];
+    }
+    const candidateOperationId = 'operationId' in operation && typeof operation.operationId === 'string' ? operation.operationId : undefined;
+    if (candidateOperationId !== operationId) {
+        return [];
+    }
+    return [{ path, method }];
+}));
+const resolveOperationMatch = (document, selector) => {
+    if ('pointer' in selector) {
+        return findOperationByPathAndMethod(document, getOperationSelectorFromPointer(selector.pointer));
+    }
+    if ('operationId' in selector) {
+        const matches = findOperationsByOperationId(document, selector.operationId);
+        if (!matches.length) {
+            throw new Error(`Operation with operationId "${selector.operationId}" was not found`);
+        }
+        if (matches.length > 1) {
+            const uniqueCandidates = matches.map(({ path, method }) => `"${method.toUpperCase()} ${path}"`);
+            throw new Error(`Multiple operations found for operationId "${selector.operationId}". Use { path, method } instead. Matches: ${uniqueCandidates.join(', ')}`);
+        }
+        return matches[0];
+    }
+    return findOperationByPathAndMethod(document, selector);
+};
+const filterDocumentByOperation = (document, selector) => {
+    const match = resolveOperationMatch(document, selector);
+    const pathItem = getPathEntries(document).find(([path]) => path === match.path)?.[1];
+    if (!pathItem) {
+        throw new Error(`Operation not found for path "${match.path}" and method "${match.method.toUpperCase()}"`);
+    }
+    return {
+        ...document,
+        paths: {
+            [match.path]: filterPathItemToSingleOperation(pathItem, match.method),
+        },
+    };
+};
+/** Scope after resolving references and migrating older documents. */
+export const selectDocument = (document, options = {}) => {
+    if (!isObject(options)) {
+        throw new Error('Render options must be an object');
+    }
+    const keys = Object.keys(options).filter((key) => options[key] !== undefined);
+    if (!keys.length) {
+        return document;
+    }
+    if (keys.length !== 1 || !['operation', 'tag', 'model', 'webhook', 'introduction'].includes(keys[0])) {
+        throw new Error('Specify exactly one of operation, tag, model, webhook, or introduction');
+    }
+    if (options.introduction !== undefined && options.introduction !== true) {
+        throw new Error('Introduction selector must be true');
+    }
+    for (const key of ['tag', 'model']) {
+        if (options[key] !== undefined && (typeof options[key] !== 'string' || !options[key].length)) {
+            throw new Error(`${key} selector must be a non-empty string`);
+        }
+    }
+    if (options.operation !== undefined) {
+        const selector = options.operation;
+        if (!isObject(selector) ||
+            !((Object.keys(selector).length === 1 &&
+                ('operationId' in selector
+                    ? typeof selector.operationId === 'string' && selector.operationId.length
+                    : 'pointer' in selector && typeof selector.pointer === 'string' && selector.pointer.length)) ||
+                (Object.keys(selector).length === 2 &&
+                    'path' in selector &&
+                    typeof selector.path === 'string' &&
+                    'method' in selector &&
+                    typeof selector.method === 'string'))) {
+            throw new Error('Invalid operation selector. Use { path, method }, { operationId }, or { pointer }');
+        }
+    }
+    const selected = { ...document, paths: {}, webhooks: {}, tags: [] };
+    const modelRoots = [];
+    if (options.operation) {
+        selected.paths = filterDocumentByOperation(document, options.operation).paths;
+    }
+    if (options.tag !== undefined) {
+        const metadata = document.tags?.filter((tag) => tag.name === options.tag) ?? [];
+        if (metadata.length > 1) {
+            throw new Error(`Multiple tags found for "${options.tag}"`);
+        }
+        selected.tags = metadata.length ? metadata : [{ name: options.tag }];
+        for (const [path, item] of getPathEntries(document)) {
+            const methods = HTTP_METHODS.filter((method) => getPathItemOperation(item, method)?.tags?.includes(options.tag));
+            if (methods.length) {
+                selected.paths[path] = Object.fromEntries(Object.entries(item).filter(([key]) => !HTTP_METHOD_SET.has(key) || methods.includes(key)));
+            }
+        }
+        if (!metadata.length && !Object.keys(selected.paths ?? {}).length) {
+            throw new Error(`Tag "${options.tag}" was not found`);
+        }
+    }
+    if (options.model !== undefined) {
+        const schema = document.components?.schemas?.[options.model];
+        if (schema === undefined || !Object.hasOwn(document.components?.schemas ?? {}, options.model)) {
+            throw new Error(`Model "${options.model}" was not found`);
+        }
+        modelRoots.push(schema);
+    }
+    if (options.webhook !== undefined) {
+        const selector = options.webhook;
+        if (!isObject(selector) ||
+            typeof selector.name !== 'string' ||
+            !selector.name ||
+            typeof selector.method !== 'string' ||
+            Object.keys(selector).length !== 2) {
+            throw new Error('Invalid webhook selector. Use { name, method }');
+        }
+        const method = normalizeHttpMethod(selector.method);
+        if (!method) {
+            throw new Error(`Invalid HTTP method "${selector.method}"`);
+        }
+        const item = getResolvedPathItem(document.webhooks?.[selector.name]);
+        if (!item || !getPathItemOperation(item, method)) {
+            throw new Error(`Webhook "${selector.name}" with method "${method.toUpperCase()}" was not found`);
+        }
+        selected.webhooks = { [selector.name]: filterPathItemToSingleOperation(item, method) };
+    }
+    const securityNames = new Set();
+    const tagNames = new Set();
+    for (const items of [selected.paths, selected.webhooks]) {
+        for (const [path, itemRef] of Object.entries(items ?? {})) {
+            const item = getResolvedPathItem(itemRef);
+            const scoped = { ...item, parameters: undefined, servers: undefined };
+            for (const method of HTTP_METHODS) {
+                const operation = getPathItemOperation(item, method);
+                if (!operation) {
+                    continue;
+                }
+                const parameters = new Map();
+                for (const ref of [...(item.parameters ?? []), ...(operation.parameters ?? [])]) {
+                    const parameter = getResolvedRef(ref);
+                    if (parameter) {
+                        parameters.set(`${parameter.in}:${parameter.name}`, ref);
+                    }
+                }
+                const security = operation.security ?? document.security ?? [];
+                for (const requirement of security) {
+                    for (const name of Object.keys(requirement)) {
+                        securityNames.add(name);
+                    }
+                }
+                for (const name of operation.tags ?? []) {
+                    tagNames.add(name);
+                }
+                scoped[method] = {
+                    ...operation,
+                    parameters: [...parameters.values()],
+                    servers: operation.servers ?? item.servers ?? document.servers,
+                    security,
+                    tags: options.tag !== undefined ? [options.tag] : operation.tags,
+                };
+            }
+            items[path] = scoped;
+        }
+    }
+    if (options.operation || options.webhook) {
+        selected.tags = document.tags?.filter((tag) => tagNames.has(tag.name)) ?? [];
+    }
+    if (options.introduction) {
+        for (const requirement of document.security ?? []) {
+            for (const name of Object.keys(requirement)) {
+                securityNames.add(name);
+            }
+        }
+    }
+    else {
+        selected.servers = [];
+        selected.security = undefined;
+    }
+    const schemas = document.components?.schemas ?? {};
+    const needed = new Set(options.model !== undefined ? [options.model] : []);
+    const visited = new WeakSet();
+    const references = new Set();
+    const opaqueValues = new Set(['example', 'examples', 'default', 'enum', 'const', 'value', 'dataValue']);
+    const namedMaps = new Set([
+        'paths',
+        'webhooks',
+        'responses',
+        'content',
+        'headers',
+        'links',
+        'encoding',
+        'variables',
+        'parameters',
+        'requestBodies',
+        'securitySchemes',
+        'pathItems',
+        'callbacks',
+        'mediaTypes',
+        'additionalOperations',
+        'schemas',
+        'properties',
+        'patternProperties',
+        '$defs',
+        'definitions',
+        'dependentSchemas',
+    ]);
+    const visit = (value, namedLevels = 0) => {
+        if (!value || typeof value !== 'object' || visited.has(value)) {
+            return;
+        }
+        visited.add(value);
+        if (!namedLevels && '$ref' in value && typeof value.$ref === 'string') {
+            const ref = value.$ref;
+            if (!references.has(ref)) {
+                references.add(ref);
+                if (ref.startsWith('#/components/schemas/')) {
+                    const name = parseJsonPointer(ref)[2];
+                    if (Object.hasOwn(schemas, name)) {
+                        needed.add(name);
+                        visit(schemas[name]);
+                    }
+                }
+                visit(getResolvedRef(value), namedLevels);
+            }
+        }
+        for (const [key, child] of Object.entries(value)) {
+            // Names such as "example" are valid map entries; only keyword positions hold opaque data.
+            if (key !== '$ref-value' && (namedLevels || (!opaqueValues.has(key) && !key.startsWith('x-')))) {
+                const childNamedLevels = namedLevels ? namedLevels - 1 : key === 'callbacks' ? 2 : namedMaps.has(key) ? 1 : 0;
+                visit(child, childNamedLevels);
+            }
+        }
+    };
+    visit({ paths: selected.paths, webhooks: selected.webhooks });
+    for (const root of modelRoots) {
+        visit(root);
+    }
+    selected.components = {
+        ...document.components,
+        schemas: Object.fromEntries(Object.entries(schemas).filter(([name]) => needed.has(name))),
+        securitySchemes: Object.fromEntries(Object.entries(document.components?.securitySchemes ?? {}).filter(([name]) => securityNames.has(name))),
+    };
+    return selected;
+};

package/package.json

@@ -16,7 +16,7 @@
     "llm",
     "swagger"
   ],
-  "version": "0.5.44",
+  "version": "1.0.0",
   "engines": {
     "node": ">=22"
   },
@@ -28,16 +28,6 @@
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    },
-    "./*.css": {
-      "import": "./dist/*.css",
-      "require": "./dist/*.css",
-      "default": "./dist/*.css"
-    },
-    "./css/*.css": {
-      "import": "./dist/css/*.css",
-      "require": "./dist/css/*.css",
-      "default": "./dist/css/*.css"
     }
   },
   "files": [
@@ -45,34 +35,32 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "html-minifier-terser": "^7.2.0",
+    "@scalar/code-highlight": "0.4.6",
+    "@scalar/helpers": "0.12.0",
+    "@scalar/json-magic": "0.14.0",
+    "@scalar/openapi-upgrader": "0.2.17",
+    "@scalar/workspace-store": "0.62.0",
     "rehype-parse": "^9.0.1",
     "rehype-remark": "^10.0.1",
     "rehype-sanitize": "^6.0.0",
+    "rehype-stringify": "^10.0.1",
     "remark-gfm": "^4.0.1",
+    "remark-parse": "^11.0.0",
+    "remark-rehype": "^11.1.2",
     "remark-stringify": "^11.0.0",
-    "unified": "^11.0.5",
-    "vue": "^3.5.40",
-    "@scalar/components": "0.29.1",
-    "@scalar/json-magic": "0.13.4",
-    "@scalar/helpers": "0.11.3",
-    "@scalar/workspace-store": "0.60.0"
+    "unified": "^11.0.5"
   },
   "devDependencies": {
     "@hono/node-server": "^1.19.10",
-    "@types/html-minifier-terser": "^7.0.2",
-    "@vitejs/plugin-vue": "^6.0.8",
-    "@vue/test-utils": "2.4.11",
-    "hono": "^4.12.7",
-    "vite": "8.1.5",
-    "vitest": "4.1.10",
-    "vue": "^3.5.40",
-    "@scalar/galaxy": "0.7.0"
+    "@scalar/galaxy": "0.7.1",
+    "@types/mdast": "^4.0.4",
+    "hono": "^4.13.7",
+    "vitest": "4.1.10"
   },
   "scripts": {
-    "build": "vite build && vue-tsc -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
     "dev": "tsx watch playground/index.ts",
     "test": "vitest --run",
-    "types:check": "vue-tsc --noEmit"
+    "types:check": "tsgo --noEmit"
   }
 }

package/dist/components/MarkdownReference.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=MarkdownReference.test.d.ts.map

package/dist/components/MarkdownReference.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MarkdownReference.test.d.ts","sourceRoot":"","sources":["../../src/components/MarkdownReference.test.ts"],"names":[],"mappings":""}

package/dist/components/MarkdownReference.vue.d.ts

@@ -1,9 +0,0 @@
-import type { OpenApiDocument } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
-type MarkdownDocument = Partial<OpenApiDocument> & Pick<OpenApiDocument, 'openapi' | 'info'>;
-type __VLS_Props = {
-    content: MarkdownDocument;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;
-//# sourceMappingURL=MarkdownReference.vue.d.ts.map

package/dist/components/MarkdownReference.vue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MarkdownReference.vue.d.ts","sourceRoot":"","sources":["../../src/components/MarkdownReference.vue"],"names":[],"mappings":"AA4kBA,OAAO,KAAK,EACV,eAAe,EAMhB,MAAM,8DAA8D,CAAA;AAQrE,KAAK,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,GAC9C,IAAI,CAAC,eAAe,EAAE,SAAS,GAAG,MAAM,CAAC,CAAA;AAuC3C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAC;AAouBF,QAAA,MAAM,YAAY,kSAEhB,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}

package/dist/components/Schema.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Schema.test.d.ts.map

package/dist/components/Schema.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Schema.test.d.ts","sourceRoot":"","sources":["../../src/components/Schema.test.ts"],"names":[],"mappings":""}

package/dist/components/Schema.vue.d.ts

@@ -1,9 +0,0 @@
-import type { MaybeRefSchemaObject } from '@scalar/workspace-store/schemas/v3.1/strict/schema';
-type __VLS_Props = {
-    schema: MaybeRefSchemaObject;
-    depth?: number;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;
-//# sourceMappingURL=Schema.vue.d.ts.map

package/dist/components/Schema.vue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Schema.vue.d.ts","sourceRoot":"","sources":["../../src/components/Schema.vue"],"names":[],"mappings":"AAiZA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oDAAoD,CAAA;AAI9F,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,oBAAoB,CAAA;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAC;AAqhBF,QAAA,MAAM,YAAY,kSAEhB,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}

package/dist/components/XmlOrJson.vue.d.ts

@@ -1,8 +0,0 @@
-type __VLS_Props = {
-    xml?: boolean;
-    modelValue: unknown;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;
-//# sourceMappingURL=XmlOrJson.vue.d.ts.map

package/dist/components/XmlOrJson.vue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"XmlOrJson.vue.d.ts","sourceRoot":"","sources":["../../src/components/XmlOrJson.vue"],"names":[],"mappings":"AA2BA,KAAK,WAAW,GAAG;IACjB,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,UAAU,EAAE,OAAO,CAAA;CACpB,CAAC;AA+CF,QAAA,MAAM,YAAY,kSAEhB,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}

package/dist/create-markdown-from-openapi.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=create-markdown-from-openapi.test.d.ts.map

package/dist/create-markdown-from-openapi.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-markdown-from-openapi.test.d.ts","sourceRoot":"","sources":["../src/create-markdown-from-openapi.test.ts"],"names":[],"mappings":""}