@astrojs/markdoc 0.0.0-10745-20240410180016

package/dist/extensions/prism.d.ts

@@ -0,0 +1,2 @@
+import { type AstroMarkdocConfig } from '../config.js';
+export default function prism(): AstroMarkdocConfig;

package/dist/extensions/prism.js

@@ -0,0 +1,21 @@
+import { runHighlighterWithAstro } from "@astrojs/prism/dist/highlighter";
+import { unescapeHTML } from "astro/runtime/server/index.js";
+import { Markdoc } from "../config.js";
+function prism() {
+  return {
+    nodes: {
+      fence: {
+        attributes: Markdoc.nodes.fence.attributes,
+        transform({ attributes: { language, content } }) {
+          const { html, classLanguage } = runHighlighterWithAstro(language, content);
+          return unescapeHTML(
+            `<pre class="${classLanguage}"><code class="${classLanguage}">${html}</code></pre>`
+          );
+        }
+      }
+    }
+  };
+}
+export {
+  prism as default
+};

package/dist/extensions/shiki.d.ts

@@ -0,0 +1,3 @@
+import type { ShikiConfig } from 'astro';
+import type { AstroMarkdocConfig } from '../config.js';
+export default function shiki(config?: ShikiConfig): Promise<AstroMarkdocConfig>;

package/dist/extensions/shiki.js

@@ -0,0 +1,21 @@
+import { createShikiHighlighter } from "@astrojs/markdown-remark";
+import Markdoc from "@markdoc/markdoc";
+import { unescapeHTML } from "astro/runtime/server/index.js";
+async function shiki(config) {
+  const highlighter = await createShikiHighlighter(config);
+  return {
+    nodes: {
+      fence: {
+        attributes: Markdoc.nodes.fence.attributes,
+        async transform({ attributes }) {
+          const lang = typeof attributes.language === "string" ? attributes.language : "plaintext";
+          const html = await highlighter.highlight(attributes.content, lang);
+          return unescapeHTML(html);
+        }
+      }
+    }
+  };
+}
+export {
+  shiki as default
+};

package/dist/heading-ids.d.ts

@@ -0,0 +1,10 @@
+import { type Config as MarkdocConfig, type Schema } from '@markdoc/markdoc';
+import Slugger from 'github-slugger';
+type HeadingIdConfig = MarkdocConfig & {
+    ctx: {
+        headingSlugger: Slugger;
+    };
+};
+export declare const heading: Schema;
+export declare function setupHeadingConfig(): HeadingIdConfig;
+export {};

package/dist/heading-ids.js

@@ -0,0 +1,55 @@
+import Markdoc, {
+} from "@markdoc/markdoc";
+import Slugger from "github-slugger";
+import { getTextContent } from "./runtime.js";
+import { MarkdocError } from "./utils.js";
+function getSlug(attributes, children, headingSlugger) {
+  if (attributes.id && typeof attributes.id === "string") {
+    return attributes.id;
+  }
+  const textContent = attributes.content ?? getTextContent(children);
+  let slug = headingSlugger.slug(textContent);
+  if (slug.endsWith("-"))
+    slug = slug.slice(0, -1);
+  return slug;
+}
+const heading = {
+  children: ["inline"],
+  attributes: {
+    id: { type: String },
+    level: { type: Number, required: true, default: 1 }
+  },
+  transform(node, config) {
+    const { level, ...attributes } = node.transformAttributes(config);
+    const children = node.transformChildren(config);
+    if (!config.ctx?.headingSlugger) {
+      throw new MarkdocError({
+        message: "Unexpected problem adding heading IDs to Markdoc file. Did you modify the `ctx.headingSlugger` property in your Markdoc config?"
+      });
+    }
+    const slug = getSlug(attributes, children, config.ctx.headingSlugger);
+    const render = config.nodes?.heading?.render ?? `h${level}`;
+    const tagProps = (
+      // For components, pass down `level` as a prop,
+      // alongside `__collectHeading` for our `headings` collector.
+      // Avoid accidentally rendering `level` as an HTML attribute otherwise!
+      typeof render === "string" ? { ...attributes, id: slug } : { ...attributes, id: slug, __collectHeading: true, level }
+    );
+    return new Markdoc.Tag(render, tagProps, children);
+  }
+};
+function setupHeadingConfig() {
+  const headingSlugger = new Slugger();
+  return {
+    ctx: {
+      headingSlugger
+    },
+    nodes: {
+      heading
+    }
+  };
+}
+export {
+  heading,
+  setupHeadingConfig
+};

