@redocly/realm 0.138.0-next.15 → 0.138.0-next.17

package/dist/server/plugins/markdown/attribute-resolvers/resolve-svg-content.d.ts

@@ -0,0 +1,4 @@
+import type { Node } from '@markdoc/markdoc';
+import type { MarkdocResolveContext } from '../../../types';
+export declare function resolveSvgContent(node: Node, attrName: string, relativePath: string, { context, actions }: MarkdocResolveContext): Promise<void>;
+//# sourceMappingURL=resolve-svg-content.d.ts.map

package/dist/server/plugins/markdown/attribute-resolvers/resolve-svg-content.js

@@ -0,0 +1 @@
+import{getNodeAttribute as m}from"../../../../markdoc/helpers/get-node-attribute.js";import{setNodeAttributeValue as p}from"../../../../markdoc/helpers/set-node-attribute-value.js";import{optimize as l}from"../../../../compiled/svgo/svgo-node.js";import{slug as c}from"../../../utils/index.js";import{MdResolveError as d}from"./md-resolve-error.js";import{resolvePathInMarkdown as u}from"../resolve-path-in-markdown.js";async function b(e,r,n,{context:i,actions:s}){const o=m(e,r),a=s.contentDir;if(o){const t=u(o,n,a);if(!i.fs.exists(t))throw new d(`File ${t} does not exist`,{rawLink:o});const f=l(await i.fs.read(t),{plugins:[{name:"prefixIds",params:{prefix:c(t).replaceAll(/[/.]/g,"-")}}]}).data;p(e,r+"RawContent",f)}}export{b as resolveSvgContent};

package/dist/server/plugins/markdown/attribute-resolvers/resolve-tag-raw-content.d.ts

@@ -0,0 +1,4 @@
+import type { Node } from '@markdoc/markdoc';
+import type { MarkdocResolveContext } from '../../../types';
+export declare function resolveTagRawContent(node: Node, attrName: string, _relativePath: string, { readSourceLines }: MarkdocResolveContext): Promise<void>;
+//# sourceMappingURL=resolve-tag-raw-content.d.ts.map

package/dist/server/plugins/markdown/attribute-resolvers/resolve-tag-raw-content.js

@@ -0,0 +1,2 @@
+import l from"@markdoc/markdoc";import{setNodeAttributeValue as u}from"../../../../markdoc/helpers/set-node-attribute-value.js";async function P(t,r,e,{readSourceLines:n}){if(t.children.length===0&&typeof t.attributes[r]=="string")return;if(t.inline){u(t,r,m(t)),t.children=[];return}if(n===void 0)return;const[i,c,o]=t.lines;if(i===void 0||c===void 0||o===void 0)return;const s=n(),f=p(s[i]??""),a=s.slice(c,o).map(h=>g(h,f)),d=b(a).join(`
+`).replace(/^(?:[ \t]*\n)+/,"").trimEnd();u(t,r,d),t.children=[]}function m(t){return l.format(new l.Ast.Node("inline",{},t.children)).trim()}function p(t){return t.slice(0,Math.max(t.indexOf("{%"),0)).split(">").length-1}function g(t,r){let e=t;for(let n=0;n<r;n+=1){const i=e.match(/^ {0,3}> ?/);if(!i)break;e=e.slice(i[0].length)}return e}function b(t){const r=t.filter(n=>n.trim()!=="").map(n=>n.match(/^[ \t]*/)?.[0]??""),e=r.reduce(x,r[0]??"");return t.map(n=>n.startsWith(e)?n.slice(e.length):n.trimStart())}function x(t,r){let e=0;for(;e<t.length&&e<r.length&&t[e]===r[e];)e+=1;return t.slice(0,e)}export{P as resolveTagRawContent};

package/dist/server/plugins/markdown/attribute-resolvers/utils.d.ts

@@ -0,0 +1,4 @@
+import type { Node, Tag } from '@markdoc/markdoc';
+export declare function getLinkOriginalAttrName(attributeName: string): `redocly:::linkOriginal:${string}`;
+export declare function getOptionalAttribute<T>(node: Node | Tag, attrName: string): T | undefined;
+//# sourceMappingURL=utils.d.ts.map

package/dist/server/plugins/markdown/attribute-resolvers/utils.js

@@ -0,0 +1 @@
+import{LINK_ORIGINAL_ATTR_NAME as e}from"../../../constants/common.js";import{getNodeAttribute as i}from"../../../../markdoc/helpers/get-node-attribute.js";function u(t){return`${e}:${t}`}function A(t,r){return i(t,r)??void 0}export{u as getLinkOriginalAttrName,A as getOptionalAttribute};

package/dist/server/plugins/markdown/compiler.d.ts

@@ -0,0 +1,43 @@
+import type { Config, Node, ValidationType } from '@markdoc/markdoc';
+import type { Store } from '../../store.js';
+import type { LifecycleContext, MarkdownParseInput, MarkdocResolveContext } from '../../types';
+import type { MarkdocError } from '../../../types/index.js';
+export type ResolvableType = ValidationType & {
+    resolver?: string;
+};
+export type MarkdocConfigProps = {
+    partials: Record<string, Node>;
+    relativePath: string;
+    nodes: any;
+    tags: any;
+} & Config;
+type ParsedAstChunk = {
+    ast: Node;
+    rawContent: string;
+    resolveErrors: MarkdocError[];
+    markdocErrors: MarkdocError[];
+    validatedAtRevision: number;
+    sharedDataDeps?: Set<string>;
+    dynamicMarkdocComponents?: Set<string>;
+    relativePath: string;
+};
+type MarkdocInfo = {
+    sharedDataDeps?: Set<string>;
+    dynamicMarkdocComponents?: string[];
+    partials?: string[];
+    tagList?: string[];
+    htmlTagsList?: string[];
+    tagOccurrence?: Record<string, number>;
+    codeSnippetLanguages?: Record<string, number>;
+    codeWalkthroughLanguages?: Record<string, number>;
+};
+export declare function resolveAndValidateMarkdoc(parsedAstChunk: ParsedAstChunk, markdocOpts: Config | undefined, context: MarkdocResolveContext): Promise<MarkdocInfo>;
+export declare function getAst(relativePath: string, rawContent: string): ParsedAstChunk;
+export declare function extractMdFirstHeading(relativePath: string, context: LifecycleContext): Promise<string | undefined>;
+export declare function validateAllMarkdowns(store: Store, context?: LifecycleContext): Promise<void>;
+export declare function parseAndResolveMarkdoc(input: MarkdownParseInput, markdocOpts: Config | undefined, rootContext: MarkdocResolveContext, resource?: string): Promise<import("../../types").LoadResult<{
+    ast: Node;
+    info: MarkdocInfo;
+}>>;
+export {};
+//# sourceMappingURL=compiler.d.ts.map

package/dist/server/plugins/markdown/compiler.js

