@canofold/markdown 0.2.0

package/dist/plugins-DQ-VUuCT.js

@@ -0,0 +1,288 @@
+const w = {
+  "package.json": "package",
+  "package-lock.json": "package",
+  "pnpm-lock.yaml": "package",
+  "yarn.lock": "package",
+  "bun.lock": "package",
+  "bun.lockb": "package",
+  "deno.json": "package",
+  "deno.jsonc": "package",
+  "pnpm-workspace.yaml": "package",
+  ".gitignore": "config",
+  ".editorconfig": "config",
+  ".npmrc": "config",
+  ".nvmrc": "config",
+  ".prettierrc": "config",
+  "biome.json": "config",
+  dockerfile: "container",
+  containerfile: "container",
+  "tsconfig.json": "config",
+  "jsconfig.json": "config",
+  "turbo.json": "config",
+  "vite.config.ts": "config",
+  "vite.config.js": "config"
+}, y = {
+  ts: "typescript",
+  tsx: "typescript",
+  mts: "typescript",
+  cts: "typescript",
+  js: "javascript",
+  jsx: "javascript",
+  mjs: "javascript",
+  cjs: "javascript",
+  md: "markdown",
+  mdx: "markdown",
+  css: "style",
+  conf: "config",
+  scss: "style",
+  sass: "style",
+  less: "style",
+  json: "data",
+  jsonc: "data",
+  yaml: "data",
+  yml: "data",
+  toml: "data",
+  sql: "database",
+  diff: "diff",
+  patch: "diff",
+  sh: "shell",
+  bash: "shell",
+  zsh: "shell",
+  fish: "shell",
+  vue: "component",
+  svelte: "component",
+  astro: "component",
+  py: "source",
+  go: "source",
+  rs: "source"
+}, k = {
+  typescript: "typescript",
+  ts: "typescript",
+  tsx: "typescript",
+  javascript: "javascript",
+  js: "javascript",
+  jsx: "javascript",
+  markdown: "markdown",
+  md: "markdown",
+  mdx: "markdown",
+  css: "style",
+  scss: "style",
+  sass: "style",
+  less: "style",
+  json: "data",
+  jsonc: "data",
+  yaml: "data",
+  yml: "data",
+  toml: "data",
+  sql: "database",
+  diff: "diff",
+  docker: "container",
+  dockerfile: "container",
+  nginx: "config",
+  shell: "shell",
+  sh: "shell",
+  bash: "shell",
+  zsh: "shell",
+  terminal: "shell",
+  vue: "component",
+  svelte: "component",
+  astro: "component",
+  python: "source",
+  py: "source",
+  go: "source",
+  rust: "source",
+  rs: "source"
+};
+function b(e, t = "") {
+  const o = e.split(/[\\/]/).pop()?.toLowerCase() || "", n = w[o];
+  if (n) return n;
+  if (/^\.env(?:\..+)?$/.test(o)) return "environment";
+  if (/(^|\.)config\.[^.]+$/.test(o) || /^\.[a-z0-9-]+rc(?:\.[^.]+)?$/.test(o))
+    return "config";
+  const r = o.includes(".") && o.split(".").pop() || "";
+  return y[r] || k[t.toLowerCase()] || "file";
+}
+const p = {
+  astro: "astro",
+  bash: "console",
+  css: "css",
+  diff: "diff",
+  docker: "docker",
+  dockerfile: "docker",
+  go: "go",
+  javascript: "javascript",
+  js: "javascript",
+  jsx: "javascript",
+  json: "json",
+  jsonc: "json",
+  markdown: "markdown",
+  md: "markdown",
+  mdx: "markdown",
+  python: "python",
+  py: "python",
+  rust: "rust",
+  rs: "rust",
+  sass: "sass",
+  scss: "sass",
+  shell: "console",
+  sh: "console",
+  sql: "database",
+  svelte: "svelte",
+  terminal: "console",
+  typescript: "typescript",
+  ts: "typescript",
+  tsx: "typescript",
+  vue: "vue",
+  yaml: "yaml",
+  yml: "yaml",
+  zsh: "console"
+};
+function j(e, t = "") {
+  const o = e.replace(/\\/g, "/").toLowerCase(), n = o.split("/").pop() || "";
+  if (/^docfuse\.config\.(?:[cm]?[jt]s)$/.test(n)) return "docfuse";
+  if (/^(?:.*\/)?\.github\/workflows\/[^/]+\.ya?ml$/.test(o)) return "github-actions";
+  if (["npm", "pnpm", "yarn", "bun", "deno"].includes(n))
+    return n;
+  if (n === "package.json") return "nodejs";
+  if (n.startsWith("pnpm-") || n === "pnpm-lock.yaml") return "pnpm";
+  if (n === "package-lock.json" || n === ".npmrc") return "npm";
+  if (n === "yarn.lock") return "yarn";
+  if (n === "bun.lock" || n === "bun.lockb") return "bun";
+  if (n === "deno.json" || n === "deno.jsonc") return "deno";
+  if (n === "dockerfile" || n === "containerfile") return "docker";
+  if (n === ".gitignore" || n === ".gitattributes" || n === ".gitmodules")
+    return "git";
+  if (/^\.env(?:\.|$)/.test(n)) return "environment";
+  if (n === "tsconfig.json" || n === "jsconfig.json") return "typescript";
+  if (/\.(?:jsx|tsx)$/.test(n)) return "react";
+  const r = b(n, t);
+  if (r === "config") return "config";
+  if (r === "database") return "database";
+  if (r === "diff") return "diff";
+  if (r === "shell") return "console";
+  if (r === "container") return "docker";
+  const a = n.includes(".") && n.split(".").pop() || "";
+  return p[a] || p[t.toLowerCase()] || "document";
+}
+function c(e, t) {
+  if (e === null || typeof e == "string" || typeof e == "boolean") return JSON.stringify(e);
+  if (typeof e == "number") {
+    if (!Number.isFinite(e)) throw new TypeError("Numbers must be finite");
+    return String(e);
+  }
+  if (typeof e != "object") throw new TypeError("Value is not JSON serializable");
+  if (t.has(e)) throw new TypeError("Circular JSON value");
+  const o = Object.getPrototypeOf(e);
+  if (!Array.isArray(e) && o !== Object.prototype && o !== null)
+    throw new TypeError("Only plain objects are JSON serializable");
+  t.add(e);
+  try {
+    if (Array.isArray(e)) {
+      if (Object.keys(e).length !== e.length) throw new TypeError("Sparse arrays are not supported");
+      return `[${e.map((n) => c(n, t)).join(",")}]`;
+    }
+    return `{${Object.keys(e).sort().map((n) => `${JSON.stringify(n)}:${c(e[n], t)}`).join(",")}}`;
+  } finally {
+    t.delete(e);
+  }
+}
+function l(e) {
+  try {
+    return c(e, /* @__PURE__ */ new WeakSet());
+  } catch {
+    return;
+  }
+}
+const m = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/, h = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function d(e) {
+  if (typeof e != "string" || !m.test(e))
+    throw new Error(
+      `Markdown plugin names must be lowercase kebab-case slugs (e.g. "external-links"), got ${JSON.stringify(e)}`
+    );
+}
+function u(e) {
+  if (e.cacheKey !== void 0 && l(e.cacheKey) === void 0)
+    throw new Error(`Markdown plugin "${e.name}" cacheKey must be JSON-serializable`);
+}
+function g(e) {
+  const t = e.browserCompiler;
+  if (t) {
+    if (typeof t.module != "string" || t.module.trim() === "")
+      throw new Error(`Markdown plugin "${e.name}" browserCompiler.module must be a non-empty string`);
+    if (typeof t.exportName != "string" || !h.test(t.exportName))
+      throw new Error(
+        `Markdown plugin "${e.name}" browserCompiler.exportName must be a named JavaScript export`
+      );
+    if (t.options !== void 0 && l(t.options) === void 0)
+      throw new Error(`Markdown plugin "${e.name}" browserCompiler.options must be JSON-serializable`);
+  }
+}
+function f(e) {
+  return (e.directiveNames ?? []).map((t) => {
+    const o = t.trim().toLowerCase();
+    if (t !== o || !m.test(o))
+      throw new Error(
+        `Markdown plugin "${e.name}" directive names must be lowercase kebab-case slugs, got ${JSON.stringify(t)}`
+      );
+    return o;
+  });
+}
+function $(e = []) {
+  const t = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
+  for (const r of e) {
+    if (d(r?.name), u(r), g(r), t.has(r.name))
+      throw new Error(`Markdown plugins must have unique names, got "${r.name}" twice`);
+    t.add(r.name);
+    for (const a of r.fenceLanguages ?? []) {
+      const s = a.trim().toLowerCase();
+      if (!s) continue;
+      const i = o.get(s);
+      if (i && i !== r.name)
+        throw new Error(`Fence language "${s}" is owned by both "${i}" and "${r.name}"`);
+      o.set(s, r.name);
+    }
+    for (const a of f(r)) {
+      const s = n.get(a);
+      if (s && s !== r.name)
+        throw new Error(`Directive "${a}" is owned by both "${s}" and "${r.name}"`);
+      n.set(a, r.name);
+    }
+  }
+  return e;
+}
+function v(e = []) {
+  return e.map((t) => ({
+    name: t.name,
+    version: t.version ?? "",
+    cacheKey: t.cacheKey ?? null
+  }));
+}
+function N(e) {
+  return d(e?.name), u(e), g(e), f(e), e;
+}
+function x(e, t) {
+  return e.filter((o) => o.appliesTo?.(t) !== !1);
+}
+function z(e) {
+  const t = /* @__PURE__ */ new Set();
+  for (const o of e)
+    for (const n of o.fenceLanguages ?? []) {
+      const r = n.trim().toLowerCase();
+      r && t.add(r);
+    }
+  return t;
+}
+function E(e) {
+  return new Set(e.flatMap((t) => f(t)));
+}
+export {
+  x as a,
+  z as b,
+  v as c,
+  N as d,
+  b as e,
+  j as f,
+  E as m,
+  $ as n,
+  l as s
+};