@blogmcp/mdx-render-vue 0.1.0

package/dist/node_modules/@ark-ui/vue/dist/components/tooltip/use-tooltip.js

@@ -0,0 +1,36 @@
+import { useEnvironmentContext, DEFAULT_ENVIRONMENT } from "../../providers/environment/use-environment-context.js";
+import { useLocaleContext, DEFAULT_LOCALE } from "../../providers/locale/use-locale-context.js";
+import { cleanProps } from "../../utils/clean-props.js";
+import { useId, computed, toValue } from "vue";
+import { useMachine } from "../../../../../@zag-js/vue/dist/machine.js";
+import { connect } from "../../../../../@zag-js/tooltip/dist/tooltip.connect.js";
+import { machine } from "../../../../../@zag-js/tooltip/dist/tooltip.machine.js";
+import { normalizeProps } from "../../../../../@zag-js/vue/dist/normalize-props.js";
+var useTooltip = (props = {}, emit) => {
+  const id = useId();
+  const env = useEnvironmentContext(DEFAULT_ENVIRONMENT);
+  const locale = useLocaleContext(DEFAULT_LOCALE);
+  const context = computed(() => {
+    const localProps = toValue(props);
+    return {
+      id,
+      dir: locale.value.dir,
+      getRootNode: env?.value.getRootNode,
+      ...cleanProps(localProps),
+      onOpenChange: (details) => {
+        emit?.("openChange", details);
+        emit?.("update:open", details.open);
+        localProps.onOpenChange?.(details);
+      },
+      onTriggerValueChange: (details) => {
+        emit?.("triggerValueChange", details);
+        localProps.onTriggerValueChange?.(details);
+      }
+    };
+  });
+  const service = useMachine(machine, context);
+  return computed(() => connect(service, normalizeProps));
+};
+export {
+  useTooltip
+};

package/dist/node_modules/@ark-ui/vue/dist/providers/environment/use-environment-context.js

@@ -0,0 +1,13 @@
+import { createContext } from "../../utils/create-context.js";
+import { computed } from "vue";
+var [EnvironmentContextProvider, useEnvironmentContext] = createContext("EnvironmentContext");
+var DEFAULT_ENVIRONMENT = computed(() => ({
+  getRootNode: () => document,
+  getDocument: () => document,
+  getWindow: () => window
+}));
+export {
+  DEFAULT_ENVIRONMENT,
+  EnvironmentContextProvider,
+  useEnvironmentContext
+};

package/dist/node_modules/@ark-ui/vue/dist/providers/locale/use-locale-context.js

@@ -0,0 +1,12 @@
+import { createContext } from "../../utils/create-context.js";
+import { computed } from "vue";
+var DEFAULT_LOCALE = computed(() => ({
+  dir: "ltr",
+  locale: "en-US"
+}));
+var [LocaleContextProvider, useLocaleContext] = createContext("LocaleContext");
+export {
+  DEFAULT_LOCALE,
+  LocaleContextProvider,
+  useLocaleContext
+};

package/dist/node_modules/@ark-ui/vue/dist/utils/clean-props.js

@@ -0,0 +1,8 @@
+var cleanProps = (obj) => {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) if (value !== void 0) result[key] = value;
+  return result;
+};
+export {
+  cleanProps
+};

package/dist/node_modules/@ark-ui/vue/dist/utils/create-context.js

@@ -0,0 +1,14 @@
+import { provide, inject } from "vue";
+var createContext = (id) => {
+  const contextId = Symbol(id);
+  const provider = (value) => provide(contextId, value);
+  const consumer = (fallback) => inject(contextId, fallback);
+  return [
+    provider,
+    consumer,
+    contextId
+  ];
+};
+export {
+  createContext
+};

package/dist/node_modules/@ark-ui/vue/dist/utils/dynamic.js