@@ -0,0 +1 @@
+import M from"@markdoc/markdoc";import*as _ from"path";import{GATED_MARKDOC_TAGS as F}from"../../constants/entitlements.js";import{logger as H}from"../../tools/notifiers/logger.js";import{reporter as z}from"../../tools/notifiers/reporter.js";import{sha1 as B}from"../../utils/crypto/sha1.js";import{formatMarkdocError as G}from"./errors.js";import{extractFirstHeading as C,SKIP as K,visit as j}from"./markdoc/plugins/utils.js";import{isPromptNode as $}from"../../../markdoc/helpers/guards/is-prompt-node.js";import{attributeResolvers as R}from"./attribute-resolvers/index.js";import{MdResolveError as V}from"./attribute-resolvers/md-resolve-error.js";import{processHtmlTokens as q}from"./html/process-html-tokens.js";import{normalizeHtmlHeadings as J}from"./html/normalize-html-headings.js";import{resolveRawPartials as Q}from"./markdoc/resolve-raw-partials.js";import{exampleContentTrees as X,reparseExampleFences as Z}from"./markdoc/reparse-example-fences.js";import{EntitlementsProvider as tt}from"../../entitlements/entitlements-provider.js";import{MARKDOC_PARTIALS_DEPS_KEY as et}from"../../constants/common.js";import{getLinkOriginalAttrName as at}from"./attribute-resolvers/utils.js";import{createSourceLinesReader as rt}from"./create-source-lines-reader.js";const ot="EMPTY";async function st(e,o,a){const n=tt.instance(),{actions:s}=a,{relativePath:l,resolveErrors:E}=e,w={...a,readSourceLines:rt(e.rawContent)},g=new Set,u=new Set,m=new Set,b=new Set,c={},y=new Set,L={},T={};function P(t,r){const D=r||ot;t[D]=(t[D]||0)+1}const I=[];e.resolveErrors.length=0;const x=X(e.ast),O=t=>{const r=D();I.push(r.then(k=>{k?.sharedDataIds&&k.sharedDataIds.forEach(d=>g.add(d))}).catch(Y(t)));async function D(){const k=[];switch(t.type){case"fence":P(L,t.attributes.language);break;case"link":case"image":await R.nativeMdLink(t,t.type==="link"?"href":"src",l,w);break;case"tag":{if(!t.tag)break;const d=o?.tags?.[t.tag];if(!d){F[t.tag]&&!n.canAccessFeature(F[t.tag])&&(t.errors.push({level:"warning",id:"invalid-tag",message:`Undefined tag: ${t.tag}`}),t.tag="",t.type="error",t.attributes={});break}const v=t.tag==="html"?t.attributes.name:t.tag;if((t.tag==="html"?y:b).add(v),c[v]=(c[v]||0)+1,v==="code-snippet"&&P(L,t.attributes.language),d.attributes?.__idx&&(t.attributes.__idx=c[t.tag]),d.dynamicComponentLib&&u.add(d.dynamicComponentLib),!d.attributes)break;if(v==="partial"&&t.attributes?.file){const i=at("file"),f=t[i]||t.attributes.file,h=f.startsWith("/")?f.slice(1):_.posix.normalize(_.posix.join(_.posix.dirname(l),f));m.add(h);const p=(s.getGlobalConfig(et)||{})[h];if(p?.dynamicComponents)for(const S of p.dynamicComponents)u.add(S);if(p?.sharedDataDeps)for(const S of p.sharedDataDeps)g.add(S)}for(const[i,f]of Object.entries(d.attributes)){const h=f.type;if(h&&(h.resolver||f.resolver)){const N=R[h.resolver||f.resolver],p=await N?.(t,i,l,w);p?.sharedDataId&&k.push(p.sharedDataId)}}if(v==="code-walkthrough")for(const i of t.attributes.resolvedFilesets||[])for(const f of i.files||[])P(T,f.language);const A=t.attributes?.attrs;if(A&&t.tag==="html")for(const i of Object.keys(A))i==="src"||i==="srcSet"?await R.htmlSourceAttribute(t,i,l,w):i==="href"&&await R.htmlHref(t,i,l,w);break}}return{sharedDataIds:k}}};function Y(t){return async r=>{if(!(r instanceof V)){await z.panicOnBuild(r.message);return}E.push(G({type:"resolve_link",meta:{...r.meta,link:r.meta.link??r.meta.rawLink},lines:t.lines,location:t.location,error:{id:"",level:"error",message:r.message,location:t.location}},e.relativePath,e.rawContent))}}j(e.ast,t=>(O(t),$(t)?K:void 0));for(const t of x)j(t,r=>(r.type==="tag"&&O(r),$(r)?K:void 0));return await Promise.all(I),e.sharedDataDeps=g,e.dynamicMarkdocComponents=u,e.validatedAtRevision<s.buildRevision&&(e.markdocErrors=[e.ast,...x].flatMap(t=>M.validate(t,o)).map(t=>G(t,l,e.rawContent)),e.validatedAtRevision=s.buildRevision),{sharedDataDeps:e.sharedDataDeps,dynamicMarkdocComponents:Array.from(e.dynamicMarkdocComponents?.values()??[]),partials:Array.from(m),tagList:Array.from(b),htmlTagsList:Array.from(y),tagOccurrence:c,codeSnippetLanguages:L,codeWalkthroughLanguages:T}}const U=new M.Tokenizer({html:!0,allowIndentation:!0,allowComments:!0});U.parser.block.ruler.getRules("reference").length=0;function W(e,o){const a=U.tokenize(e),n=q(a),s=M.parse(n,o);return J(s),s}function it(e,o){const a=W(o,{file:e,slots:!0});return Z(a,s=>W(s,{file:e})),{ast:a,rawContent:o,resolveErrors:[],markdocErrors:[],relativePath:e,sharedDataDeps:void 0,validatedAtRevision:-1}}async function Pt(e,o){const{data:a}=await o.cache.load(e,"markdown-ast");return C(a.ast)}async function St(e,o){z.clearMarkdocProblems();const a=e.getAllRoutes();let n=0;const s=H.isInteractive();for(const l of a)await e.resolveRouteStaticData(l,o,!0),n++,s&&n%100===0&&H.logInFooter("validate",`  \u{1F50D} Status: validating markdoc (${n}/${a.length})`)}async function Mt(e,o,a,n){const s=e.content?B(e.content):"";return await a.context.cache.load(n||e.relativePath,{loader:E,name:"markdown-inline-parser"},[s,String(a.actions.buildRevision)]);async function E(w,g,u){let m;if(e.content){const c=await g.getConfig(),y=await Q(e.content,e.relativePath,c.markdown?.partialsFolders,g);m=it(e.relativePath,y)}else m=(await g.cache.load(e.relativePath,"markdown-ast")).data;let b={};if(a.actions.buildRevision!==0&&(b=await st(m,o,a)),!e.isVirtual){for(const c of m.markdocErrors)u(c);for(const c of m.resolveErrors)u(c)}return{ast:m.ast,info:b}}}export{Pt as extractMdFirstHeading,it as getAst,Mt as parseAndResolveMarkdoc,st as resolveAndValidateMarkdoc,St as validateAllMarkdowns};

package/dist/server/plugins/markdown/create-source-lines-reader.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns a reader that splits `source` into lines on first use and reuses the result,
+ * so every tag on a page shares one split. CRLF line ends are normalized to match the
+ * line numbers Markdoc reports.
+ */
+export declare function createSourceLinesReader(source: string): () => string[];
+//# sourceMappingURL=create-source-lines-reader.d.ts.map

package/dist/server/plugins/markdown/create-source-lines-reader.js

@@ -0,0 +1 @@
+function n(r){let e;return()=>(e??=r.split(/\r?\n/),e)}export{n as createSourceLinesReader};

package/dist/server/plugins/markdown/errors.d.ts

@@ -0,0 +1,26 @@
+import type { NormalizedProblem } from '@redocly/openapi-core';
+import type { ValidateError, LocationEdge } from '@markdoc/markdoc';
+import type { MarkdocError, BrokenLinkType } from '../../../types/index.js';
+export type ValidateErrorWithMeta = ValidateError & {
+    meta?: {
+        rawLink: string;
+        link?: string;
+        title?: string;
+        brokenLinkType?: BrokenLinkType;
+    };
+};
+export type NormalizedLocation = {
+    start: Required<LocationEdge>;
+    end: Required<LocationEdge>;
+    lines: string[];
+};
+export declare function formatMarkdocError(error: ValidateErrorWithMeta, relativePath: string, sourceContent: string): MarkdocError;
+/**
+ * Normalizes markdoc error:
+ * - fixes location indexes to be 1-based instead of 0 based
+ * - for some errors, tries to infer specific character as characters are not supplid for every markdown it node.
+ */
+export declare function normalizeErrorLocation(error: ValidateErrorWithMeta, source: string): NormalizedLocation;
+export declare function formatBundleFromMarkdocError(error: NormalizedProblem, relativePath: string, contentDir: string): string;
+export declare function isMarkdocError(error: Error | MarkdocError): error is MarkdocError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/server/plugins/markdown/errors.js

