@blogmcp/mdx-render-vue 0.1.0

package/dist/node_modules/@zag-js/anatomy/dist/create-anatomy.js

@@ -0,0 +1,29 @@
+var createAnatomy = (name, parts = []) => ({
+  parts: (...values) => {
+    if (isEmpty(parts)) {
+      return createAnatomy(name, values);
+    }
+    throw new Error("createAnatomy().parts(...) should only be called once. Did you mean to use .extendWith(...) ?");
+  },
+  extendWith: (...values) => createAnatomy(name, [...parts, ...values]),
+  omit: (...values) => createAnatomy(name, parts.filter((part) => !values.includes(part))),
+  rename: (newName) => createAnatomy(newName, parts),
+  keys: () => parts,
+  build: () => [...new Set(parts)].reduce(
+    (prev, part) => Object.assign(prev, {
+      [part]: {
+        selector: [
+          `&[data-scope="${toKebabCase(name)}"][data-part="${toKebabCase(part)}"]`,
+          `& [data-scope="${toKebabCase(name)}"][data-part="${toKebabCase(part)}"]`
+        ].join(", "),
+        attrs: { "data-scope": toKebabCase(name), "data-part": toKebabCase(part) }
+      }
+    }),
+    {}
+  )
+});
+var toKebabCase = (value) => value.replace(/([A-Z])([A-Z])/g, "$1-$2").replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+var isEmpty = (v) => v.length === 0;
+export {
+  createAnatomy
+};

package/dist/node_modules/@zag-js/core/dist/create-machine.js

@@ -0,0 +1,28 @@
+import { ensureStateIndex } from "./state.js";
+function createGuards() {
+  return {
+    and: (...guards) => {
+      return function andGuard(params) {
+        return guards.every((str) => params.guard(str));
+      };
+    },
+    or: (...guards) => {
+      return function orGuard(params) {
+        return guards.some((str) => params.guard(str));
+      };
+    },
+    not: (guard) => {
+      return function notGuard(params) {
+        return !params.guard(guard);
+      };
+    }
+  };
+}
+function createMachine(config) {
+  ensureStateIndex(config);
+  return config;
+}
+export {
+  createGuards,
+  createMachine
+};

package/dist/node_modules/@zag-js/core/dist/merge-props.js

@@ -0,0 +1,55 @@
+import { callAll } from "../../utils/dist/functions.js";
+import { isString } from "../../utils/dist/guard.js";
+var clsx = (...args) => args.map((str) => str?.trim?.()).filter(Boolean).join(" ");
+var CSS_REGEX = /((?:--)?(?:\w+-?)+)\s*:\s*([^;]*)/g;
+var serialize = (style) => {
+  const res = {};
+  let match;
+  while (match = CSS_REGEX.exec(style)) {
+    res[match[1]] = match[2];
+  }
+  return res;
+};
+var css = (a, b) => {
+  if (isString(a)) {
+    if (isString(b)) return `${a};${b}`;
+    a = serialize(a);
+  } else if (isString(b)) {
+    b = serialize(b);
+  }
+  return Object.assign({}, a ?? {}, b ?? {});
+};
+function mergeProps(...args) {
+  let result = {};
+  for (let props of args) {
+    if (!props) continue;
+    for (let key in result) {
+      if (key.startsWith("on") && typeof result[key] === "function" && typeof props[key] === "function") {
+        result[key] = callAll(props[key], result[key]);
+        continue;
+      }
+      if (key === "className" || key === "class") {
+        result[key] = clsx(result[key], props[key]);
+        continue;
+      }
+      if (key === "style") {
+        result[key] = css(result[key], props[key]);
+        continue;
+      }
+      result[key] = props[key] !== void 0 ? props[key] : result[key];
+    }
+    for (let key in props) {
+      if (result[key] === void 0) {
+        result[key] = props[key];
+      }
+    }
+    const symbols = Object.getOwnPropertySymbols(props);
+    for (let symbol of symbols) {
+      result[symbol] = props[symbol];
+    }
+  }
+  return result;
+}
+export {
+  mergeProps
+};

package/dist/node_modules/@zag-js/core/dist/scope.js

@@ -0,0 +1,20 @@
+import { isActiveElement, getActiveElement, getDocument } from "../../dom-query/dist/node.js";
+function createScope(props) {
+  const getRootNode = () => props.getRootNode?.() ?? document;
+  const getDoc = () => getDocument(getRootNode());
+  const getWin = () => getDoc().defaultView ?? window;
+  const getActiveElementFn = () => getActiveElement(getRootNode());
+  const getById = (id) => getRootNode().getElementById(id);
+  return {
+    ...props,
+    getRootNode,
+    getDoc,
+    getWin,
+    getActiveElement: getActiveElementFn,
+    isActiveElement,
+    getById
+  };
+}
+export {
+  createScope
+};

