mdream 0.1.1

package/dist/shared/mdream.5zaIXVJz.mjs

@@ -0,0 +1,508 @@
+import { ae as TEXT_NODE, aa as ELEMENT_NODE, a7 as TAG_MAIN, C as TAG_HEADER, B as TAG_FOOTER, I as TAG_H1, H as TAG_H2, G as TAG_H3, F as TAG_H4, E as TAG_H5, D as TAG_H6 } from './mdream.-hdaPj9a.mjs';
+import { c as createPlugin } from './mdream.cpEmpxyh.mjs';
+
+class TagSelector {
+  constructor(tagName) {
+    this.tagName = tagName;
+  }
+  matches(element) {
+    return element.name === this.tagName;
+  }
+  toString() {
+    return this.tagName;
+  }
+}
+class IdSelector {
+  id;
+  constructor(selector) {
+    this.id = selector.slice(1);
+  }
+  matches(element) {
+    return element.attributes?.id === this.id;
+  }
+  toString() {
+    return `#${this.id}`;
+  }
+}
+class ClassSelector {
+  className;
+  constructor(selector) {
+    this.className = selector.slice(1);
+  }
+  matches(element) {
+    if (!element.attributes?.class)
+      return false;
+    const classes = element.attributes.class.trim().split(" ").filter(Boolean);
+    return classes.includes(this.className);
+  }
+  toString() {
+    return `.${this.className}`;
+  }
+}
+class AttributeSelector {
+  attrName;
+  attrValue;
+  operator;
+  constructor(selector) {
+    const match = selector.match(/\[([^\]=~|^$*]+)(?:([=~|^$*]+)["']?([^"'\]]+)["']?)?\]/);
+    if (match) {
+      this.attrName = match[1];
+      this.operator = match[2];
+      this.attrValue = match[3];
+    } else {
+      this.attrName = selector.slice(1, -1);
+    }
+  }
+  matches(element) {
+    if (!(this.attrName in (element.attributes || {}))) {
+      return false;
+    }
+    if (!this.operator || !this.attrValue) {
+      return true;
+    }
+    const value = element.attributes[this.attrName];
+    switch (this.operator) {
+      case "=":
+        return value === this.attrValue;
+      case "^=":
+        return value.startsWith(this.attrValue);
+      case "$=":
+        return value.endsWith(this.attrValue);
+      case "*=":
+        return value.includes(this.attrValue);
+      case "~=":
+        return value.trim().split(" ").filter(Boolean).includes(this.attrValue);
+      case "|=":
+        return value === this.attrValue || value.startsWith(`${this.attrValue}-`);
+      default:
+        return false;
+    }
+  }
+  toString() {
+    if (!this.operator || !this.attrValue) {
+      return `[${this.attrName}]`;
+    }
+    return `[${this.attrName}${this.operator}${this.attrValue}]`;
+  }
+}
+class CompoundSelector {
+  constructor(selectors) {
+    this.selectors = selectors;
+  }
+  matches(element) {
+    return this.selectors.every((selector) => selector.matches(element));
+  }
+  toString() {
+    return this.selectors.map((s) => s.toString()).join("");
+  }
+}
+function parseSelector(selector) {
+  selector = selector.trim();
+  if (!selector) {
+    throw new Error("Empty selector");
+  }
+  const selectorParts = [];
+  let current = "";
+  let inAttribute = false;
+  for (let i = 0; i < selector.length; i++) {
+    const char = selector[i];
+    if ((char === "." || char === "#" || char === "[") && current) {
+      if (current[0] === ".") {
+        selectorParts.push(new ClassSelector(current));
+      } else if (current[0] === "#") {
+        selectorParts.push(new IdSelector(current));
+      } else if (current[0] === "[") {
+        selectorParts.push(new AttributeSelector(current));
+      } else {
+        selectorParts.push(new TagSelector(current));
+      }
+      current = char;
+    } else {
+      current += char;
+    }
+    if (char === "[")
+      inAttribute = true;
+    if (char === "]")
+      inAttribute = false;
+    if (inAttribute && char !== "[") {
+      continue;
+    }
+  }
+  if (current) {
+    if (current[0] === ".") {
+      selectorParts.push(new ClassSelector(current));
+    } else if (current[0] === "#") {
+      selectorParts.push(new IdSelector(current));
+    } else if (current[0] === "[") {
+      selectorParts.push(new AttributeSelector(current));
+    } else {
+      selectorParts.push(new TagSelector(current));
+    }
+  }
+  if (selectorParts.length === 1) {
+    return selectorParts[0];
+  }
+  return new CompoundSelector(selectorParts);
+}
+function filterPlugin(options = {}) {
+  const includeSelectors = options.include?.map((selector) => {
+    if (typeof selector === "string") {
+      return parseSelector(selector);
+    }
+    return { matches: (element) => element.tagId === selector };
+  }) || [];
+  const excludeSelectors = options.exclude?.map((selector) => {
+    if (typeof selector === "string") {
+      return parseSelector(selector);
+    }
+    return { matches: (element) => element.tagId === selector };
+  }) || [];
+  const processChildren = options.processChildren !== false;
+  return createPlugin({
+    // Handle include/exclude filtering for elements and text nodes
+    beforeNodeProcess(event) {
+      const { node } = event;
+      if (node.type === TEXT_NODE) {
+        const textNode = node;
+        let currentParent2 = textNode.parent;
+        while (currentParent2 && excludeSelectors.length) {
+          const parentShouldExclude = excludeSelectors.some((selector) => selector.matches(currentParent2));
+          if (parentShouldExclude) {
+            return { skip: true };
+          }
+          currentParent2 = currentParent2.parent;
+        }
+        return;
+      }
+      if (node.type !== ELEMENT_NODE) {
+        return;
+      }
+      const element = node;
+      if (excludeSelectors.length) {
+        if (element.attributes.style?.includes("absolute") || element.attributes.style?.includes("fixed")) {
+          return { skip: true };
+        }
+        const shouldExclude = excludeSelectors.some((selector) => selector.matches(element));
+        if (shouldExclude) {
+          return { skip: true };
+        }
+      }
+      let currentParent = element.parent;
+      while (currentParent) {
+        if (excludeSelectors.length) {
+          const parentShouldExclude = excludeSelectors.some((selector) => selector.matches(currentParent));
+          if (parentShouldExclude) {
+            return { skip: true };
+          }
+        }
+        currentParent = currentParent.parent;
+      }
+      if (includeSelectors.length) {
+        let currentElement = element;
+        while (currentElement) {
+          const shouldInclude = includeSelectors.some((selector) => selector.matches(currentElement));
+          if (shouldInclude) {
+            return;
+          }
+          if (!processChildren)
+            break;
+          currentElement = currentElement.parent;
+        }
+        return { skip: true };
+      }
+    }
+  });
+}
+
+function isolateMainPlugin() {
+  let mainElement = null;
+  let firstHeaderElement = null;
+  let afterFooter = false;
+  const headerTagIds = /* @__PURE__ */ new Set([TAG_H1, TAG_H2, TAG_H3, TAG_H4, TAG_H5, TAG_H6]);
+  return createPlugin({
+    beforeNodeProcess(event) {
+      const { node } = event;
+      if (node.type === ELEMENT_NODE) {
+        const element = node;
+        if (!mainElement && element.tagId === TAG_MAIN && element.depth <= 5) {
+          mainElement = element;
+          return;
+        }
+        if (mainElement) {
+          let current = element.parent;
+          let isInsideMain = element === mainElement;
+          while (current && !isInsideMain) {
+            if (current === mainElement) {
+              isInsideMain = true;
+              break;
+            }
+            current = current.parent;
+          }
+          if (!isInsideMain) {
+            return { skip: true };
+          }
+          return;
+        }
+        if (!firstHeaderElement && headerTagIds.has(element.tagId)) {
+          let current = element.parent;
+          let isInHeaderTag = false;
+          while (current) {
+            if (current.tagId === TAG_HEADER) {
+              isInHeaderTag = true;
+              break;
+            }
+            current = current.parent;
+          }
+          if (!isInHeaderTag) {
+            firstHeaderElement = element;
+            return;
+          }
+        }
+        if (firstHeaderElement && !afterFooter && element.tagId === TAG_FOOTER) {
+          const depthDifference = element.depth - firstHeaderElement.depth;
+          if (depthDifference <= 5) {
+            afterFooter = true;
+            return { skip: true };
+          }
+        }
+        if (!firstHeaderElement) {
+          return { skip: true };
+        }
+        if (afterFooter) {
+          return { skip: true };
+        }
+      }
+      if (node.type === TEXT_NODE) {
+        if (mainElement) {
+          let current = node.parent;
+          let isInsideMain = false;
+          while (current) {
+            if (current === mainElement) {
+              isInsideMain = true;
+              break;
+            }
+            current = current.parent;
+          }
+          if (!isInsideMain) {
+            return { skip: true };
+          }
+          return;
+        }
+        if (!firstHeaderElement || afterFooter) {
+          return { skip: true };
+        }
+      }
+    }
+  });
+}
+
+const TAILWIND_TO_MARKDOWN_MAP = {
+  // Typography
+  "font-bold": { prefix: "**", suffix: "**" },
+  "font-semibold": { prefix: "**", suffix: "**" },
+  "font-black": { prefix: "**", suffix: "**" },
+  "font-extrabold": { prefix: "**", suffix: "**" },
+  "font-medium": { prefix: "**", suffix: "**" },
+  "font-italic": { prefix: "*", suffix: "*" },
+  "italic": { prefix: "*", suffix: "*" },
+  "line-through": { prefix: "~~", suffix: "~~" },
+  // Display properties - hide elements
+  "hidden": { hidden: true },
+  "invisible": { hidden: true },
+  // Position properties - hide positioned elements
+  "absolute": { hidden: true },
+  "fixed": { hidden: true },
+  "sticky": { hidden: true }
+};
+function extractBaseClass(className) {
+  const breakpoints = ["sm:", "md:", "lg:", "xl:", "2xl:"];
+  for (const bp of breakpoints) {
+    if (className.startsWith(bp)) {
+      return {
+        baseClass: className.substring(bp.length),
+        breakpoint: bp
+      };
+    }
+  }
+  return {
+    baseClass: className,
+    breakpoint: ""
+    // Base/mobile class (no breakpoint)
+  };
+}
+function sortByBreakpoint(classes) {
+  const breakpointOrder = {
+    "": 0,
+    // Base/mobile (no breakpoint)
+    "sm:": 1,
+    "md:": 2,
+    "lg:": 3,
+    "xl:": 4,
+    "2xl:": 5
+  };
+  return [...classes].sort((a, b) => {
+    const aBreakpoint = extractBaseClass(a).breakpoint;
+    const bBreakpoint = extractBaseClass(b).breakpoint;
+    return breakpointOrder[aBreakpoint] - breakpointOrder[bBreakpoint];
+  });
+}
+function groupByFormattingType(classes) {
+  const sorted = sortByBreakpoint(classes);
+  const groups = {
+    emphasis: [],
+    // italic, etc.
+    weight: [],
+    // bold, etc.
+    decoration: [],
+    // strikethrough, etc.
+    display: [],
+    // hidden, etc.
+    position: [],
+    // absolute, fixed, etc.
+    other: []
+  };
+  for (const cls of sorted) {
+    const { baseClass } = extractBaseClass(cls);
+    if (baseClass.includes("italic")) {
+      groups.emphasis.push(cls);
+    } else if (baseClass.includes("font-") || baseClass === "bold") {
+      groups.weight.push(cls);
+    } else if (baseClass.includes("line-through") || baseClass.includes("underline")) {
+      groups.decoration.push(cls);
+    } else if (baseClass === "hidden" || baseClass.includes("invisible")) {
+      groups.display.push(cls);
+    } else if (["absolute", "fixed", "sticky"].includes(baseClass)) {
+      groups.position.push(cls);
+    } else {
+      groups.other.push(cls);
+    }
+  }
+  return groups;
+}
+function fixRedundantDelimiters(content) {
+  content = content.replaceAll("****", "**");
+  content = content.replaceAll("~~~~", "~~");
+  if (content.includes("***") && content.split("***").length > 3) {
+    const parts = content.split("***");
+    if (parts.length >= 4) {
+      content = `${parts[0]}***${parts[1]} ${parts[2]}***${parts.slice(3).join("***")}`;
+    }
+  }
+  return content;
+}
+function normalizeClasses(classes) {
+  const result = [];
+  const mobileClasses = classes.filter((cls) => !hasBreakpoint(cls));
+  const breakpointClasses = classes.filter((cls) => hasBreakpoint(cls));
+  result.push(...mobileClasses);
+  result.push(...breakpointClasses);
+  return result;
+}
+function hasBreakpoint(className) {
+  const { breakpoint } = extractBaseClass(className);
+  return breakpoint !== "";
+}
+function processTailwindClasses(classes) {
+  let prefix = "";
+  let suffix = "";
+  let hidden = false;
+  const normalizedClasses = normalizeClasses(classes);
+  const grouped = groupByFormattingType(normalizedClasses);
+  if (grouped.weight.length > 0) {
+    const { baseClass } = extractBaseClass(grouped.weight[0]);
+    const mapping = TAILWIND_TO_MARKDOWN_MAP[baseClass];
+    if (mapping) {
+      if (mapping.prefix)
+        prefix += mapping.prefix;
+      if (mapping.suffix)
+        suffix = mapping.suffix + suffix;
+    }
+  }
+  if (grouped.emphasis.length > 0) {
+    const { baseClass } = extractBaseClass(grouped.emphasis[0]);
+    const mapping = TAILWIND_TO_MARKDOWN_MAP[baseClass];
+    if (mapping) {
+      if (mapping.prefix)
+        prefix += mapping.prefix;
+      if (mapping.suffix)
+        suffix = mapping.suffix + suffix;
+    }
+  }
+  if (grouped.decoration.length > 0) {
+    const { baseClass } = extractBaseClass(grouped.decoration[0]);
+    const mapping = TAILWIND_TO_MARKDOWN_MAP[baseClass];
+    if (mapping) {
+      if (mapping.prefix)
+        prefix += mapping.prefix;
+      if (mapping.suffix)
+        suffix = mapping.suffix + suffix;
+    }
+  }
+  for (const cls of grouped.display) {
+    const { baseClass } = extractBaseClass(cls);
+    const mapping = TAILWIND_TO_MARKDOWN_MAP[baseClass];
+    if (mapping && mapping.hidden) {
+      hidden = true;
+      break;
+    }
+  }
+  for (const cls of grouped.position) {
+    const { baseClass } = extractBaseClass(cls);
+    const mapping = TAILWIND_TO_MARKDOWN_MAP[baseClass];
+    if (mapping && mapping.hidden) {
+      hidden = true;
+      break;
+    }
+  }
+  return { prefix, suffix, hidden };
+}
+function tailwindPlugin() {
+  return createPlugin({
+    // Process node attributes to extract Tailwind classes
+    processAttributes(node) {
+      const classAttr = node.attributes?.class;
+      if (!classAttr) {
+        return;
+      }
+      const classes = classAttr.trim().split(" ").filter(Boolean);
+      const { prefix, suffix, hidden } = processTailwindClasses(classes);
+      node.context = node.context || {};
+      node.context.tailwind = {
+        prefix,
+        suffix,
+        hidden
+      };
+    },
+    // Process text nodes to apply Tailwind formatting
+    processTextNode(node) {
+      const parentNode = node.parent;
+      if (!parentNode || parentNode.type !== ELEMENT_NODE) {
+        return void 0;
+      }
+      const tailwindData = parentNode.context?.tailwind;
+      if (tailwindData?.hidden) {
+        return { content: "", skip: true };
+      }
+      let content = node.value;
+      const prefix = tailwindData?.prefix || "";
+      const suffix = tailwindData?.suffix || "";
+      if (prefix || suffix) {
+        content = prefix + content + suffix;
+        content = fixRedundantDelimiters(content);
+      }
+      return { content, skip: false };
+    },
+    // Filter out hidden elements
+    beforeNodeProcess({ node }) {
+      if (node.type === ELEMENT_NODE) {
+        const elementNode = node;
+        const tailwindData = elementNode.context?.tailwind;
+        if (tailwindData?.hidden) {
+          return { skip: true };
+        }
+      }
+    }
+  });
+}
+
+export { filterPlugin as f, isolateMainPlugin as i, tailwindPlugin as t };