@@ -0,0 +1,2 @@
+import l from"node:path";import{MARKDOC_ERROR_TYPES as s}from"../../../constants/common.js";import{slash as m}from"../../../utils/path/slash.js";import{getCodeframe as f}from"../../utils/codeframes/codeframes.js";function L(e,r,n){const{frame:t,start:a}=f(h(e,n),!0);return{type:e.meta?e.meta?.brokenLinkType?"BROKEN_LINK":"RESOLVE":"MARKDOC",brokenLinkType:e.meta?.brokenLinkType,codeframe:t,message:e.error.message,sourceFileRelativePath:r,sourceFileLocation:a,...e.meta}}function o(e,r,n){const t=e?.line??r?.line??n?.line,a=e?.character??r?.character??n?.character;return{line:t!==void 0?t+1:0,character:a!==void 0?a+1:void 0}}function h(e,r){const n=o(e.location?.start,e.error.location?.start,{line:e.lines[0]}),t=o(e.location?.end,e.error.location?.end,{line:e.lines[1]});t.line--;const a=r.split(`
+`);switch(e.type){case"resolve_link":{const c=e.meta?.rawLink;let i=n.line;for(;i<t.line&&!(a[i-1].indexOf(c)>-1);)i++;if(n.line=i,i<1)break;n.character=n.character??a[i-1].indexOf(c)+1,t.line=i,t.character=t.character??n.character+c.length;break}default:n.character=n.character??1,t.character=t.character??(a[t.line-1]?.length||0)+1}return{start:n,end:t,lines:a}}function R(e,r,n){const t=l.relative(n,e.location[0]?.source.absoluteRef),c=m(t)===r?"":e.location[0]?.pointer;return`${e.message.replaceAll(n+"/","")} in ${t}${c?` at ${c}`:""}`}function E(e){return"type"in e&&s.includes(e.type)}export{R as formatBundleFromMarkdocError,L as formatMarkdocError,E as isMarkdocError,h as normalizeErrorLocation};

package/dist/server/plugins/markdown/extract-frontmatter.d.ts

@@ -0,0 +1,6 @@
+export type ExtractFrontmatterResult = {
+    frontmatter: Record<string, unknown>;
+    frontmatterError?: string;
+};
+export declare function extractFrontmatter(source: string): ExtractFrontmatterResult;
+//# sourceMappingURL=extract-frontmatter.d.ts.map

package/dist/server/plugins/markdown/extract-frontmatter.js

@@ -0,0 +1 @@
+import a from"js-yaml";const c=/^---\r?\n(?:([\s\S]*?)\r?\n)?---\r?\n?/;function m(t){return typeof t=="object"&&t!==null&&!Array.isArray(t)}function f(t){const n=t.match(c);if(!n)return{frontmatter:{}};const o=n[1]??"";try{const r=a.load(o);return{frontmatter:m(r)?r:{}}}catch(r){const e=r instanceof Error?r.message:String(r);return{frontmatter:{},frontmatterError:e}}}export{f as extractFrontmatter};

package/dist/server/plugins/markdown/get-server-props.d.ts

@@ -0,0 +1,4 @@
+import type { MdPageStaticData, GetServerPropsFn } from '../../types';
+declare const getServerProps: GetServerPropsFn<MdPageStaticData>;
+export default getServerProps;
+//# sourceMappingURL=get-server-props.d.ts.map

package/dist/server/plugins/markdown/get-server-props.js

@@ -0,0 +1 @@
+import s from"@markdoc/markdoc";import{getPublicEnvVariables as u}from"../../utils/envs/get-public-env-variables.js";import{transformMdAst as i}from"./runtime-transform";const v=async(A,o,t,e)=>{const{ast:n,frontmatter:r,props:l,editPage:f,lastModified:m}=o,{headings:d,renderableAst:p}=await i(s.Ast.fromJSON(n),{partials:t.partials,variables:{frontmatter:r,...t.variables,env:u()}},e.serverOutDir);return Array.isArray(r.banner)&&(r.banner=await Promise.all(r.banner.map(async a=>{if(a.ast){const{renderableAst:b}=await i(s.Ast.fromJSON(a.ast),{partials:{},variables:{}},e.serverOutDir);return{...a,ast:b}}return a}))),{...l,ast:p,headings:d,frontmatter:r,editPage:f,lastModified:m}};var P=v;export{P as default};

package/dist/server/plugins/markdown/get-template-path.d.ts

@@ -0,0 +1,2 @@
+export declare function getTemplatePath(relativePath: string): string;
+//# sourceMappingURL=get-template-path.d.ts.map

package/dist/server/plugins/markdown/get-template-path.js

@@ -0,0 +1 @@
+import{fromCurrentDir as t}from"../../utils/paths.js";function m(r){return t(import.meta.url,r)}export{m as getTemplatePath};

package/dist/server/plugins/markdown/html/html-jsx-attribute-mapping.d.ts

@@ -0,0 +1,6 @@
+export declare function getJsxConvertedAttributes(attrs: {
+    [key: string]: string;
+}, tagName?: string): {
+    [key: string]: string | boolean | object;
+};
+//# sourceMappingURL=html-jsx-attribute-mapping.d.ts.map

package/dist/server/plugins/markdown/html/html-jsx-attribute-mapping.js