package/dist/node_modules/@zag-js/core/dist/state.js

@@ -0,0 +1,176 @@
+import { ensure, invariant } from "../../utils/dist/warning.js";
+var STATE_DELIMITER = ".";
+var ABSOLUTE_PREFIX = "#";
+var stateIndexCache = /* @__PURE__ */ new WeakMap();
+var stateIdIndexCache = /* @__PURE__ */ new WeakMap();
+function joinStatePath(parts) {
+  return parts.join(STATE_DELIMITER);
+}
+function isAbsoluteStatePath(value) {
+  return value.includes(STATE_DELIMITER);
+}
+function isExplicitAbsoluteStatePath(value) {
+  return value.startsWith(ABSOLUTE_PREFIX);
+}
+function isChildTarget(value) {
+  return value.startsWith(STATE_DELIMITER);
+}
+function stripAbsolutePrefix(value) {
+  return isExplicitAbsoluteStatePath(value) ? value.slice(ABSOLUTE_PREFIX.length) : value;
+}
+function appendStatePath(base, segment) {
+  return base ? `${base}${STATE_DELIMITER}${segment}` : segment;
+}
+function buildStateIndex(machine) {
+  const index = /* @__PURE__ */ new Map();
+  const idIndex = /* @__PURE__ */ new Map();
+  const visit = (basePath, state) => {
+    index.set(basePath, state);
+    const stateId = state.id;
+    if (stateId) {
+      if (idIndex.has(stateId)) {
+        invariant(`[zag-js] Duplicate state id: "${stateId}"`);
+      }
+      idIndex.set(stateId, basePath);
+    }
+    const childStates = state.states;
+    if (!childStates) return;
+    ensure(state.initial, () => `[zag-js] Compound state "${basePath}" has child states but no "initial" property`);
+    if (!(state.initial in childStates)) {
+      invariant(
+        `[zag-js] Compound state "${basePath}" has initial "${String(state.initial)}" which is not a child state`
+      );
+    }
+    for (const [childKey, childState] of Object.entries(childStates)) {
+      if (!childState) continue;
+      const childPath = appendStatePath(basePath, childKey);
+      visit(childPath, childState);
+    }
+  };
+  for (const [topKey, topState] of Object.entries(machine.states)) {
+    if (!topState) continue;
+    visit(topKey, topState);
+  }
+  return { index, idIndex };
+}
+function ensureStateIndex(machine) {
+  const cached = stateIndexCache.get(machine);
+  if (cached) return cached;
+  const { index, idIndex } = buildStateIndex(machine);
+  stateIndexCache.set(machine, index);
+  stateIdIndexCache.set(machine, idIndex);
+  return index;
+}
+function getStatePathById(machine, stateId) {
+  ensureStateIndex(machine);
+  return stateIdIndexCache.get(machine)?.get(stateId);
+}
+function toSegments(value) {
+  if (!value) return [];
+  return String(value).split(STATE_DELIMITER).filter(Boolean);
+}
+function getStateChain(machine, state) {
+  if (!state) return [];
+  const stateIndex = ensureStateIndex(machine);
+  const segments = toSegments(state);
+  const chain = [];
+  const statePath = [];
+  for (const segment of segments) {
+    statePath.push(segment);
+    const path = joinStatePath(statePath);
+    const current = stateIndex.get(path);
+    if (!current) break;
+    chain.push({ path, state: current });
+  }
+  return chain;
+}
+function resolveAbsoluteStateValue(machine, value) {
+  const stateIndex = ensureStateIndex(machine);
+  const segments = toSegments(value);
+  if (!segments.length) return value;
+  const resolved = [];
+  for (const segment of segments) {
+    resolved.push(segment);
+    const path = joinStatePath(resolved);
+    if (!stateIndex.has(path)) return value;
+  }
+  let resolvedPath = joinStatePath(resolved);
+  let current = stateIndex.get(resolvedPath);
+  while (current?.initial) {
+    const nextPath = `${resolvedPath}${STATE_DELIMITER}${current.initial}`;
+    const nextState = stateIndex.get(nextPath);
+    if (!nextState) break;
+    resolvedPath = nextPath;
+    current = nextState;
+  }
+  return resolvedPath;
+}
+function hasStatePath(machine, value) {
+  const stateIndex = ensureStateIndex(machine);
+  return stateIndex.has(value);
+}
+function resolveStateValue(machine, value, source) {
+  const stateValue = String(value);
+  if (isExplicitAbsoluteStatePath(stateValue)) {
+    const stateId = stripAbsolutePrefix(stateValue);
+    const statePath = getStatePathById(machine, stateId);
+    ensure(statePath, () => `[zag-js] Unknown state id: "${stateId}"`);
+    return resolveAbsoluteStateValue(machine, statePath);
+  }
+  if (isChildTarget(stateValue) && source) {
+    const childPath = appendStatePath(source, stateValue.slice(1));
+    return resolveAbsoluteStateValue(machine, childPath);
+  }
+  if (!isAbsoluteStatePath(stateValue) && source) {
+    const sourceSegments = toSegments(source);
+    for (let index = sourceSegments.length - 1; index >= 1; index--) {
+      const base = sourceSegments.slice(0, index).join(STATE_DELIMITER);
+      const candidate = appendStatePath(base, stateValue);
+      if (hasStatePath(machine, candidate)) return resolveAbsoluteStateValue(machine, candidate);
+    }
+    if (hasStatePath(machine, stateValue)) return resolveAbsoluteStateValue(machine, stateValue);
+  }
+  return resolveAbsoluteStateValue(machine, stateValue);
+}
+function findTransition(machine, state, eventType) {
+  const chain = getStateChain(machine, state);
+  for (let index = chain.length - 1; index >= 0; index--) {
+    const transitionMap = chain[index]?.state.on;
+    const transition = transitionMap?.[eventType];
+    if (transition) return { transitions: transition, source: chain[index]?.path };
+  }
+  const rootTransitionMap = machine.on;
+  return { transitions: rootTransitionMap?.[eventType], source: void 0 };
+}
+function getExitEnterStates(machine, prevState, nextState, reenter) {
+  const prevChain = prevState ? getStateChain(machine, prevState) : [];
+  const nextChain = getStateChain(machine, nextState);
+  let commonIndex = 0;
+  while (commonIndex < prevChain.length && commonIndex < nextChain.length && prevChain[commonIndex]?.path === nextChain[commonIndex]?.path) {
+    commonIndex += 1;
+  }
+  let exiting = prevChain.slice(commonIndex).reverse();
+  let entering = nextChain.slice(commonIndex);
+  const sameLeaf = prevChain.at(-1)?.path === nextChain.at(-1)?.path;
+  if (reenter && sameLeaf) {
+    exiting = prevChain.slice().reverse();
+    entering = nextChain;
+  }
+  return { exiting, entering };
+}
+function matchesState(current, value) {
+  if (!current) return false;
+  return current === value || current.startsWith(`${value}${STATE_DELIMITER}`);
+}
+function hasTag(machine, state, tag) {
+  return getStateChain(machine, state).some((item) => item.state.tags?.includes(tag));
+}
+export {
+  ensureStateIndex,
+  findTransition,
+  getExitEnterStates,
+  getStateChain,
+  hasTag,
+  matchesState,
+  resolveStateValue
+};