@@ -0,0 +1,34 @@
+import { defineComponent, cloneVNode, Fragment } from "vue";
+import { mergeProps } from "../../../../@zag-js/core/dist/merge-props.js";
+var Dynamic = defineComponent({
+  name: "Dynamic",
+  inheritAttrs: false,
+  setup(_, { attrs, slots }) {
+    return () => {
+      if (!slots.default) return null;
+      const children = renderSlotFragments(slots.default());
+      const [firstChildren, ...otherChildren] = children;
+      if (firstChildren && Object.keys(attrs).length > 0) {
+        delete firstChildren.props?.ref;
+        const mergedProps = mergeProps(attrs, firstChildren.props ?? {});
+        const cloned = cloneVNode(firstChildren, mergedProps);
+        for (const prop in mergedProps) if (prop.startsWith("on")) {
+          cloned.props ||= {};
+          cloned.props[prop] = mergedProps[prop];
+        }
+        return children.length === 1 ? cloned : [cloned, ...otherChildren];
+      }
+      return children;
+    };
+  }
+});
+function renderSlotFragments(children) {
+  if (!children) return [];
+  return children.flatMap((child) => {
+    if (child.type === Fragment) return renderSlotFragments(child.children);
+    return [child];
+  });
+}
+export {
+  Dynamic
+};

package/dist/node_modules/@ark-ui/vue/dist/utils/unref-element.js

@@ -0,0 +1,8 @@
+import { toValue } from "vue";
+function unrefElement(elRef) {
+  const plain = toValue(elRef);
+  return plain?.$el ?? plain;
+}
+export {
+  unrefElement
+};

package/dist/node_modules/@ark-ui/vue/dist/utils/use-forward-expose.js

@@ -0,0 +1,46 @@
+import { unrefElement } from "./unref-element.js";
+import { getCurrentInstance, ref, computed } from "vue";
+var isElement = (el) => Object.prototype.hasOwnProperty.call(el, "nodeName") && typeof el.nodeName === "string";
+function useForwardExpose() {
+  const instance = getCurrentInstance();
+  const currentRef = ref();
+  const currentElement = computed(() => {
+    return ["#text", "#comment"].includes(currentRef.value?.$el.nodeName) ? currentRef.value?.$el.nextElementSibling : unrefElement(currentRef);
+  });
+  const localExpose = Object.assign({}, instance.exposed);
+  const ret = {};
+  for (const key in instance.props) Object.defineProperty(ret, key, {
+    enumerable: true,
+    configurable: true,
+    get: () => instance.props[key]
+  });
+  if (Object.keys(localExpose).length > 0) for (const key in localExpose) Object.defineProperty(ret, key, {
+    enumerable: true,
+    configurable: true,
+    get: () => localExpose[key]
+  });
+  Object.defineProperty(ret, "$el", {
+    enumerable: true,
+    configurable: true,
+    get: () => instance.vnode.el
+  });
+  instance.exposed = ret;
+  function forwardRef(ref2) {
+    currentRef.value = ref2;
+    if (!ref2) return;
+    Object.defineProperty(ret, "$el", {
+      enumerable: true,
+      configurable: true,
+      get: () => isElement(ref2) ? ref2 : ref2.$el
+    });
+    instance.exposed = ret;
+  }
+  return {
+    forwardRef,
+    currentRef,
+    currentElement
+  };
+}
+export {
+  useForwardExpose
+};

package/dist/node_modules/@ark-ui/vue/dist/utils/use-render-strategy.js

@@ -0,0 +1,5 @@
+import { createContext } from "./create-context.js";
+var [RenderStrategyPropsProvider] = createContext("RenderStrategyProps");
+export {
+  RenderStrategyPropsProvider
+};

package/dist/node_modules/@braintree/sanitize-url/dist/constants.js

@@ -0,0 +1,20 @@
+import { __exports as constants } from "../../../../_virtual/constants.js";
+var hasRequiredConstants;
+function requireConstants() {
+  if (hasRequiredConstants) return constants;
+  hasRequiredConstants = 1;
+  Object.defineProperty(constants, "__esModule", { value: true });
+  constants.BLANK_URL = constants.relativeFirstCharacters = constants.whitespaceEscapeCharsRegex = constants.urlSchemeRegex = constants.ctrlCharactersRegex = constants.htmlCtrlEntityRegex = constants.htmlEntitiesRegex = constants.invalidProtocolRegex = void 0;
+  constants.invalidProtocolRegex = /^([^\w]*)(javascript|data|vbscript)/im;
+  constants.htmlEntitiesRegex = /&#(\w+)(^\w|;)?/g;
+  constants.htmlCtrlEntityRegex = /&(newline|tab);/gi;
+  constants.ctrlCharactersRegex = /[\u0000-\u001F\u007F-\u009F\u2000-\u200D\uFEFF]/gim;
+  constants.urlSchemeRegex = /^.+(:|:)/gim;
+  constants.whitespaceEscapeCharsRegex = /(\\|%5[cC])((%(6[eE]|72|74))|[nrt])/g;
+  constants.relativeFirstCharacters = [".", "/"];
+  constants.BLANK_URL = "about:blank";
+  return constants;
+}
+export {
+  requireConstants as __require
+};