@@ -0,0 +1 @@
+const a={for:"htmlFor",class:"className","accept-charset":"acceptCharset",accesskey:"accessKey",allowfullscreen:"allowFullScreen",allowtransparency:"allowTransparency",autocomplete:"autoComplete",autoplay:"autoPlay",cellpadding:"cellPadding",cellspacing:"cellSpacing",charset:"charSet",classid:"classID",colspan:"colSpan",contenteditable:"contentEditable",contextmenu:"contextMenu",crossorigin:"crossOrigin",datetime:"dateTime",enctype:"encType",formaction:"formAction",formenctype:"formEncType",formmethod:"formMethod",formnovalidate:"formNoValidate",formtarget:"formTarget",frameborder:"frameBorder",hreflang:"hrefLang","http-equiv":"httpEquiv",inputmode:"inputMode",keyparams:"keyParams",keytype:"keyType",marginheight:"marginHeight",marginwidth:"marginWidth",maxlength:"maxLength",mediagroup:"mediaGroup",minlength:"minLength",novalidate:"noValidate",playsinline:"playsInline",radiogroup:"radioGroup",readonly:"readOnly",referrerpolicy:"referrerPolicy",rowspan:"rowSpan",spellcheck:"spellCheck",srcdoc:"srcDoc",srclang:"srcLang",srcset:"srcSet",tabindex:"tabIndex",usemap:"useMap",autocapitalize:"autoCapitalize",autocorrect:"autoCorrect",autosave:"autoSave",itemprop:"itemProp",itemscope:"itemScope",itemtype:"itemType",itemid:"itemID",itemref:"itemRef","accent-height":"accentHeight","alignment-baseline":"alignmentBaseline","arabic-form":"arabicForm","baseline-shift":"baselineShift","cap-height":"capHeight","clip-path":"clipPath","clip-rule":"clipRule","color-interpolation":"colorInterpolation","color-interpolation-filters":"colorInterpolationFilters","color-profile":"colorProfile","color-rendering":"colorRendering","dominant-baseline":"dominantBaseline","enable-background":"enableBackground","fill-opacity":"fillOpacity","fill-rule":"fillRule","flood-color":"floodColor","flood-opacity":"floodOpacity","font-family":"fontFamily","font-size":"fontSize","font-size-adjust":"fontSizeAdjust","font-stretch":"fontStretch","font-style":"fontStyle","font-variant":"fontVariant","font-weight":"fontWeight","glyph-name":"glyphName","glyph-orientation-horizontal":"glyphOrientationHorizontal","glyph-orientation-vertical":"glyphOrientationVertical","horiz-adv-x":"horizAdvX","horiz-origin-x":"horizOriginX","image-rendering":"imageRendering","letter-spacing":"letterSpacing","lighting-color":"lightingColor","marker-end":"markerEnd","marker-mid":"markerMid","marker-start":"markerStart","overline-position":"overlinePosition","overline-thickness":"overlineThickness","paint-order":"paintOrder","panose-1":"panose1","pointer-events":"pointerEvents","rendering-intent":"renderingIntent","shape-rendering":"shapeRendering","stop-color":"stopColor","stop-opacity":"stopOpacity","strikethrough-position":"strikethroughPosition","strikethrough-thickness":"strikethroughThickness","stroke-dasharray":"strokeDasharray","stroke-dashoffset":"strokeDashoffset","stroke-linecap":"strokeLinecap","stroke-linejoin":"strokeLinejoin","stroke-miterlimit":"strokeMiterlimit","stroke-opacity":"strokeOpacity","stroke-width":"strokeWidth","text-anchor":"textAnchor","text-decoration":"textDecoration","text-rendering":"textRendering","underline-position":"underlinePosition","underline-thickness":"underlineThickness","unicode-bidi":"unicodeBidi","unicode-range":"unicodeRange","units-per-em":"unitsPerEm","v-alphabetic":"vAlphabetic","v-hanging":"vHanging","v-ideographic":"vIdeographic","v-mathematical":"vMathematical","vector-effect":"vectorEffect","vert-adv-y":"vertAdvY","vert-origin-x":"vertOriginX","vert-origin-y":"vertOriginY","word-spacing":"wordSpacing","writing-mode":"writingMode","x-height":"xHeight","xlink:actuate":"xlinkActuate","xlink:arcrole":"xlinkArcrole","xlink:href":"xlinkHref","xlink:role":"xlinkRole","xlink:show":"xlinkShow","xlink:title":"xlinkTitle","xlink:type":"xlinkType","xml:base":"xmlBase","xmlns:xlink":"xmlnsXlink","xml:lang":"xmlLang","xml:space":"xmlSpace"};function s(r,t){const e={};for(const[i,n]of Object.entries(r))switch(i){case"value":t==="input"||t==="textarea"?e.defaultValue=n:e.value=n;break;case"checked":t==="input"?e.defaultChecked=!0:e.checked=n;break;case"style":e.style=c(n);break;default:e[a[i]||i]=n}return e}function l(r){return r.match(/^--/)?r:r.replace(/-[a-z]/g,t=>t[1].toUpperCase())}function c(r){return r.split(";").filter(t=>t.trim().length).reduce((t,e)=>{const i=e.indexOf(":"),n=i===-1?e:e.slice(0,i),o=i===-1?"":e.slice(i+1);return t[l(n.trim())]=o.trim(),t},{})}export{s as getJsxConvertedAttributes};

package/dist/server/plugins/markdown/html/html-tags-allow-list.d.ts

@@ -0,0 +1,2 @@
+export declare const HTML_TAGS_ALLOW_LIST: string[];
+//# sourceMappingURL=html-tags-allow-list.d.ts.map

package/dist/server/plugins/markdown/html/html-tags-allow-list.js

@@ -0,0 +1 @@
+const t=["a","abbr","address","area","article","aside","audio","b","base","bdi","bdo","blockquote","body","br","button","canvas","caption","cite","code","col","colgroup","data","datalist","dd","del","details","dfn","dialog","div","dl","dt","em","embed","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","head","header","hr","html","i","iframe","img","input","ins","kbd","label","legend","li","link","main","map","mark","meta","meter","nav","noscript","object","ol","optgroup","option","output","p","param","picture","pre","progress","q","rp","rt","ruby","s","samp","script","section","select","small","source","span","strong","style","sub","summary","sup","svg","table","tbody","td","template","textarea","tfoot","th","thead","time","title","tr","track","u","ul","var","video","wbr"];export{t as HTML_TAGS_ALLOW_LIST};

package/dist/server/plugins/markdown/html/normalize-html-headings.d.ts

@@ -0,0 +1,9 @@
+import type { Node } from '@markdoc/markdoc';
+/**
+ * Rewrites block-level raw HTML `<h1>`…`<h6>` elements into Markdoc `heading` nodes,
+ * so they get an anchor id, a TOC entry and a search section like Markdown headings.
+ * Keeps the element's `id` attribute and drops the rest. Mutates `ast` in place.
+ * HTML headings inside inline content are left untouched.
+ */
+export declare function normalizeHtmlHeadings(ast: Node): void;
+//# sourceMappingURL=normalize-html-headings.d.ts.map

package/dist/server/plugins/markdown/html/normalize-html-headings.js

@@ -0,0 +1 @@
+import s from"@markdoc/markdoc";const o=/^h([1-6])$/;function u(t){r(t,!1)}function r(t,i){const n=i||t.type==="inline";t.children=t.children.map(e=>{const l=(n?void 0:a(e))??e;return r(l,n),l});for(const e of Object.values(t.slots))r(e,n)}function a(t){if(t.type!=="tag"||t.tag!=="html")return;const i=o.exec(t.attributes.name)?.[1];if(!i)return;const n=t.attributes.attrs?.id,e=new s.Ast.Node("heading",{level:Number(i),...typeof n=="string"&&{id:n}},[new s.Ast.Node("inline",{},t.children)]);return e.lines=t.lines,e.location=t.location,e}export{u as normalizeHtmlHeadings};

package/dist/server/plugins/markdown/html/process-html-tokens.d.ts

@@ -0,0 +1,2 @@
+export declare function processHtmlTokens(tokens: any): any[];
+//# sourceMappingURL=process-html-tokens.d.ts.map

package/dist/server/plugins/markdown/html/process-html-tokens.js

@@ -0,0 +1 @@
+import{Parser as p}from"htmlparser2";import{getJsxConvertedAttributes as i}from"./html-jsx-attribute-mapping.js";function l(r){const e=[],n=[];let o=null;const s=new p({onopentag(t,a){n.push({name:t,token:o}),e.push({type:"tag_open",nesting:1,meta:{tag:"html",attributes:[{type:"attribute",name:"name",value:t},{type:"attribute",name:"attrs",value:i(a,t)}]}})},ontext(t){t?.trim().length>0&&e.push({type:"text",content:t})},onclosetag(){n.pop(),e.push({type:"tag_close",nesting:-1,meta:{tag:"html"}})}});for(const t of r){if(t.type.startsWith("html")){o=t,s.write(t.content);continue}t.type==="inline"&&(t.children=l(t.children)),e.push(t)}for(const t of n)e.push({type:"error",meta:{error:{message:`HTML tag <${t.name}> is not closed, opened at`,location:t?.token?.map?{start:{line:t.token.map[0]},end:{line:t.token.map[1]}}:void 0}}}),e.push({type:"tag_close",nesting:-1,meta:{tag:"html"}});return e}export{l as processHtmlTokens};

package/dist/server/plugins/markdown/index.d.ts

@@ -0,0 +1,3 @@
+import type { LifecyclePluginInstance, PluginOptions } from '../../types';
+export declare function markdownPlugin(options: PluginOptions): Promise<LifecyclePluginInstance>;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/plugins/markdown/index.js