package/dist/node_modules/@zag-js/core/dist/types.js

@@ -0,0 +1,11 @@
+var MachineStatus = /* @__PURE__ */ ((MachineStatus2) => {
+  MachineStatus2["NotStarted"] = "Not Started";
+  MachineStatus2["Started"] = "Started";
+  MachineStatus2["Stopped"] = "Stopped";
+  return MachineStatus2;
+})(MachineStatus || {});
+var INIT_STATE = "__init__";
+export {
+  INIT_STATE,
+  MachineStatus
+};

package/dist/node_modules/@zag-js/dom-query/dist/chunk-QZ7TP4HQ.js

@@ -0,0 +1,6 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+export {
+  __publicField
+};

package/dist/node_modules/@zag-js/dom-query/dist/computed-style.js

@@ -0,0 +1,11 @@
+import { getWindow } from "./node.js";
+var styleCache = /* @__PURE__ */ new WeakMap();
+function getComputedStyle(el) {
+  if (!styleCache.has(el)) {
+    styleCache.set(el, getWindow(el).getComputedStyle(el));
+  }
+  return styleCache.get(el);
+}
+export {
+  getComputedStyle
+};

package/dist/node_modules/@zag-js/dom-query/dist/event.js

@@ -0,0 +1,37 @@
+import { isAndroid } from "./platform.js";
+function getComposedPath(event) {
+  return event.composedPath?.() ?? event.nativeEvent?.composedPath?.();
+}
+function getEventTarget(event) {
+  const composedPath = getComposedPath(event);
+  return composedPath?.[0] ?? event.target;
+}
+function isComposingEvent(event) {
+  return getNativeEvent(event).isComposing || event.keyCode === 229;
+}
+function isVirtualClick(e) {
+  if (e.pointerType === "" && e.isTrusted) return true;
+  if (isAndroid() && e.pointerType) {
+    return e.type === "click" && e.buttons === 1;
+  }
+  return e.detail === 0 && !e.pointerType;
+}
+var isLeftClick = (e) => e.button === 0;
+function getNativeEvent(event) {
+  return event.nativeEvent ?? event;
+}
+var addDomEvent = (target, eventName, handler, options) => {
+  const node = typeof target === "function" ? target() : target;
+  node?.addEventListener(eventName, handler, options);
+  return () => {
+    node?.removeEventListener(eventName, handler, options);
+  };
+};
+export {
+  addDomEvent,
+  getEventTarget,
+  getNativeEvent,
+  isComposingEvent,
+  isLeftClick,
+  isVirtualClick
+};