package/dist/html/css/parse-inline-css-to-react.d.ts

@@ -0,0 +1 @@
+export declare function parseInlineCSSToReactLikeObject(css: string | undefined | null): React.CSSProperties | undefined;

package/dist/html/css/parse-inline-css-to-react.js

@@ -0,0 +1,21 @@
+import { styleToObject } from "./style-to-object.js";
+function parseInlineCSSToReactLikeObject(css) {
+  if (typeof css === "string") {
+    const cssObject = {};
+    styleToObject(css, (originalCssDirective, value) => {
+      const reactCssDirective = convertCssDirectiveNameToReactCamelCase(originalCssDirective);
+      cssObject[reactCssDirective] = value;
+    });
+    return cssObject;
+  }
+  return void 0;
+}
+function convertCssDirectiveNameToReactCamelCase(original) {
+  const replaced = original.replace(/-([a-z\d])/gi, (_match, char) => {
+    return char.toUpperCase();
+  });
+  return replaced;
+}
+export {
+  parseInlineCSSToReactLikeObject
+};

package/dist/html/css/parse-inline-styles.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {String} style
+ * @param {Object} [options]
+ * @return {Object[]}
+ * @throws {TypeError}
+ * @throws {Error}
+ */
+export declare function parseInlineStyles(style: any, options: any): any[];

package/dist/html/css/parse-inline-styles.js