@@ -0,0 +1 @@
+import{REDOCLY_TEAMS_RBAC as v}from"@redocly/config";import{MARKDOC_PARTIALS_DATA_KEY as D}from"../../constants/common.js";import{reporter as R}from"../../tools/notifiers/reporter.js";import{canAccessFeature as g}from"../../utils/entitlements/can-access-feature.js";import{extractMdFirstHeading as A,getAst as T}from"./compiler.js";import{getTemplatePath as w}from"./get-template-path.js";import{prepareMarkdocPartials as M}from"./markdoc/partials.js";import{searchResolver as C}from"./search/search-resolver.js";import{markdownStaticDataLoader as E}from"./markdown-static-data-loader.js";import{makeErrorRoute as I}from"../error-route.js";import{validateRbacConfig as O}from"../validate-rbac-config.js";import{findFrontmatterSlugs as _,getSidebarSharedDataId as G,resolveFrontmatterSlugs as L}from"../utils.js";import{isPartial as j}from"./is-partial.js";import{markdownFrontmatterLoader as B}from"./markdown-frontmatter-loader.js";import{resolveRawPartials as K}from"./markdoc/resolve-raw-partials.js";import{getAiDocumentsStore as N}from"./search/get-ai-search-documents.js";import{registerPageProps as Y}from"../register-page-props.js";import{resolveMarkdownTemplate as q}from"./utils/resolve-markdown-template.js";import{sanitizeMalformedMdContent as z}from"./utils/sanitize-malformed-md-content.js";import{telemetryTraceStep as H}from"../../../cli/telemetry/helpers/trace-step.js";async function ce(h){return{id:"markdoc",requiredEntitlements:["markdown"],loaders:{"markdown-frontmatter":B,"markdown-ast":async(e,t)=>{const i=await t.fs.read(e),m=await t.getConfig(),s=await K(i,e,m?.markdown?.partialsFolders,t),n=z(s);return T(e,n)}},processContent:async(e,t)=>{await H("com.redocly.build.plugin.markdown",async i=>{const{markdown:m}=await t.getConfig();i?.setAttribute("config",JSON.stringify(m||{}));const s=m?.partialsFolders??[],n=e.createTemplate("markdown","@redocly/theme/core/templates/Markdown"),S=e.registerServerPropsGetter("markdown",w("./get-server-props.js"));e.createTemplate("error",w("../../../client/app/Error/ErrorDetails.js"));for(const o of t.fs.scan(/\.md$/))if(!await t.isPathIgnored(o.relativePath)&&!j(o.relativePath,s))try{await k(o)}catch(a){e.addRoute(I(o.relativePath,a)),i?.error(a),await R.panicOnBuild("Failed to create route for markdown file: %s",a.message)}async function k(o){const{relativePath:a,realRelativePath:b}=o,{data:{frontmatter:r}}=await t.cache.load(a,"markdown-frontmatter"),P=r?.metadata||{},y=await _(a,"markdown-frontmatter",r,t),p=L(y,a);let d=null;r?.sidebar&&(d=await G(r.sidebar,a,t.fs));let u=n;const l=q({realRelativePath:b,frontmatter:r,markdown:m,contentDir:h.contentDir});l&&(u=e.createTemplate(l.templateRef,l.templatePath)),r?.rbac&&(g("rbac")?O({content:{[a]:r.rbac}}):r.rbac=void 0),g("banner")||(r.banner=void 0),await Y(o,t.fs,e),(p.length?p.reverse():[void 0]).forEach(F=>{e.addRoute({excludeFromSearch:r?.excludeFromSearch||!1,slug:F,fsPath:a,templateId:u,sharedData:d?[{id:d,key:"sidebar"}]:void 0,redirectFrom:Object.entries(r.redirects||{}).map(([c,{type:f}])=>({type:f||301,from:c})),[v]:r?.rbac,getNavText:async()=>(r?.seo?.title||await A(a,t)||"").toString(),metadata:{type:"markdown",...P},async getStaticData(c,f){return E(o,c,t,r,f)},getSearchDocuments:C(r,a,e.getSearchFacets,e.setSearchFacets),getAiDocumentsStore:N(e.getSearchFacets,r),serverPropsGetterIds:[S]})})}})},afterRoutesCreated:async(e,t)=>{const i=await M(t,e);e.setGlobalConfig({[D]:i})}}}export{ce as markdownPlugin};

package/dist/server/plugins/markdown/is-markdown-page.d.ts

@@ -0,0 +1,2 @@
+export declare const isMarkdownPage: (relativePath: string) => RegExpMatchArray | null;
+//# sourceMappingURL=is-markdown-page.d.ts.map

package/dist/server/plugins/markdown/is-markdown-page.js

@@ -0,0 +1 @@
+const t=r=>r.match(/\.md$/);export{t as isMarkdownPage};

package/dist/server/plugins/markdown/is-partial.d.ts

@@ -0,0 +1,2 @@
+export declare const isPartial: (relativePath: string, partialsFolders: string[]) => boolean;
+//# sourceMappingURL=is-partial.d.ts.map

package/dist/server/plugins/markdown/is-partial.js

@@ -0,0 +1 @@
+import c from"path";import{compileGlobMatcher as n}from"../../utils/globs.js";const m=new WeakMap,i=(o,e)=>{if(e.length===0)return!1;let t=m.get(e);return t||(t=n(e.map(r=>c.posix.normalize(r))),m.set(e,t)),t(o)};export{i as isPartial};

package/dist/server/plugins/markdown/markdoc/functions/concat.d.ts

@@ -0,0 +1,7 @@
+import type { Scalar } from '@markdoc/markdoc';
+export declare const concat: {
+    transform(parameters: {
+        [key: string]: Scalar;
+    }): string;
+};
+//# sourceMappingURL=concat.d.ts.map

package/dist/server/plugins/markdown/markdoc/functions/concat.js

@@ -0,0 +1 @@
+const r={transform(t){return Object.values(t).map(n=>String(n)).join("")}};export{r as concat};

package/dist/server/plugins/markdown/markdoc/functions/includes.d.ts

@@ -0,0 +1,6 @@
+export declare const includes: {
+    transform(parameters: {
+        [key: string]: unknown;
+    }): boolean;
+};
+//# sourceMappingURL=includes.d.ts.map

package/dist/server/plugins/markdown/markdoc/functions/includes.js

@@ -0,0 +1 @@
+const s={transform(a){const[r,e]=Object.values(a);return Array.isArray(r)?r.includes(e):!1}};export{s as includes};

package/dist/server/plugins/markdown/markdoc/import-user-tags.d.ts

@@ -0,0 +1,2 @@
+export declare function importUserTags(serverOutDir: string): Promise<any>;
+//# sourceMappingURL=import-user-tags.d.ts.map

package/dist/server/plugins/markdown/markdoc/import-user-tags.js

@@ -0,0 +1 @@
+import{pathToFileURL as o}from"url";import{envConfig as r}from"../../../config/env-config.js";async function n(t){if(r.isRuntimeMode)return await import("@redocly-markdoc/schema");try{const e=r.isDevelopMode?"js":"mjs";return await import(o(`${t}/user-tags-entry.${e}`)+"?"+new Date)}catch(e){if(r.isDevelopMode)return{schema:{}};throw e}}export{n as importUserTags};

package/dist/server/plugins/markdown/markdoc/markdoc-options.d.ts