package/dist/node_modules/@zag-js/dom-query/dist/node.js

@@ -0,0 +1,64 @@
+import { isObject } from "./shared.js";
+var ELEMENT_NODE = 1;
+var DOCUMENT_NODE = 9;
+var DOCUMENT_FRAGMENT_NODE = 11;
+var isHTMLElement = (el) => isObject(el) && el.nodeType === ELEMENT_NODE && typeof el.nodeName === "string";
+var isDocument = (el) => isObject(el) && el.nodeType === DOCUMENT_NODE;
+var isWindow = (el) => isObject(el) && el === el.window;
+var getNodeName = (node) => {
+  if (isHTMLElement(node)) return node.localName || "";
+  return "#document";
+};
+function isRootElement(node) {
+  return ["html", "body", "#document"].includes(getNodeName(node));
+}
+var isNode = (el) => isObject(el) && el.nodeType !== void 0;
+var isShadowRoot = (el) => isNode(el) && el.nodeType === DOCUMENT_FRAGMENT_NODE && "host" in el;
+function isActiveElement(element) {
+  if (!element) return false;
+  const rootNode = element.getRootNode();
+  return getActiveElement(rootNode) === element;
+}
+function getDocument(el) {
+  if (isDocument(el)) return el;
+  if (isWindow(el)) return el.document;
+  return el?.ownerDocument ?? document;
+}
+function getDocumentElement(el) {
+  return getDocument(el).documentElement;
+}
+function getWindow(el) {
+  if (isShadowRoot(el)) return getWindow(el.host);
+  if (isDocument(el)) return el.defaultView ?? window;
+  if (isHTMLElement(el)) return el.ownerDocument?.defaultView ?? window;
+  return window;
+}
+function getActiveElement(rootNode) {
+  let activeElement = rootNode.activeElement;
+  while (activeElement?.shadowRoot) {
+    const el = activeElement.shadowRoot.activeElement;
+    if (!el || el === activeElement) break;
+    else activeElement = el;
+  }
+  return activeElement;
+}
+function getParentNode(node) {
+  if (getNodeName(node) === "html") return node;
+  const result = node.assignedSlot || node.parentNode || isShadowRoot(node) && node.host || getDocumentElement(node);
+  return isShadowRoot(result) ? result.host : result;
+}
+export {
+  getActiveElement,
+  getDocument,
+  getDocumentElement,
+  getNodeName,
+  getParentNode,
+  getWindow,
+  isActiveElement,
+  isDocument,
+  isHTMLElement,
+  isNode,
+  isRootElement,
+  isShadowRoot,
+  isWindow
+};

package/dist/node_modules/@zag-js/dom-query/dist/overflow.js