@@ -0,0 +1,153 @@
+/**
+ * @license MIT
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2012 TJ Holowaychuk <tj@vision-media.ca>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+const COMMENT_REGEX = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g;
+const NEWLINE_REGEX = /\n/g;
+const WHITESPACE_REGEX = /^\s*/;
+const PROPERTY_REGEX = /^([-#/*\\\w]+(\[[\da-z_-]+\])?)\s*/;
+const COLON_REGEX = /^:\s*/;
+const VALUE_REGEX = /^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*\)|[^};])+)/;
+const SEMICOLON_REGEX = /^[;\s]*/;
+const TRIM_REGEX = /^\s+|\s+$/g;
+const NEWLINE = "\n";
+const FORWARD_SLASH = "/";
+const ASTERISK = "*";
+const EMPTY_STRING = "";
+const TYPE_COMMENT = "comment";
+const TYPE_DECLARATION = "declaration";
+function parseInlineStyles(style, options) {
+  if (typeof style !== "string") {
+    throw new TypeError("First argument must be a string");
+  }
+  if (!style)
+    return [];
+  options = options || {};
+  let lineno = 1;
+  let column = 1;
+  function updatePosition(str) {
+    let lines = str.match(NEWLINE_REGEX);
+    if (lines)
+      lineno += lines.length;
+    let i = str.lastIndexOf(NEWLINE);
+    column = ~i ? str.length - i : column + str.length;
+  }
+  function position() {
+    let start = { line: lineno, column };
+    return function(node) {
+      node.position = new Position(start);
+      whitespace();
+      return node;
+    };
+  }
+  function Position(start) {
+    this.start = start;
+    this.end = { line: lineno, column };
+    this.source = options.source;
+  }
+  Position.prototype.content = style;
+  const errorsList = [];
+  function error(msg) {
+    const err = new Error(options.source + ":" + lineno + ":" + column + ": " + msg);
+    err.reason = msg;
+    err.filename = options.source;
+    err.line = lineno;
+    err.column = column;
+    err.source = style;
+    if (options.silent) {
+      errorsList.push(err);
+    } else {
+      throw err;
+    }
+  }
+  function match(re) {
+    const m = re.exec(style);
+    if (!m)
+      return;
+    const str = m[0];
+    updatePosition(str);
+    style = style.slice(str.length);
+    return m;
+  }
+  function whitespace() {
+    match(WHITESPACE_REGEX);
+  }
+  function comments(rules) {
+    let c;
+    rules = rules || [];
+    while (c = comment()) {
+      if (c !== false) {
+        rules.push(c);
+      }
+    }
+    return rules;
+  }
+  function comment() {
+    const pos = position();
+    if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1))
+      return;
+    let i = 2;
+    while (EMPTY_STRING != style.charAt(i) && (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))) {
+      ++i;
+    }
+    i += 2;
+    if (EMPTY_STRING === style.charAt(i - 1)) {
+      return error("End of comment missing");
+    }
+    const str = style.slice(2, i - 2);
+    column += 2;
+    updatePosition(str);
+    style = style.slice(i);
+    column += 2;
+    return pos({
+      type: TYPE_COMMENT,
+      comment: str
+    });
+  }
+  function declaration() {
+    const pos = position();
+    const prop = match(PROPERTY_REGEX);
+    if (!prop)
+      return;
+    comment();
+    if (!match(COLON_REGEX))
+      return error("property missing ':'");
+    const val = match(VALUE_REGEX);
+    const ret = pos({
+      type: TYPE_DECLARATION,
+      property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),
+      value: val ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING)) : EMPTY_STRING
+    });
+    match(SEMICOLON_REGEX);
+    return ret;
+  }
+  function declarations() {
+    const decls = [];
+    comments(decls);
+    let decl;
+    while (decl = declaration()) {
+      if (decl !== false) {
+        decls.push(decl);
+        comments(decls);
+      }
+    }
+    return decls;
+  }
+  whitespace();
+  return declarations();
+}
+function trim(str) {
+  return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;
+}
+export {
+  parseInlineStyles
+};

package/dist/html/css/style-to-object.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Parses inline style to object.
+ *
+ * @example
+ * // returns { 'line-height': '42' }
+ * styleToObject('line-height: 42;');
+ *
+ * @param  {String}      style      - The inline style.
+ * @param  {Function}    [iterator] - The iterator function.
+ * @return {null|Object}
+ */
+export declare function styleToObject(style: any, iterator: any): {} | null;

package/dist/html/css/style-to-object.js