@@ -0,0 +1,214 @@
+export declare function getMarkdocOptions(serverOutDir?: string, _templateId?: string): Promise<{
+    nodes: {
+        item: import("@markdoc/markdoc").Schema;
+        heading: import("@markdoc/markdoc").Schema;
+        fence: import("@markdoc/markdoc").Schema;
+        table: import("@markdoc/markdoc").Schema;
+        td: import("@markdoc/markdoc").Schema;
+        th: import("@markdoc/markdoc").Schema;
+        text: import("@markdoc/markdoc").Schema;
+        strong: {
+            render?: string | undefined;
+            attributes?: Record<string, import("@markdoc/markdoc").SchemaAttribute>;
+            slots?: Record<string, import("@markdoc/markdoc").SchemaSlot>;
+            selfClosing?: boolean;
+            inline?: boolean;
+            transform?(node: import("@markdoc/markdoc").Node, config: Readonly<Partial<{
+                nodes: Partial<Record<import("@markdoc/markdoc").NodeType, import("@markdoc/markdoc").Schema<Partial</*elided*/ any>, string>>>;
+                tags: Record<string, import("@markdoc/markdoc").Schema>;
+                variables: Record<string, any>;
+                functions: Record<string, import("@markdoc/markdoc").ConfigFunction>;
+                partials: Record<string, any>;
+                validation?: {
+                    parents?: import("@markdoc/markdoc").Node[];
+                    validateFunctions?: boolean;
+                    environment?: string;
+                };
+            }>>): import("@markdoc/markdoc").MaybePromise<import("@markdoc/markdoc").RenderableTreeNodes>;
+            validate?(node: import("@markdoc/markdoc").Node, config: Readonly<Partial<{
+                nodes: Partial<Record<import("@markdoc/markdoc").NodeType, import("@markdoc/markdoc").Schema<Partial<any>, string>>>;
+                tags: Record<string, import("@markdoc/markdoc").Schema>;
+                variables: Record<string, any>;
+                functions: Record<string, import("@markdoc/markdoc").ConfigFunction>;
+                partials: Record<string, any>;
+                validation?: {
+                    parents?: import("@markdoc/markdoc").Node[];
+                    validateFunctions?: boolean;
+                    environment?: string;
+                };
+            }>>): import("@markdoc/markdoc").MaybePromise<import("@markdoc/markdoc").ValidationError[]>;
+            description?: string;
+            children: string[];
+        };
+        em: {
+            render?: string | undefined;
+            attributes?: Record<string, import("@markdoc/markdoc").SchemaAttribute>;
+            slots?: Record<string, import("@markdoc/markdoc").SchemaSlot>;
+            selfClosing?: boolean;
+            inline?: boolean;
+            transform?(node: import("@markdoc/markdoc").Node, config: Readonly<Partial<{
+                nodes: Partial<Record<import("@markdoc/markdoc").NodeType, import("@markdoc/markdoc").Schema<Partial<any>, string>>>;
+                tags: Record<string, import("@markdoc/markdoc").Schema>;
+                variables: Record<string, any>;
+                functions: Record<string, import("@markdoc/markdoc").ConfigFunction>;
+                partials: Record<string, any>;
+                validation?: {
+                    parents?: import("@markdoc/markdoc").Node[];
+                    validateFunctions?: boolean;
+                    environment?: string;
+                };
+            }>>): import("@markdoc/markdoc").MaybePromise<import("@markdoc/markdoc").RenderableTreeNodes>;
+            validate?(node: import("@markdoc/markdoc").Node, config: Readonly<Partial<{
+                nodes: Partial<Record<import("@markdoc/markdoc").NodeType, import("@markdoc/markdoc").Schema<Partial<any>, string>>>;
+                tags: Record<string, import("@markdoc/markdoc").Schema>;
+                variables: Record<string, any>;
+                functions: Record<string, import("@markdoc/markdoc").ConfigFunction>;
+                partials: Record<string, any>;
+                validation?: {
+                    parents?: import("@markdoc/markdoc").Node[];
+                    validateFunctions?: boolean;
+                    environment?: string;
+                };
+            }>>): import("@markdoc/markdoc").MaybePromise<import("@markdoc/markdoc").ValidationError[]>;
+            description?: string;
+            children: string[];
+        };
+        s: {
+            render?: string | undefined;
+            attributes?: Record<string, import("@markdoc/markdoc").SchemaAttribute>;
+            slots?: Record<string, import("@markdoc/markdoc").SchemaSlot>;
+            selfClosing?: boolean;
+            inline?: boolean;
+            transform?(node: import("@markdoc/markdoc").Node, config: Readonly<Partial<{
+                nodes: Partial<Record<import("@markdoc/markdoc").NodeType, import("@markdoc/markdoc").Schema<Partial<any>, string>>>;
+                tags: Record<string, import("@markdoc/markdoc").Schema>;
+                variables: Record<string, any>;
+                functions: Record<string, import("@markdoc/markdoc").ConfigFunction>;
+                partials: Record<string, any>;
+                validation?: {
+                    parents?: import("@markdoc/markdoc").Node[];
+                    validateFunctions?: boolean;
+                    environment?: string;
+                };
+            }>>): import("@markdoc/markdoc").MaybePromise<import("@markdoc/markdoc").RenderableTreeNodes>;
+            validate?(node: import("@markdoc/markdoc").Node, config: Readonly<Partial<{
+                nodes: Partial<Record<import("@markdoc/markdoc").NodeType, import("@markdoc/markdoc").Schema<Partial<any>, string>>>;
+                tags: Record<string, import("@markdoc/markdoc").Schema>;
+                variables: Record<string, any>;
+                functions: Record<string, import("@markdoc/markdoc").ConfigFunction>;
+                partials: Record<string, any>;
+                validation?: {
+                    parents?: import("@markdoc/markdoc").Node[];
+                    validateFunctions?: boolean;
+                    environment?: string;
+                };
+            }>>): import("@markdoc/markdoc").MaybePromise<import("@markdoc/markdoc").ValidationError[]>;
+            description?: string;
+            children: string[];
+        };
+        link: {
+            attributes?: Record<string, import("@markdoc/markdoc").SchemaAttribute>;
+            slots?: Record<string, import("@markdoc/markdoc").SchemaSlot>;
+            selfClosing?: boolean;
+            inline?: boolean;
+            transform?(node: import("@markdoc/markdoc").Node, config: Readonly<Partial<{
+                nodes: Partial<Record<import("@markdoc/markdoc").NodeType, import("@markdoc/markdoc").Schema<Partial<any>, string>>>;
+                tags: Record<string, import("@markdoc/markdoc").Schema>;
+                variables: Record<string, any>;
+                functions: Record<string, import("@markdoc/markdoc").ConfigFunction>;
+                partials: Record<string, any>;
+                validation?: {
+                    parents?: import("@markdoc/markdoc").Node[];
+                    validateFunctions?: boolean;
+                    environment?: string;
+                };
+            }>>): import("@markdoc/markdoc").MaybePromise<import("@markdoc/markdoc").RenderableTreeNodes>;
+            validate?(node: import("@markdoc/markdoc").Node, config: Readonly<Partial<{
+                nodes: Partial<Record<import("@markdoc/markdoc").NodeType, import("@markdoc/markdoc").Schema<Partial<any>, string>>>;
+                tags: Record<string, import("@markdoc/markdoc").Schema>;
+                variables: Record<string, any>;
+                functions: Record<string, import("@markdoc/markdoc").ConfigFunction>;
+                partials: Record<string, any>;
+                validation?: {
+                    parents?: import("@markdoc/markdoc").Node[];
+                    validateFunctions?: boolean;
+                    environment?: string;
+                };
+            }>>): import("@markdoc/markdoc").MaybePromise<import("@markdoc/markdoc").ValidationError[]>;
+            description?: string;
+            render: string;
+            children: string[];
+        };
+        document: {
+            render?: string | undefined;
+            attributes?: Record<string, import("@markdoc/markdoc").SchemaAttribute>;
+            slots?: Record<string, import("@markdoc/markdoc").SchemaSlot>;
+            selfClosing?: boolean;
+            inline?: boolean;
+            transform?(node: import("@markdoc/markdoc").Node, config: Readonly<Partial<{
+                nodes: Partial<Record<import("@markdoc/markdoc").NodeType, import("@markdoc/markdoc").Schema<Partial<any>, string>>>;
+                tags: Record<string, import("@markdoc/markdoc").Schema>;
+                variables: Record<string, any>;
+                functions: Record<string, import("@markdoc/markdoc").ConfigFunction>;
+                partials: Record<string, any>;
+                validation?: {
+                    parents?: import("@markdoc/markdoc").Node[];
+                    validateFunctions?: boolean;
+                    environment?: string;
+                };
+            }>>): import("@markdoc/markdoc").MaybePromise<import("@markdoc/markdoc").RenderableTreeNodes>;
+            validate?(node: import("@markdoc/markdoc").Node, config: Readonly<Partial<{
+                nodes: Partial<Record<import("@markdoc/markdoc").NodeType, import("@markdoc/markdoc").Schema<Partial<any>, string>>>;
+                tags: Record<string, import("@markdoc/markdoc").Schema>;
+                variables: Record<string, any>;
+                functions: Record<string, import("@markdoc/markdoc").ConfigFunction>;
+                partials: Record<string, any>;
+                validation?: {
+                    parents?: import("@markdoc/markdoc").Node[];
+                    validateFunctions?: boolean;
+                    environment?: string;
+                };
+            }>>): import("@markdoc/markdoc").MaybePromise<import("@markdoc/markdoc").ValidationError[]>;
+            description?: string;
+            children: string[];
+        };
+    };
+    tags: {
+        schemaDefinition: {
+            render: string;
+            attributes: {
+                schemaRef: {
+                    type: StringConstructor;
+                };
+                exampleRef: {
+                    type: StringConstructor;
+                };
+                showReadOnly: {
+                    type: BooleanConstructor;
+                };
+                showWriteOnly: {
+                    type: BooleanConstructor;
+                };
+            };
+        };
+    };
+    functions: {
+        and: import("@markdoc/markdoc").ConfigFunction;
+        or: import("@markdoc/markdoc").ConfigFunction;
+        not: import("@markdoc/markdoc").ConfigFunction;
+        equals: import("@markdoc/markdoc").ConfigFunction;
+        default: import("@markdoc/markdoc").ConfigFunction;
+        debug: import("@markdoc/markdoc").ConfigFunction;
+        includes: {
+            transform(parameters: {
+                [key: string]: unknown;
+            }): boolean;
+        };
+        concat: {
+            transform(parameters: {
+                [key: string]: import("@markdoc/markdoc").Scalar;
+            }): string;
+        };
+    };
+}>;
+//# sourceMappingURL=markdoc-options.d.ts.map

