gutterpress 0.11.21 → 0.11.22-alpha.1

package/dist/{index-t7r8g75c.js → index-gmfh6n05.js}

@@ -3,7 +3,6 @@ import {
   cssQuote,
   extract,
   generatedContentCss,
-  getAssetPath,
   isIgnoredMarginBoxProperty,
   isRectoVersoBreak,
   leaderMarker,
@@ -19,7 +18,10 @@ import {
   stringValueAt,
   toFolioPage,
   wantsRecto
-} from "./index-mr72vt8n.js";
+} from "./index-5h9a38jn.js";
+import {
+  getAssetPath
+} from "./index-dhknsvfz.js";
 import {
   launchChromium
 } from "./index-bt0qws5c.js";

package/dist/index-r7jcsk6h.js

@@ -0,0 +1,200 @@
+// src/lib/plugin-vendor.ts
+import { lstat, readFile, realpath } from "node:fs/promises";
+import path from "node:path";
+import { exports as resolveExports } from "resolve.exports";
+var PLUGINS_DIR = "plugins";
+var VENDORED_NPM_DIR = "npm";
+var NPM_SEGMENT = /^[a-z0-9][a-z0-9._~-]*$/;
+var EXACT_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+var WINDOWS_RESERVED = /^(con|prn|aux|nul|clock\$|conin\$|conout\$|com[1-9¹²³]|lpt[1-9¹²³])(?:\..*)?$/i;
+function isValidNpmPackageName(name) {
+  if (!name || name.length > 214 || name !== name.toLowerCase())
+    return false;
+  if (name.startsWith("@")) {
+    const parts = name.slice(1).split("/");
+    return parts.length === 2 && parts.every((part) => NPM_SEGMENT.test(part));
+  }
+  return !name.includes("/") && NPM_SEGMENT.test(name);
+}
+function parseNpmPluginSpec(input) {
+  const spec = input.trim();
+  if (!spec)
+    throw new Error("An npm package name is required.");
+  let name = spec;
+  let selector;
+  if (spec.startsWith("@")) {
+    const slash = spec.indexOf("/");
+    const versionAt = spec.lastIndexOf("@");
+    if (slash > 1 && versionAt > slash) {
+      name = spec.slice(0, versionAt);
+      selector = spec.slice(versionAt + 1);
+    }
+  } else {
+    const versionAt = spec.lastIndexOf("@");
+    if (versionAt > 0) {
+      name = spec.slice(0, versionAt);
+      selector = spec.slice(versionAt + 1);
+    }
+  }
+  if (!isValidNpmPackageName(name)) {
+    throw new Error(`"${name}" is not a valid npm package name. Use a name like ` + "markdown-it-highlightjs or @scope/markdown-it-plugin.");
+  }
+  if (selector !== undefined && !selector) {
+    throw new Error(`The package spec "${spec}" is missing a selector after @.`);
+  }
+  return selector === undefined ? { name } : { name, selector };
+}
+function isExactNpmVersion(version) {
+  return EXACT_VERSION.test(version);
+}
+function encodePathPart(value) {
+  return encodeURIComponent(value).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function vendoredNpmPluginRoot(projectDir, name, version) {
+  return path.join(projectDir, PLUGINS_DIR, VENDORED_NPM_DIR, encodePathPart(name), encodePathPart(version));
+}
+function vendoredNpmPluginPackageDir(installRoot, name) {
+  return path.join(installRoot, "node_modules", ...name.split("/"));
+}
+function toPosixPath(value) {
+  return value.split(path.sep).join("/");
+}
+function assertWindowsSafeRelativePath(relative) {
+  if (!relative || relative.includes("\\") || relative.startsWith("/") || /^[a-zA-Z]:/.test(relative)) {
+    throw new Error(`Unsafe package path: ${relative || "(empty)"}`);
+  }
+  const normalized = relative.normalize("NFKC");
+  const parts = normalized.split("/");
+  if (parts.some((part) => !part || part === "." || part === "..")) {
+    throw new Error(`Unsafe package path: ${relative}`);
+  }
+  for (const part of parts) {
+    if (part.length > 255 || /[\u0000-\u001f<>:"|?*]/.test(part) || part.endsWith(".") || part.endsWith(" ") || WINDOWS_RESERVED.test(part)) {
+      throw new Error(`Package path is invalid on Windows: ${relative}`);
+    }
+  }
+}
+function windowsPathKey(relative) {
+  return relative.normalize("NFKC").toLowerCase();
+}
+function isContained(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+async function readPackageJson(packageDir) {
+  const packageJsonPath = path.join(packageDir, "package.json");
+  const info = await lstat(packageJsonPath);
+  if (!info.isFile() || info.isSymbolicLink()) {
+    throw new Error(`Package metadata is not a regular file: ${packageJsonPath}`);
+  }
+  const parsed = object(JSON.parse(await readFile(packageJsonPath, "utf8")));
+  if (!parsed)
+    throw new Error(`Package metadata is not an object: ${packageJsonPath}`);
+  return parsed;
+}
+function packageResolutionTargets(manifest, subpath, condition) {
+  if (manifest.exports !== undefined) {
+    try {
+      const targets2 = resolveExports(manifest, subpath ? `./${subpath}` : ".", { require: condition === "require" }) ?? [];
+      return targets2.map((target) => ({ target, exact: true }));
+    } catch {
+      return [];
+    }
+  }
+  if (subpath)
+    return [{ target: subpath, exact: false }];
+  const targets = [
+    ...condition === "import" && typeof manifest.module === "string" ? [manifest.module] : [],
+    ...typeof manifest.main === "string" ? [manifest.main] : [],
+    "index.mjs",
+    "index.js",
+    "index.cjs"
+  ];
+  return [...new Set(targets)].map((target) => ({ target, exact: false }));
+}
+function safePackageTarget(target) {
+  if (!target || target.includes("\\") || target.includes("*") || target.includes("?") || target.includes("#")) {
+    return null;
+  }
+  const relative = target.startsWith("./") ? target.slice(2) : target;
+  if (!relative || path.isAbsolute(relative))
+    return null;
+  assertWindowsSafeRelativePath(relative);
+  if (relative.normalize("NFKC").split("/").some((part) => part.toLowerCase() === "node_modules")) {
+    return null;
+  }
+  return relative;
+}
+async function resolveEntryCandidate(packageDir, resolution) {
+  const relative = safePackageTarget(resolution.target);
+  if (!relative)
+    return null;
+  const base = path.resolve(packageDir, ...relative.split("/"));
+  if (!isContained(packageDir, base))
+    return null;
+  const candidates = resolution.exact ? [base] : [
+    base,
+    `${base}.mjs`,
+    `${base}.js`,
+    `${base}.cjs`,
+    `${base}.json`,
+    path.join(base, "index.mjs"),
+    path.join(base, "index.js"),
+    path.join(base, "index.cjs"),
+    path.join(base, "index.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      const info = await lstat(candidate);
+      if (!info.isFile() || info.isSymbolicLink())
+        continue;
+      const extension = path.extname(candidate);
+      if (extension && ![".js", ".mjs", ".cjs", ".json"].includes(extension))
+        continue;
+      const [realRoot, realCandidate] = await Promise.all([realpath(packageDir), realpath(candidate)]);
+      if (!isContained(realRoot, realCandidate))
+        continue;
+      return toPosixPath(path.relative(packageDir, realCandidate));
+    } catch {}
+  }
+  return null;
+}
+async function resolvePackageEntry(packageDir, packageJson) {
+  const manifest = packageJson ?? await readPackageJson(packageDir);
+  for (const condition of ["import", "require"]) {
+    for (const target of packageResolutionTargets(manifest, "", condition)) {
+      const resolved = await resolveEntryCandidate(packageDir, target);
+      if (resolved)
+        return resolved;
+    }
+  }
+  throw new Error("Package has no contained JavaScript entry point.");
+}
+async function resolveVendoredPluginInstallRoot(projectDir, expectedName, expectedVersion) {
+  const requestedProjectRoot = path.resolve(projectDir);
+  const requestedInstallRoot = vendoredNpmPluginRoot(requestedProjectRoot, expectedName, expectedVersion);
+  let installInfo;
+  try {
+    installInfo = await lstat(requestedInstallRoot);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+  if (!installInfo.isDirectory() || installInfo.isSymbolicLink()) {
+    throw new Error("Vendor install root is not a normal directory.");
+  }
+  const [realProjectRoot, installRoot] = await Promise.all([
+    realpath(requestedProjectRoot),
+    realpath(requestedInstallRoot)
+  ]);
+  if (!isContained(realProjectRoot, installRoot)) {
+    throw new Error("Vendor install root resolves outside the book folder.");
+  }
+  return installRoot;
+}
+
+export { PLUGINS_DIR, VENDORED_NPM_DIR, isValidNpmPackageName, parseNpmPluginSpec, isExactNpmVersion, vendoredNpmPluginRoot, vendoredNpmPluginPackageDir, toPosixPath, assertWindowsSafeRelativePath, windowsPathKey, packageResolutionTargets, safePackageTarget, resolvePackageEntry, resolveVendoredPluginInstallRoot };