Initial commit: New MoreminiMore website with fresh design

node_modules/@astrojs/markdown-remark/dist/shiki.js

@@ -0,0 +1,163 @@
+import {
+  createCssVariablesTheme,
+  createHighlighter,
+  isSpecialLang
+} from "shiki";
+import { loadShikiEngine } from "#shiki-engine";
+let _cssVariablesTheme;
+const cssVariablesTheme = () => _cssVariablesTheme ?? (_cssVariablesTheme = createCssVariablesTheme({
+  variablePrefix: "--astro-code-"
+}));
+const cachedHighlighters = /* @__PURE__ */ new Map();
+function clearShikiHighlighterCache() {
+  cachedHighlighters.clear();
+}
+function createShikiHighlighter(options) {
+  const key = getCacheKey(options);
+  let highlighterPromise = cachedHighlighters.get(key);
+  if (!highlighterPromise) {
+    highlighterPromise = createShikiHighlighterInternal(options);
+    cachedHighlighters.set(key, highlighterPromise);
+  }
+  return ensureLanguagesLoaded(highlighterPromise, options?.langs);
+}
+function getCacheKey(options) {
+  const keyCache = [];
+  const { theme, themes, langAlias } = options ?? {};
+  if (theme) {
+    keyCache.push(theme);
+  }
+  if (themes) {
+    keyCache.push(Object.entries(themes).sort());
+  }
+  if (langAlias) {
+    keyCache.push(Object.entries(langAlias).sort());
+  }
+  return keyCache.length > 0 ? JSON.stringify(keyCache) : "";
+}
+async function ensureLanguagesLoaded(promise, langs) {
+  const highlighter = await promise;
+  if (!langs) {
+    return highlighter;
+  }
+  const loadedLanguages = highlighter.getLoadedLanguages();
+  for (const lang of langs) {
+    if (typeof lang === "string" && (isSpecialLang(lang) || loadedLanguages.includes(lang))) {
+      continue;
+    }
+    await highlighter.loadLanguage(lang);
+  }
+  return highlighter;
+}
+let shikiEngine = void 0;
+async function createShikiHighlighterInternal({
+  langs = [],
+  theme = "github-dark",
+  themes = {},
+  langAlias = {}
+} = {}) {
+  theme = theme === "css-variables" ? cssVariablesTheme() : theme;
+  if (shikiEngine === void 0) {
+    shikiEngine = await loadShikiEngine();
+  }
+  const highlighter = await createHighlighter({
+    langs: ["plaintext", ...langs],
+    langAlias,
+    themes: Object.values(themes).length ? Object.values(themes) : [theme],
+    engine: shikiEngine
+  });
+  async function highlight(code, lang = "plaintext", options, to) {
+    const resolvedLang = langAlias[lang] ?? lang;
+    const loadedLanguages = highlighter.getLoadedLanguages();
+    if (!isSpecialLang(lang) && !loadedLanguages.includes(resolvedLang)) {
+      try {
+        await highlighter.loadLanguage(resolvedLang);
+      } catch (_err) {
+        const langStr = lang === resolvedLang ? `"${lang}"` : `"${lang}" (aliased to "${resolvedLang}")`;
+        console.warn(`[Shiki] The language ${langStr} doesn't exist, falling back to "plaintext".`);
+        lang = "plaintext";
+      }
+    }
+    code = code.replace(/(?:\r\n|\r|\n)$/, "");
+    const themeOptions = Object.values(themes).length ? { themes } : { theme };
+    const inline = options?.inline ?? false;
+    return highlighter[to === "html" ? "codeToHtml" : "codeToHast"](code, {
+      ...themeOptions,
+      defaultColor: options.defaultColor,
+      lang,
+      // NOTE: while we can spread `options.attributes` here so that Shiki can auto-serialize this as rendered
+      // attributes on the top-level tag, it's not clear whether it is fine to pass all attributes as meta, as
+      // they're technically neither meta nor parsed from Shiki's `parseMetaString` API.
+      meta: options?.meta ? { __raw: options?.meta } : void 0,
+      transformers: [
+        {
+          pre(node) {
+            if (inline) {
+              node.tagName = "code";
+            }
+            const {
+              class: attributesClass,
+              style: attributesStyle,
+              ...rest
+            } = options?.attributes ?? {};
+            Object.assign(node.properties, rest);
+            const classValue = (normalizePropAsString(node.properties.class) ?? "") + (attributesClass ? ` ${attributesClass}` : "");
+            const styleValue = (normalizePropAsString(node.properties.style) ?? "") + (attributesStyle ? `; ${attributesStyle}` : "");
+            node.properties.class = classValue.replace(/shiki/g, "astro-code");
+            node.properties.dataLanguage = lang;
+            if (options.wrap === false || options.wrap === void 0) {
+              node.properties.style = styleValue + "; overflow-x: auto;";
+            } else if (options.wrap === true) {
+              node.properties.style = styleValue + "; overflow-x: auto; white-space: pre-wrap; word-wrap: break-word;";
+            }
+          },
+          line(node) {
+            if (resolvedLang === "diff") {
+              const innerSpanNode = node.children[0];
+              const innerSpanTextNode = innerSpanNode?.type === "element" && innerSpanNode.children?.[0];
+              if (innerSpanTextNode && innerSpanTextNode.type === "text") {
+                const start = innerSpanTextNode.value[0];
+                if (start === "+" || start === "-") {
+                  innerSpanTextNode.value = innerSpanTextNode.value.slice(1);
+                  innerSpanNode.children.unshift({
+                    type: "element",
+                    tagName: "span",
+                    properties: { style: "user-select: none;" },
+                    children: [{ type: "text", value: start }]
+                  });
+                }
+              }
+            }
+          },
+          code(node) {
+            if (inline) {
+              return node.children[0];
+            }
+          }
+        },
+        ...options.transformers ?? []
+      ]
+    });
+  }
+  return {
+    codeToHast(code, lang, options = {}) {
+      return highlight(code, lang, options, "hast");
+    },
+    codeToHtml(code, lang, options = {}) {
+      return highlight(code, lang, options, "html");
+    },
+    loadLanguage(...newLangs) {
+      return highlighter.loadLanguage(...newLangs);
+    },
+    getLoadedLanguages() {
+      return highlighter.getLoadedLanguages();
+    }
+  };
+}
+function normalizePropAsString(value) {
+  return Array.isArray(value) ? value.join(" ") : value;
+}
+export {
+  clearShikiHighlighterCache,
+  createShikiHighlighter
+};