package/dist/server/plugins/markdown/markdoc/markdoc-options.js

@@ -0,0 +1 @@
+import f from"@markdoc/markdoc";import*as p from"@redocly/theme/markdoc/default";import{reporter as g}from"../../../tools/notifiers/reporter.js";import*as u from"../../../../markdoc/nodes/index.js";import d from"../../../../markdoc/tags/index.js";import{normalizeCustomTags as l}from"../../../../markdoc/helpers/normalize-custom-tags.js";import{includes as h}from"./functions/includes.js";import{importUserTags as O}from"./import-user-tags.js";import{concat as y}from"./functions/concat.js";const T=p.tags;function b(s){const{tags:c,functions:e={},...r}=s,n={...c,...r},a=Object.entries(n),o=[],t=[];for(const[i,m]of a)i in f.nodes?o.push([i,m]):t.push([i,m]);return{nodes:Object.fromEntries(o),tags:Object.fromEntries(t),functions:e}}async function _(s="../../../esbuild/cache/server/",c=""){let e;try{e=(await O(s)).schema}catch(t){throw t.code==="ERR_MODULE_NOT_FOUND"?(g.printErrors(),new Error("Please fix the errors above and try again.")):t}const{tags:r={},nodes:n={},functions:a={}}=b(e),o={tags:{schemaDefinition:{render:"SchemaDefinition",attributes:{schemaRef:{type:String},exampleRef:{type:String},showReadOnly:{type:Boolean},showWriteOnly:{type:Boolean}}}}};return{nodes:{...u,...n},tags:{...d,...T,...l(r),...o.tags},functions:{...f.functions,...a,includes:h,concat:y}}}export{_ as getMarkdocOptions};

package/dist/server/plugins/markdown/markdoc/partials.d.ts

@@ -0,0 +1,4 @@
+import type { Node } from '@markdoc/markdoc';
+import type { LifecycleContext, AfterRoutesCreatedActions } from '../../../types';
+export declare function prepareMarkdocPartials(context: LifecycleContext, actions: AfterRoutesCreatedActions): Promise<Record<string, Node>>;
+//# sourceMappingURL=partials.d.ts.map

package/dist/server/plugins/markdown/markdoc/partials.js

@@ -0,0 +1 @@
+import*as f from"path";import{MARKDOC_PARTIALS_DATA_KEY as D,MARKDOC_PARTIALS_DEPS_KEY as A}from"../../../constants/common.js";import{isPartial as y}from"../is-partial.js";function h(t,s){return Promise.all(t.map(s)).then(i=>t.filter((o,n)=>i[n]))}async function b(t,s){const{markdown:i}=await t.getConfig(),o=i?.partialsFolders??[],n=await h(t.fs.scan(/\.md$/),async a=>!(!f.posix.basename(a.relativePath).endsWith(".md")||await t.isPathIgnored(a.relativePath)||!y(a.relativePath,o)));s.setGlobalConfig({[D]:Object.fromEntries(n.map(a=>[a.relativePath,{}]))});const p={},m={};for(const a of n){const{ast:e,info:r}=await s.parseMarkdoc({input:a,context:t});p[a.relativePath]=e;const l=Array.isArray(r.dynamicMarkdocComponents)?r.dynamicMarkdocComponents:[],c=r.sharedDataDeps instanceof Set?Array.from(r.sharedDataDeps):Array.isArray(r.sharedDataDeps)?r.sharedDataDeps:[],d=Array.isArray(r.partials)?r.partials:[];m[a.relativePath]={dynamicComponents:new Set(l),sharedDataDeps:new Set(c),partials:new Set(d)}}return s.setGlobalConfig({[A]:Object.fromEntries(Object.entries(m).map(([a,e])=>[a,{dynamicComponents:Array.from(e.dynamicComponents),sharedDataDeps:Array.from(e.sharedDataDeps),partials:Array.from(e.partials)}]))}),p}export{b as prepareMarkdocPartials};

package/dist/server/plugins/markdown/markdoc/plugins/headings.d.ts

@@ -0,0 +1,7 @@
+import type { Tag, Node } from '@markdoc/markdoc';
+export declare function getHeadingData(node: Tag | Node): {
+    value: string;
+    id: any;
+    depth: any;
+} | undefined;
+//# sourceMappingURL=headings.d.ts.map

package/dist/server/plugins/markdown/markdoc/plugins/headings.js

@@ -0,0 +1 @@
+import{getNodeAttribute as r}from"../../../../../markdoc/helpers/get-node-attribute.js";import{getInnerText as i}from"../../../../../markdoc/helpers/get-inner-text.js";function u(t){const e=r(t,"level");if(e)return{value:i(t.children),id:r(t,"id"),depth:e}}export{u as getHeadingData};

package/dist/server/plugins/markdown/markdoc/plugins/render-diagrams.d.ts