@@ -0,0 +1,28 @@
+import { getWindow, getParentNode, isRootElement, getDocument, isHTMLElement } from "./node.js";
+function getNearestOverflowAncestor(el) {
+  const parentNode = getParentNode(el);
+  if (isRootElement(parentNode)) return getDocument(parentNode).body;
+  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) return parentNode;
+  return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(el, list = []) {
+  const scrollableAncestor = getNearestOverflowAncestor(el);
+  const isBody = scrollableAncestor === el.ownerDocument.body;
+  const win = getWindow(scrollableAncestor);
+  if (isBody) {
+    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : []);
+  }
+  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, []));
+}
+var OVERFLOW_RE = /auto|scroll|overlay|hidden|clip/;
+var nonOverflowValues = /* @__PURE__ */ new Set(["inline", "contents"]);
+function isOverflowElement(el) {
+  const win = getWindow(el);
+  const { overflow, overflowX, overflowY, display } = win.getComputedStyle(el);
+  return OVERFLOW_RE.test(overflow + overflowY + overflowX) && !nonOverflowValues.has(display);
+}
+export {
+  getNearestOverflowAncestor,
+  getOverflowAncestors,
+  isOverflowElement
+};

package/dist/node_modules/@zag-js/dom-query/dist/platform.js

@@ -0,0 +1,23 @@
+var isDom = () => typeof document !== "undefined";
+function getPlatform() {
+  const agent = navigator.userAgentData;
+  return agent?.platform ?? navigator.platform;
+}
+function getUserAgent() {
+  const ua2 = navigator.userAgentData;
+  if (ua2 && Array.isArray(ua2.brands)) {
+    return ua2.brands.map(({ brand, version }) => `${brand}/${version}`).join(" ");
+  }
+  return navigator.userAgent;
+}
+var pt = (v) => isDom() && v.test(getPlatform());
+var ua = (v) => isDom() && v.test(getUserAgent());
+var isMac = () => pt(/^Mac/i);
+var isAndroid = () => ua(/Android/i);
+export {
+  getPlatform,
+  getUserAgent,
+  isAndroid,
+  isDom,
+  isMac
+};

package/dist/node_modules/@zag-js/dom-query/dist/query.js

@@ -0,0 +1,6 @@
+function queryAll(root, selector) {
+  return Array.from(root?.querySelectorAll(selector) ?? []);
+}
+export {
+  queryAll
+};

package/dist/node_modules/@zag-js/dom-query/dist/raf.js

@@ -0,0 +1,52 @@
+import { __publicField } from "./chunk-QZ7TP4HQ.js";
+var AnimationFrame = class _AnimationFrame {
+  constructor() {
+    __publicField(this, "id", null);
+    __publicField(this, "fn_cleanup");
+    __publicField(this, "cleanup", () => {
+      this.cancel();
+    });
+  }
+  static create() {
+    return new _AnimationFrame();
+  }
+  request(fn) {
+    this.cancel();
+    this.id = globalThis.requestAnimationFrame(() => {
+      this.id = null;
+      this.fn_cleanup = fn?.();
+    });
+  }
+  cancel() {
+    if (this.id !== null) {
+      globalThis.cancelAnimationFrame(this.id);
+      this.id = null;
+    }
+    this.fn_cleanup?.();
+    this.fn_cleanup = void 0;
+  }
+  isActive() {
+    return this.id !== null;
+  }
+};
+function raf(fn) {
+  const frame = AnimationFrame.create();
+  frame.request(fn);
+  return frame.cleanup;
+}
+function nextTick(fn) {
+  const set = /* @__PURE__ */ new Set();
+  function raf2(fn2) {
+    const id = globalThis.requestAnimationFrame(fn2);
+    set.add(() => globalThis.cancelAnimationFrame(id));
+  }
+  raf2(() => raf2(fn));
+  return function cleanup() {
+    set.forEach((fn2) => fn2());
+  };
+}
+export {
+  AnimationFrame,
+  nextTick,
+  raf
+};

package/dist/node_modules/@zag-js/dom-query/dist/set.js

@@ -0,0 +1,22 @@
+import { noop } from "./shared.js";
+function setStyle(el, style) {
+  if (!el) return noop;
+  const prev = Object.keys(style).reduce((acc, key) => {
+    acc[key] = el.style.getPropertyValue(key);
+    return acc;
+  }, {});
+  if (isEqual(prev, style)) return noop;
+  Object.assign(el.style, style);
+  return () => {
+    Object.assign(el.style, prev);
+    if (el.style.length === 0) {
+      el.removeAttribute("style");
+    }
+  };
+}
+function isEqual(a, b) {
+  return Object.keys(a).every((key) => a[key] === b[key]);
+}
+export {
+  setStyle
+};

package/dist/node_modules/@zag-js/dom-query/dist/shared.js

@@ -0,0 +1,8 @@
+var noop = () => void 0;
+var isObject = (v) => typeof v === "object" && v !== null;
+var dataAttr = (guard) => guard ? "" : void 0;
+export {
+  dataAttr,
+  isObject,
+  noop
+};