@@ -0,0 +1,53 @@
+/**
+ * @license MIT
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2017 Menglin "Mark" Xu <mark@remarkablemark.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+import { parseInlineStyles } from "./parse-inline-styles.js";
+function styleToObject(style, iterator) {
+  let output = null;
+  if (!style || typeof style !== "string") {
+    return output;
+  }
+  let declaration;
+  let declarations = parseInlineStyles(style);
+  let hasIterator = typeof iterator === "function";
+  let property;
+  let value;
+  for (let i = 0, len = declarations.length; i < len; i++) {
+    declaration = declarations[i];
+    property = declaration.property;
+    value = declaration.value;
+    if (hasIterator) {
+      iterator(property, value, declaration);
+    } else if (value) {
+      output || (output = {});
+      output[property] = value;
+    }
+  }
+  return output;
+}
+export {
+  styleToObject
+};

package/dist/html/index.d.ts

@@ -0,0 +1,2 @@
+export { htmlTag } from './tagdefs/html.tag.js';
+export { htmlTokenTransform } from './transform/html-token-transform.js';

package/dist/html/index.js

@@ -0,0 +1,6 @@
+import { htmlTag } from "./tagdefs/html.tag.js";
+import { htmlTokenTransform } from "./transform/html-token-transform.js";
+export {
+  htmlTag,
+  htmlTokenTransform
+};

package/dist/html/tagdefs/html.tag.d.ts

@@ -0,0 +1,2 @@
+import type { Config, Schema } from '@markdoc/markdoc';
+export declare const htmlTag: Schema<Config, never>;

package/dist/html/tagdefs/html.tag.js

@@ -0,0 +1,21 @@
+import Markdoc from "@markdoc/markdoc";
+import { parseInlineCSSToReactLikeObject } from "../css/parse-inline-css-to-react.js";
+const htmlTag = {
+  attributes: {
+    name: { type: String, required: true },
+    attrs: { type: Object }
+  },
+  transform(node, config) {
+    const { name, attrs: unsafeAttributes } = node.attributes;
+    const children = node.transformChildren(config);
+    const { style, ...safeAttributes } = unsafeAttributes;
+    if (typeof style === "string") {
+      const styleObject = parseInlineCSSToReactLikeObject(style);
+      safeAttributes.style = styleObject;
+    }
+    return new Markdoc.Tag(name, safeAttributes, children);
+  }
+};
+export {
+  htmlTag
+};

package/dist/html/transform/html-token-transform.d.ts

@@ -0,0 +1,3 @@
+import type { Tokenizer } from '@markdoc/markdoc';
+import type * as Token from 'markdown-it/lib/token';
+export declare function htmlTokenTransform(tokenizer: Tokenizer, tokens: Token[]): Token[];

package/dist/html/transform/html-token-transform.js

@@ -0,0 +1,154 @@
+import { Parser } from "htmlparser2";
+function htmlTokenTransform(tokenizer, tokens) {
+  const output = [];
+  let textBuffer = "";
+  let inCDATA = false;
+  const appendText = (text) => {
+    textBuffer += text;
+  };
+  const processTextBuffer = () => {
+    if (textBuffer.length > 0) {
+      const toks = tokenizer.tokenize(textBuffer);
+      if (toks.length === 3) {
+        const first = toks[0];
+        const second = toks[1];
+        const third = toks.at(2);
+        if (first.type === "paragraph_open" && second.type === "inline" && third && third.type === "paragraph_close" && Array.isArray(second.children)) {
+          for (const tok of second.children) {
+            if (tok.type === "text") {
+              if (tok.content.trim() == textBuffer.trim()) {
+                tok.content = textBuffer;
+              }
+            }
+            output.push(tok);
+          }
+        } else {
+          for (const tok of toks) {
+            output.push(tok);
+          }
+        }
+      } else {
+        for (const tok of toks) {
+          output.push(tok);
+        }
+      }
+      textBuffer = "";
+    }
+  };
+  const parser = new Parser(
+    {
+      oncdatastart() {
+        inCDATA = true;
+      },
+      oncdataend() {
+        inCDATA = false;
+      },
+      // when an HTML tag opens...
+      onopentag(name, attrs) {
+        processTextBuffer();
+        output.push({
+          type: "tag_open",
+          nesting: 1,
+          meta: {
+            tag: "html-tag",
+            attributes: [
+              { type: "attribute", name: "name", value: name },
+              { type: "attribute", name: "attrs", value: attrs }
+            ]
+          }
+        });
+      },
+      ontext(content) {
+        if (inCDATA) {
+          return;
+        }
+        if (typeof content === "string") {
+          appendText(content);
+        }
+      },
+      // when an HTML tag closes...
+      onclosetag(name) {
+        processTextBuffer();
+        output.push({
+          type: "tag_close",
+          nesting: -1,
+          meta: {
+            tag: "html-tag",
+            attributes: [{ type: "attribute", name: "name", value: name }]
+          }
+        });
+      }
+    },
+    {
+      decodeEntities: false,
+      recognizeCDATA: true,
+      recognizeSelfClosing: true
+    }
+  );
+  for (const token of tokens) {
+    if (token.type.startsWith("html")) {
+      parser.write(token.content);
+      continue;
+    }
+    if (token.type === "inline") {
+      if (token.children) {
+        token.children = htmlTokenTransform(tokenizer, token.children);
+      }
+    }
+    output.push(token);
+  }
+  processTextBuffer();
+  mutateAndCollapseExtraParagraphsUnderHtml(output);
+  return output;
+}
+function mutateAndCollapseExtraParagraphsUnderHtml(tokens) {
+  let done = false;
+  while (!done) {
+    const idx = findExtraParagraphUnderHtml(tokens);
+    if (typeof idx === "number") {
+      const actualChildTokens = tokens[idx + 2].children ?? [];
+      tokens.splice(idx, 5, ...actualChildTokens);
+    } else {
+      done = true;
+    }
+  }
+}
+function findExtraParagraphUnderHtml(tokens) {
+  if (tokens.length < 5) {
+    return null;
+  }
+  for (let i = 0; i < tokens.length; i++) {
+    const last = i + 4;
+    if (last > tokens.length - 1) {
+      break;
+    }
+    const slice = tokens.slice(i, last + 1);
+    const isMatch = isExtraParagraphPatternMatch(slice);
+    if (isMatch) {
+      return i;
+    }
+  }
+  return null;
+}
+function isExtraParagraphPatternMatch(slice) {
+  const match = isHtmlTagOpen(slice[0]) && isParagraphOpen(slice[1]) && isInline(slice[2]) && isParagraphClose(slice[3]) && isHtmlTagClose(slice[4]);
+  return match;
+}
+function isHtmlTagOpen(token) {
+  return token.type === "tag_open" && token.meta && token.meta.tag === "html-tag";
+}
+function isHtmlTagClose(token) {
+  return token.type === "tag_close" && token.meta && token.meta.tag === "html-tag";
+}
+function isParagraphOpen(token) {
+  return token.type === "paragraph_open";
+}
+function isParagraphClose(token) {
+  return token.type === "paragraph_close";
+}
+function isInline(token) {
+  return token.type === "inline";
+}
+export {
+  htmlTokenTransform
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { AstroIntegration } from 'astro';
+import type { MarkdocIntegrationOptions } from './options.js';
+export default function markdocIntegration(options?: MarkdocIntegrationOptions): AstroIntegration;

package/dist/index.js

@@ -0,0 +1,39 @@
+import { getContentEntryType } from "./content-entry-type.js";
+import {
+  SUPPORTED_MARKDOC_CONFIG_FILES,
+  loadMarkdocConfig
+} from "./load-config.js";
+function markdocIntegration(options) {
+  let markdocConfigResult;
+  let astroConfig;
+  return {
+    name: "@astrojs/markdoc",
+    hooks: {
+      "astro:config:setup": async (params) => {
+        const { updateConfig, addContentEntryType } = params;
+        astroConfig = params.config;
+        markdocConfigResult = await loadMarkdocConfig(astroConfig);
+        addContentEntryType(
+          await getContentEntryType({ markdocConfigResult, astroConfig, options })
+        );
+        updateConfig({
+          vite: {
+            ssr: {
+              external: ["@astrojs/markdoc/prism", "@astrojs/markdoc/shiki"]
+            }
+          }
+        });
+      },
+      "astro:server:setup": async ({ server }) => {
+        server.watcher.on("all", (event, entry) => {
+          if (SUPPORTED_MARKDOC_CONFIG_FILES.some((f) => entry.endsWith(f))) {
+            server.restart();
+          }
+        });
+      }
+    }
+  };
+}
+export {
+  markdocIntegration as default
+};

package/dist/load-config.d.ts

@@ -0,0 +1,8 @@
+import type { AstroConfig } from 'astro';
+import type { AstroMarkdocConfig } from './config.js';
+export declare const SUPPORTED_MARKDOC_CONFIG_FILES: string[];
+export type MarkdocConfigResult = {
+    config: AstroMarkdocConfig;
+    fileUrl: URL;
+};
+export declare function loadMarkdocConfig(astroConfig: Pick<AstroConfig, 'root'>): Promise<MarkdocConfigResult | undefined>;