@@ -0,0 +1,16 @@
+export type DiagramInput = {
+    type: DiagramType;
+    source: string;
+};
+type DiagramType = 'mermaid' | 'excalidraw' | 'plantuml';
+type DiagramHtmlVariants = {
+    light: string;
+    dark: string;
+    error?: string;
+};
+export declare const cache: Record<string, DiagramHtmlVariants>;
+export declare function generateDiagramHash(source: string, type?: DiagramType): string;
+export declare function renderDiagramsWithVariants(diagrams: DiagramInput[]): Promise<DiagramHtmlVariants[]>;
+export declare function renderDiagrams(diagrams: DiagramInput[], theme?: string): Promise<string[]>;
+export {};
+//# sourceMappingURL=render-diagrams.d.ts.map

package/dist/server/plugins/markdown/markdoc/plugins/render-diagrams.js

@@ -0,0 +1 @@
+import{nanoid as w}from"nanoid";import{envConfig as l}from"../../../../config/env-config.js";import{logger as m}from"../../../../tools/notifiers/logger.js";import{sha as I}from"../../../../utils/crypto/sha.js";const u={};function g(r,n="mermaid"){const s=`${n}:${r}`;if(n==="mermaid"&&r.toLowerCase().includes("gantt")&&!r.toLowerCase().includes("todaymarker off")){const t=new Date().toISOString().split("T")[0];return I(s+t)}return I(s)}function y(){return l.REDOCLY_DIAGRAM_MICROSERVICE_URL||"https://tools.redocly.com/diagram-renders"}function R(r,n){return n==="dark"?r.dark??r.light??"":r.light??r.dark??""}async function D(r,n){const s=y(),a=m.startTiming(),e=w(),t=await fetch(s,{method:"POST",headers:{"Content-Type":"application/json","x-request-id":l.REQUEST_ID||""},body:JSON.stringify({type:r,definitions:n,rayId:e,theme:"both",organizationId:l.ORGANIZATION_ID})});if(t.status!==200)throw m.error("Diagram rendering service returned %s (rayId: %s)",t.status,e),new Error(`Something went wrong during rendering of ${r} diagrams`);return m.verboseTime(a,"Rendered %s diagrams (%s)",r,n.length),t.json()}async function T(r){if(r.length===0)return[];const n=new Map;for(let e=0;e<r.length;e++){const{type:t,source:i}=r[e],f=g(i,t);if(!u[f]){n.has(t)||n.set(t,[]);const o=n.get(t);o&&o.push({index:e,source:i})}}const s=[],a=new Map;for(const[e,t]of n){const i=t.map(o=>o.source),f=D(e,i).then(o=>{for(let c=0;c<t.length;c++){const d=o[c],h=g(t[c].source,e);if(d.error)m.error("Failed to render %s diagram: %s",e,d.error),a.set(h,{light:"",dark:"",error:`Failed to render ${e} diagram: ${d.error}`});else{const p={light:d.light??"",dark:d.dark??""};u[h]=p,a.set(h,p)}}}).catch(o=>{m.error("Failed to render %s diagrams: %s",e,o.message);for(const c of t){const d=g(c.source,e);a.set(d,{light:"",dark:"",error:`Failed to render ${e} diagram: ${o.message}`})}});s.push(f)}return await Promise.all(s),r.map(({type:e,source:t})=>{const i=g(t,e);return a.get(i)??u[i]})}async function M(r,n="light"){return(await T(r)).map(a=>R(a,n))}export{u as cache,g as generateDiagramHash,M as renderDiagrams,T as renderDiagramsWithVariants};

package/dist/server/plugins/markdown/markdoc/plugins/utils.d.ts

@@ -0,0 +1,20 @@
+import type { Node, Tag } from '@markdoc/markdoc';
+export declare function getHeadingData(node: Tag | Node): {
+    value: string;
+    id: any;
+    depth: any;
+} | undefined;
+export declare function getNumberedItemHeadingData(node: Tag | Node): {
+    value: string;
+    id: any;
+    depth: any;
+} | undefined;
+export declare function extractFirstHeading(ast: Node): undefined | string;
+export declare const EXIT: unique symbol;
+export declare const SKIP: unique symbol;
+/**
+ * simplified version of unist-util-visit for our specific use-case
+ * @see https://github.com/syntax-tree/unist-util-visit-parents/blob/main/index.js#L112
+ */
+export declare function visit<T extends Tag | Node>(node: T, visitor: (node: T) => symbol | void): symbol | void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/server/plugins/markdown/markdoc/plugins/utils.js

@@ -0,0 +1 @@
+import{isNode as p}from"../../../../../markdoc/helpers/guards/is-node.js";import{isStringNode as u}from"../../../../../markdoc/helpers/guards/is-string-node.js";import{getNodeAttribute as o}from"../../../../../markdoc/helpers/get-node-attribute.js";import{getInnerText as a}from"../../../../../markdoc/helpers/get-inner-text.js";import{isPromptNode as m}from"../../../../../markdoc/helpers/guards/is-prompt-node.js";function d(t){const r=o(t,"level");if(r)return{value:a(t.children),id:o(t,"id"),depth:r}}function y(t){const r=o(t,"headlineLevel"),e=o(t,"anchorId"),s=o(t,"headline");if(!(!r||!e||!Array.isArray(s)))return{value:a(s),id:e,depth:r}}function I(t){let r;return f(t,e=>{if(p(e)){if(m(e))return l;if(e.type==="heading")return r=d(e)?.value,c}}),r}const c=Symbol("Exit visitor"),l=Symbol("Skip children");function f(t,r){if(!t)return;const e=r(t);if(e===c)return e;if(e===l)return;for(const i of t.children){if(!i||u(i))continue;const n=f(i,r);if(n===c)return n}const s=t.slots||{};for(const i of Object.values(s)){if(!i||u(i))continue;const n=f(i,r);if(n===c)return n}}export{c as EXIT,l as SKIP,I as extractFirstHeading,d as getHeadingData,y as getNumberedItemHeadingData,f as visit};

package/dist/server/plugins/markdown/markdoc/reparse-example-fences.d.ts

@@ -0,0 +1,7 @@
+import type { Node } from '@markdoc/markdoc';
+type ParseMarkdownFn = (content: string) => Node;
+/** Parse each `{% markdoc-example %}` fence body onto the fence, out of the page tree. */
+export declare function reparseExampleFences(ast: Node, parseMarkdown: ParseMarkdownFn): void;
+export declare function exampleContentTrees(ast: Node): Node[];
+export {};
+//# sourceMappingURL=reparse-example-fences.d.ts.map

package/dist/server/plugins/markdown/markdoc/reparse-example-fences.js

@@ -0,0 +1 @@
+import{EXAMPLE_CONTENT_ATTRIBUTE as s}from"@redocly/theme/core/constants";import{isExampleNode as l}from"../../../../markdoc/helpers/guards/is-example-node.js";import{isFenceNode as a}from"../../../../markdoc/helpers/guards/is-fence-node.js";const u="no-inline-annotations";function p(o,n){for(const e of c(o)){if(!e.children.length)continue;const{content:t}=e.attributes;if(typeof t!="string")continue;const i=n(t),f=(e.lines[0]??0)+1;for(const r of i.children)m(r,f);e.children=[],e.slots={},e.errors=e.errors.filter(r=>r.id!==u),e.attributes[s]=i,p(i,n)}}function d(o){const n=[];for(const e of c(o)){const t=e.attributes[s];t&&n.push(t,...d(t))}return n}function*c(o){for(const n of o.walk()){if(!l(n))continue;const[e]=n.children;a(e)&&(yield e)}}function m(o,n){for(const e of[o,...o.walk()]){e.lines=e.lines.map(i=>i+n);const{location:t}=e;t&&(typeof t.start?.line=="number"&&(t.start.line+=n),typeof t.end?.line=="number"&&(t.end.line+=n))}}export{d as exampleContentTrees,p as reparseExampleFences};