package/dist/node_modules/@braintree/sanitize-url/dist/index.js

@@ -0,0 +1,75 @@
+import { __exports as dist } from "../../../../_virtual/index2.js";
+import { __require as requireConstants } from "./constants.js";
+var hasRequiredDist;
+function requireDist() {
+  if (hasRequiredDist) return dist;
+  hasRequiredDist = 1;
+  Object.defineProperty(dist, "__esModule", { value: true });
+  dist.sanitizeUrl = sanitizeUrl;
+  var constants_1 = requireConstants();
+  function isRelativeUrlWithoutProtocol(url) {
+    return constants_1.relativeFirstCharacters.indexOf(url[0]) > -1;
+  }
+  function decodeHtmlCharacters(str) {
+    var removedNullByte = str.replace(constants_1.ctrlCharactersRegex, "");
+    return removedNullByte.replace(constants_1.htmlEntitiesRegex, function(match, dec) {
+      return String.fromCharCode(dec);
+    });
+  }
+  function isValidUrl(url) {
+    return URL.canParse(url);
+  }
+  function decodeURI(uri) {
+    try {
+      return decodeURIComponent(uri);
+    } catch (e) {
+      return uri;
+    }
+  }
+  function sanitizeUrl(url) {
+    if (!url) {
+      return constants_1.BLANK_URL;
+    }
+    var charsToDecode;
+    var decodedUrl = decodeURI(url.trim());
+    do {
+      decodedUrl = decodeHtmlCharacters(decodedUrl).replace(constants_1.htmlCtrlEntityRegex, "").replace(constants_1.ctrlCharactersRegex, "").replace(constants_1.whitespaceEscapeCharsRegex, "").trim();
+      decodedUrl = decodeURI(decodedUrl);
+      charsToDecode = decodedUrl.match(constants_1.ctrlCharactersRegex) || decodedUrl.match(constants_1.htmlEntitiesRegex) || decodedUrl.match(constants_1.htmlCtrlEntityRegex) || decodedUrl.match(constants_1.whitespaceEscapeCharsRegex);
+    } while (charsToDecode && charsToDecode.length > 0);
+    var sanitizedUrl = decodedUrl;
+    if (!sanitizedUrl) {
+      return constants_1.BLANK_URL;
+    }
+    if (isRelativeUrlWithoutProtocol(sanitizedUrl)) {
+      return sanitizedUrl;
+    }
+    var trimmedUrl = sanitizedUrl.trimStart();
+    var urlSchemeParseResults = trimmedUrl.match(constants_1.urlSchemeRegex);
+    if (!urlSchemeParseResults) {
+      return sanitizedUrl;
+    }
+    var urlScheme = urlSchemeParseResults[0].toLowerCase().trim();
+    if (constants_1.invalidProtocolRegex.test(urlScheme)) {
+      return constants_1.BLANK_URL;
+    }
+    var backSanitized = trimmedUrl.replace(/\\/g, "/");
+    if (urlScheme === "mailto:" || urlScheme.includes("://")) {
+      return backSanitized;
+    }
+    if (urlScheme === "http:" || urlScheme === "https:") {
+      if (!isValidUrl(backSanitized)) {
+        return constants_1.BLANK_URL;
+      }
+      var url_1 = new URL(backSanitized);
+      url_1.protocol = url_1.protocol.toLowerCase();
+      url_1.hostname = url_1.hostname.toLowerCase();
+      return url_1.toString();
+    }
+    return backSanitized;
+  }
+  return dist;
+}
+export {
+  requireDist as __require
+};