@hajimism/dek 0.3.1 → 0.3.3

package/src/core/pack.ts

@@ -0,0 +1,137 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+import { loadConfig } from "./config.ts";
+import { DekError } from "./error.ts";
+import { licenseText } from "./licenses.ts";
+import { type DistOptions, distFile } from "./path.ts";
+import { keepsInDeck, LICENSE_NAMES, MAX_SNAPSHOT_BYTES } from "./ref.ts";
+import { isRefDeckName } from "./ref-name.ts";
+import { followInside, requireInside, writeInside } from "./safe-fs.ts";
+
+/**
+ * A deck handed over as a file, to be read as a ref by someone who cannot reach it on GitHub:
+ * a gzipped tar of a project that holds only that deck, under a folder named for it. The deck
+ * keeps what `dekc ref` keeps of a repository; the project's dek.toml goes empty, so the
+ * sender's refs and voice settings stay home. Its LICENSE is the one `packLicense` picks.
+ */
+export async function packDeck(
+  project: { root: string },
+  deck: { name: string; dir: string },
+  options: { maxBytes?: number } = {},
+): Promise<Uint8Array> {
+  if (!isRefDeckName(deck.name)) {
+    throw new DekError(`deck "${deck.name}" cannot be read as a ref by that name`, {
+      path: deck.dir,
+      hint: "a ref names its deck with no space or @; rename the deck's folder, e.g. to 2026-10-talk, and pack it again",
+    });
+  }
+  // Each file by its path in the pack and where it really is, measured before any is read.
+  const sources: Array<readonly [string, string]> = deckFiles(deck.dir, project.root).map(
+    (path) =>
+      [`decks/${deck.name}/${path}`, requireInside(join(deck.dir, path), project.root)] as const,
+  );
+  const license = packLicense(project.root);
+  if (license?.path) {
+    sources.push([license.name, license.path]);
+  }
+  const maxBytes = options.maxBytes ?? MAX_SNAPSHOT_BYTES;
+  const size = sources.reduce((sum, [, real]) => sum + statSync(real).size, 0);
+  if (size > maxBytes) {
+    throw new DekError(
+      `deck "${deck.name}" is larger than a ref keeps, ${maxBytes / 1024 / 1024} MB`,
+      {
+        path: deck.dir,
+        hint: "a deck to read as a model should be far smaller; check its assets",
+      },
+    );
+  }
+  const files = new Map<string, Uint8Array>([["dek.toml", new Uint8Array()]]);
+  for (const [path, real] of sources) {
+    files.set(path, readFileSync(real));
+  }
+  if (license?.text !== undefined) {
+    files.set(license.name, new TextEncoder().encode(license.text));
+  }
+  const entries: Record<string, Uint8Array> = {};
+  for (const [path, bytes] of files) {
+    entries[`${deck.name}/${path}`] = bytes;
+  }
+  return new Bun.Archive(entries, { compress: "gzip" }).bytes();
+}
+
+/**
+ * The LICENSE a pack carries: the legal code `[pack] license` names, which says what the reader
+ * may do with a deck handed over on purpose; else the project's own LICENSE file; else none.
+ */
+function packLicense(
+  root: string,
+):
+  | { name: string; text: string; path?: undefined }
+  | { name: string; path: string; text?: undefined }
+  | undefined {
+  const id = loadConfig(join(root, "dek.toml")).pack?.license;
+  if (id) {
+    return { name: "LICENSE", text: licenseText(id) };
+  }
+  const name = LICENSE_NAMES.find((file) => isFile(join(root, file), root));
+  return name ? { name, path: requireInside(join(root, name), root) } : undefined;
+}
+
+/** Said to the sender, who can fix it, when a pack would go out with no license. */
+const NO_PACK_LICENSE =
+  'the pack carries no license, so its reader is told to ask you before reusing it; add `[pack] license = "CC0-1.0"` to dek.toml to let them reuse it freely, or put a LICENSE at the project root';
+
+/** `dekc pack`: write the deck's pack as dist/<deck>.tgz. */
+export async function writePack(
+  project: { root: string },
+  deck: { name: string; dir: string },
+  options: DistOptions = {},
+): Promise<{ outPath: string; warnings: string[] }> {
+  const bytes = await packDeck(project, deck);
+  const outPath = distFile(project, deck, "tgz", options);
+  writeInside(outPath, bytes, project.root);
+  return { outPath, warnings: packLicense(project.root) ? [] : [NO_PACK_LICENSE] };
+}
+
+/** What `deckFiles` looks at in the deck's own folder; dist/, .cache/, and voice/ are not read. */
+const DECK_TOP = new Set(["script.md", "theme.css", "slides", "assets"]);
+
+/**
+ * The deck's files a ref keeps, relative to the deck, in a stable order. A file or folder whose
+ * name starts with a dot stays behind; a link dek would not follow anywhere else is an error.
+ */
+function deckFiles(deckDir: string, root: string): string[] {
+  const found: string[] = [];
+  const walk = (rel: string) => {
+    const dir = requireInside(join(deckDir, rel), root);
+    for (const name of readdirSync(dir).sort()) {
+      if (name.startsWith(".") || (rel === "" && !DECK_TOP.has(name))) {
+        continue;
+      }
+      const path = rel === "" ? name : `${rel}/${name}`;
+      const real = requireInside(join(deckDir, path), root);
+      if (!existsSync(real)) {
+        throw new DekError(`${relative(root, join(deckDir, path))} is missing`, {
+          path: join(deckDir, path),
+          hint: "it is a symlink to nothing; remove it, or copy the file it meant in its place",
+        });
+      }
+      if (statSync(real).isDirectory()) {
+        walk(path);
+      } else if (keepsInDeck(path)) {
+        found.push(path);
+      }
+    }
+  };
+  walk("");
+  return found;
+}
+
+function isFile(path: string, root: string): boolean {
+  const real = followInside(path, root);
+  try {
+    return real !== undefined && statSync(real).isFile();
+  } catch {
+    return false;
+  }
+}

package/src/core/pdf-text.ts

@@ -0,0 +1,191 @@
+/// <reference lib="dom" />
+// What a PDF prints of a slide: a picture of the slide as the browser drew it, with its text laid
+// over it, unseen, so a reader can still select, search, and copy it. Chromium writes a blurred
+// box-shadow and `background-clip: text` into a PDF as soft masks, which Apple's viewers (Preview,
+// Quick Look, Safari, iOS) draw as flat boxes; a picture looks the same in every viewer.
+
+/** The slides of the print document, one PDF page each. */
+export const PDF_SLIDES = "#deck > .slide";
+
+/**
+ * Leaves each slide's text where it was laid out and paints nothing else: no color, no
+ * background, no border, no shadow, no picture. Only paint changes, never layout, so the text lies
+ * where the picture under it shows it. In a layer, so that these `!important` declarations win
+ * over any the theme or a slide writes, whatever their selectors weigh.
+ */
+export const PDF_TEXT_CSS = `@layer dek-pdf-text {
+  #deck > .slide,
+  #deck > .slide::before,
+  #deck > .slide::after,
+  #deck > .slide *,
+  #deck > .slide *::before,
+  #deck > .slide *::after,
+  #deck > .slide *::marker,
+  #deck > .slide *::first-letter,
+  #deck > .slide *::first-line {
+    color: transparent !important;
+    -webkit-text-fill-color: transparent !important;
+    -webkit-text-stroke-color: transparent !important;
+    text-decoration-color: transparent !important;
+    text-emphasis-color: transparent !important;
+    text-shadow: none !important;
+    border-color: transparent !important;
+    border-image: none !important;
+    outline-color: transparent !important;
+    column-rule-color: transparent !important;
+    box-shadow: none !important;
+    transition: none !important;
+  }
+  #deck > .slide::before,
+  #deck > .slide::after,
+  #deck > .slide *,
+  #deck > .slide *::before,
+  #deck > .slide *::after,
+  #deck > .slide *::first-letter,
+  #deck > .slide *::first-line {
+    background: none !important;
+  }
+  #deck > .slide {
+    opacity: 1 !important;
+    mix-blend-mode: normal !important;
+  }
+  #deck > .slide :is(img, video, canvas, iframe, embed, object, input, select, textarea, button, progress, meter),
+  #deck > .slide svg image {
+    opacity: 0 !important;
+  }
+  #deck > .slide svg * {
+    fill: transparent !important;
+    stroke: transparent !important;
+  }
+}`;
+
+/**
+ * Where each slide lies on the whole page, for its picture to be shot.
+ *
+ * Runs in the page, shipped by `page.evaluate`, so it references nothing outside itself.
+ */
+export function slideBoxesInPage(
+  selector: string,
+): { x: number; y: number; width: number; height: number }[] {
+  return [...document.querySelectorAll(selector)].map((slide) => {
+    const box = slide.getBoundingClientRect();
+    return {
+      x: box.left + window.scrollX,
+      y: box.top + window.scrollY,
+      width: box.width,
+      height: box.height,
+    };
+  });
+}
+
+/**
+ * Takes every paint but the text away from the page's slides, once their pictures are shot. A
+ * filter or a backdrop filter would draw over the picture, or turn the text under it into pixels,
+ * so each goes; `will-change` keeps the box it made for its positioned descendants, so they stay
+ * where they were laid out.
+ *
+ * Runs in the page, shipped by `page.evaluate`, so it references nothing outside itself.
+ */
+export function keepOnlyTextInPage({ selector, css }: { selector: string; css: string }): void {
+  for (const slide of document.querySelectorAll(selector)) {
+    for (const el of [slide, ...slide.querySelectorAll("*")]) {
+      if (!(el instanceof HTMLElement || el instanceof SVGElement)) {
+        continue;
+      }
+      const style = getComputedStyle(el);
+      const effects = (["filter", "backdrop-filter"] as const).filter(
+        (property) => style.getPropertyValue(property) !== "none",
+      );
+      if (effects.length === 0) {
+        continue;
+      }
+      const hints = style.willChange === "auto" ? [] : [style.willChange];
+      for (const property of effects) {
+        el.style.setProperty(property, "none", "important");
+      }
+      el.style.setProperty("will-change", [...hints, ...effects].join(", "), "important");
+    }
+  }
+  const sheet = document.createElement("style");
+  sheet.textContent = css;
+  document.head.append(sheet);
+}
+
+/** How good a JPEG a photograph's slide is kept as: near the PNG to the eye, at under half its size. */
+export const PDF_JPEG_QUALITY = 90;
+
+/** How much of a slide its photographs must cover for the slide to be kept as a JPEG. */
+const PHOTO_SHARE = 0.1;
+
+/**
+ * Which of a slide's two pictures the PDF keeps: the JPEG for a slide that shows photographs,
+ * where it is smaller, and the PNG for the rest. Type and flat shapes keep their edges in a PNG;
+ * a JPEG blurs them, so a slide of them is never kept as one, however much smaller it would be.
+ */
+export function pdfPictureType(
+  sizes: { png: number; jpeg: number },
+  photoShare: number,
+): "png" | "jpeg" {
+  return photoShare >= PHOTO_SHARE && sizes.jpeg < sizes.png ? "jpeg" : "png";
+}
+
+/**
+ * How much of each slide raster pictures cover, 0 to 1: images, video, and canvases, and
+ * backgrounds drawn from a picture's URL. SVG is shapes, not a photograph, and does not count.
+ *
+ * Runs in the page, shipped by `page.evaluate`, so it references nothing outside itself.
+ */
+export function photoSharesInPage(selector: string): number[] {
+  const vector = (url: string) => /^data:image\/svg|\.svg(?:[?#]|$)/i.test(url);
+  return [...document.querySelectorAll(selector)].map((slide) => {
+    const frame = slide.getBoundingClientRect();
+    let covered = 0;
+    for (const el of [slide, ...slide.querySelectorAll("*")]) {
+      const style = getComputedStyle(el);
+      if (style.visibility !== "visible" || style.display === "none") {
+        continue;
+      }
+      const raster =
+        el instanceof HTMLImageElement
+          ? !vector(el.currentSrc || el.src)
+          : el instanceof HTMLVideoElement ||
+            el instanceof HTMLCanvasElement ||
+            [...style.backgroundImage.matchAll(/url\("?([^")]*)"?\)/g)].some(
+              ([, url]) => url !== undefined && !vector(url),
+            );
+      if (!raster) {
+        continue;
+      }
+      const box = el.getBoundingClientRect();
+      const width = Math.min(box.right, frame.right) - Math.max(box.left, frame.left);
+      const height = Math.min(box.bottom, frame.bottom) - Math.max(box.top, frame.top);
+      covered += Math.max(0, width) * Math.max(0, height);
+    }
+    return Math.min(1, covered / (frame.width * frame.height));
+  });
+}
+
+/**
+ * Sets a slide's picture, a `data:` URL, under its text: the `index`th of the page's slides.
+ * One slide a call, so no message to the page carries more than one picture.
+ *
+ * Runs in the page, shipped by `page.evaluate`, so it references nothing outside itself.
+ */
+export function setSlidePictureInPage({
+  selector,
+  index,
+  picture,
+}: {
+  selector: string;
+  index: number;
+  picture: string;
+}): void {
+  const slide = document.querySelectorAll(selector)[index];
+  if (slide instanceof HTMLElement) {
+    slide.style.setProperty(
+      "background",
+      `url("${picture}") 0 0 / 100% 100% no-repeat border-box`,
+      "important",
+    );
+  }
+}

package/src/core/playwright-module.d.ts

@@ -3,13 +3,18 @@ declare module "playwright" {
   export type Page = {
     goto(url: string): Promise<unknown>;
     setContent(html: string, options?: { waitUntil?: string }): Promise<void>;
-    emulateMedia(options: { reducedMotion?: "reduce" | "no-preference" }): Promise<void>;
+    emulateMedia(options: {
+      media?: "screen" | "print";
+      reducedMotion?: "reduce" | "no-preference";
+    }): Promise<void>;
     setViewportSize(size: Viewport): Promise<void>;
     evaluate<T, A = unknown>(fn: (arg: A) => T | Promise<T>, arg?: A): Promise<T>;
     screenshot(options: {
       path?: string;
       fullPage?: boolean;
+      clip?: { x: number; y: number; width: number; height: number };
       type?: "png" | "jpeg";
+      quality?: number;
     }): Promise<Buffer>;
     addScriptTag(options: { content: string }): Promise<unknown>;
     pdf(options: {

package/src/core/playwright-visual.ts

@@ -11,6 +11,16 @@ import {
   samePlace,
 } from "./overflow.ts";
 import { visitInPages } from "./page-pool.ts";
+import {
+  keepOnlyTextInPage,
+  PDF_JPEG_QUALITY,
+  PDF_SLIDES,
+  PDF_TEXT_CSS,
+  pdfPictureType,
+  photoSharesInPage,
+  setSlidePictureInPage,
+  slideBoxesInPage,
+} from "./pdf-text.ts";
 import type {
   ContrastFinding,
   ContrastOrigin,
@@ -50,12 +60,13 @@ export async function runVisualRequest<R extends VisualRequest>(
   browser: Browser,
   request: R,
 ): Promise<ResponseTo<R>> {
-  // A PPTX's pictures are shown full screen, so they are drawn at twice the slide's size. A deck is
-  // self-contained (DEK020), so the page needs no network, and a ref's slide scripts get none.
+  // A PPTX's and a PDF's pictures are shown full screen, so they are drawn at twice the slide's
+  // size. A deck is self-contained (DEK020), so the page needs no network, and a ref's slide
+  // scripts get none.
   const context = await browser.newContext({
     viewport: request.viewport,
     offline: true,
-    ...(request.kind === "pptx" ? { deviceScaleFactor: 2 } : {}),
+    ...(request.kind === "pptx" || request.kind === "pdf" ? { deviceScaleFactor: 2 } : {}),
   });
   try {
     return (await answer(context, request)) as ResponseTo<R>;
@@ -83,10 +94,35 @@ function answer(context: BrowserContext, request: VisualRequest) {
   }
 }
 
-/** The whole print document as one PDF, a page per slide. */
+/**
+ * The whole print document as one PDF, a page per slide: each slide shot as print draws it, then
+ * printed as that picture with its text laid over it, unseen.
+ */
 async function printPdf(context: BrowserContext, request: PdfRequest): Promise<DoneResponse> {
   const page = await context.newPage();
   await page.setContent(request.html, { waitUntil: "load" });
+  await page.evaluate(() => document.fonts.ready.then(() => undefined));
+  await page.emulateMedia({ media: "print" });
+  // A slide that shows photographs is shot as a JPEG too, and kept as one where it is smaller.
+  const shares = await page.evaluate(photoSharesInPage, PDF_SLIDES);
+  const pictures: string[] = [];
+  for (const [index, clip] of (await page.evaluate(slideBoxesInPage, PDF_SLIDES)).entries()) {
+    const share = shares[index] ?? 0;
+    const png = await page.screenshot({ clip, fullPage: true });
+    const jpeg =
+      pdfPictureType({ png: png.length, jpeg: 0 }, share) === "jpeg"
+        ? await page.screenshot({ clip, fullPage: true, type: "jpeg", quality: PDF_JPEG_QUALITY })
+        : undefined;
+    const kept =
+      jpeg && pdfPictureType({ png: png.length, jpeg: jpeg.length }, share) === "jpeg"
+        ? { type: "jpeg", data: jpeg }
+        : { type: "png", data: png };
+    pictures.push(`data:image/${kept.type};base64,${kept.data.toString("base64")}`);
+  }
+  await page.evaluate(keepOnlyTextInPage, { selector: PDF_SLIDES, css: PDF_TEXT_CSS });
+  for (const [index, picture] of pictures.entries()) {
+    await page.evaluate(setSlidePictureInPage, { selector: PDF_SLIDES, index, picture });
+  }
   await page.pdf({
     path: request.pdfPath,
     width: `${request.viewport.width}px`,

package/src/core/playwright.ts

@@ -55,7 +55,10 @@ export type PagesRequest = {
   sheets?: SheetSpec[];
 };
 
-/** One page printed to `pdfPath`, a PDF page per slide. */
+/**
+ * One page printed to `pdfPath`, a PDF page per slide: each slide a picture at twice its size,
+ * with its text laid over it, unseen, to select and search.
+ */
 export type PdfRequest = {
   kind: "pdf";
   viewport: Viewport;

package/src/core/ref-name.ts

@@ -2,11 +2,13 @@ import { DekError } from "./error.ts";
 
 /**
  * A ref is someone else's deck, kept as a read-only snapshot to read as a
- * model. dek.toml `[refs]` pins each one to a commit; the snapshot under
- * `refs/owner/repo/deck` is only a copy of that commit and can be fetched again.
+ * model. dek.toml `[refs]` pins each one: a deck on GitHub to a commit, a pack
+ * to a digest of its files. The snapshot under `refs/` is only a copy of what
+ * the pin names, fetched or unpacked again whenever it is missing.
  * This module only names refs; `ref.ts` fetches and stores them.
  */
-export type RefSource = {
+export type GithubRefSource = {
+  kind: "github";
   /** `owner/repo/deck`, the key in dek.toml `[refs]`. */
   name: string;
   owner: string;
@@ -18,13 +20,32 @@ export type RefSource = {
   path?: string;
 };
 
+/** A deck handed over as a file by `dekc pack`, committed as `packs/<deck>.tgz`. */
+export type FileRefSource = {
+  kind: "file";
+  /** `file/<deck>`, the key in dek.toml `[refs]`. */
+  name: string;
+  deck: string;
+};
+
+export type RefSource = GithubRefSource | FileRefSource;
+
+/** The first segment of a pack's ref name; no GitHub owner may take it, so refs/ never overlaps. */
+const PACK_OWNER = "file";
+
 const OWNER_RE = /^[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?$/;
 const REPO_RE = /^[A-Za-z0-9._-]+$/;
 const DECK_RE = /^[^/\\\s@]+$/;
 const SHA_RE = /^[0-9a-f]{40}$/;
+const DIGEST_RE = /^[0-9a-f]{64}$/;
 
 const REF_HINT =
-  "name a ref as owner/repo/deck, e.g. hajimism/dek/why-dek or hajimism/dek/why-dek@v1";
+  "name a ref as owner/repo/deck, e.g. hajimism/dek/why-dek or hajimism/dek/why-dek@v1, or a pack's as file/<deck>";
+
+/** Where a pack's ref keeps its pack, relative to the project root: committed, never ignored. */
+export function packFile(deck: string): string {
+  return `packs/${deck}.tgz`;
+}
 
 /** True for `owner/repo/deck[@rev]` or a GitHub link, which a deck name never is. */
 export function isRefName(arg: string): boolean {
@@ -34,14 +55,15 @@ export function isRefName(arg: string): boolean {
   if (arg.startsWith(".") || arg.startsWith("/") || arg.startsWith("~")) {
     return false;
   }
-  return arg.split("@")[0]?.split("/").length === 3;
+  const segments = arg.split("@")[0]?.split("/") ?? [];
+  return segments.length === 3 || (segments.length === 2 && segments[0] === PACK_OWNER);
 }
 
-/** A valid `owner/repo/deck` with no rev: the form dek.toml `[refs]` keys take. */
+/** A valid `owner/repo/deck` with no rev, or a pack's `file/<deck>`: the form dek.toml `[refs]` keys take. */
 export function isPlainRefName(name: string): boolean {
   try {
     const source = parseRefSource(name);
-    return source.rev === undefined && source.name === name;
+    return (source.kind === "file" || source.rev === undefined) && source.name === name;
   } catch {
     return false;
   }
@@ -51,6 +73,16 @@ export function isPinnedRev(rev: string): boolean {
   return SHA_RE.test(rev);
 }
 
+/** True when `pin` has the form a ref of this kind is pinned with: a commit, or a pack's digest. */
+export function isPinFor(source: RefSource, pin: string): boolean {
+  return source.kind === "file" ? DIGEST_RE.test(pin) : SHA_RE.test(pin);
+}
+
+/** True for a deck name a ref can carry: no slash, space, or @, and not . or .. */
+export function isRefDeckName(deck: string | undefined): deck is string {
+  return deck !== undefined && DECK_RE.test(deck) && deck !== "." && deck !== "..";
+}
+
 export function parseRefSource(input: string): RefSource {
   const trimmed = input.trim();
   if (/^https?:\/\//i.test(trimmed)) {
@@ -60,6 +92,17 @@ export function parseRefSource(input: string): RefSource {
   const path = at === -1 ? trimmed : trimmed.slice(0, at);
   const rev = at === -1 ? undefined : trimmed.slice(at + 1);
   const [owner, repo, deck, ...extra] = path.split("/");
+  if (owner === PACK_OWNER && deck === undefined) {
+    if (rev !== undefined || !isRefDeckName(repo)) {
+      throw new DekError(`"${input}" is not a ref name`, { hint: REF_HINT });
+    }
+    return { kind: "file", name: `${PACK_OWNER}/${repo}`, deck: repo };
+  }
+  if (owner?.toLowerCase() === PACK_OWNER && deck !== undefined) {
+    throw new DekError(`"${input}" is not a ref name`, {
+      hint: "file is kept for packs, so no GitHub owner of that name can be pinned; name a pack's ref as file/<deck>",
+    });
+  }
   const valid =
     extra.length === 0 &&
     owner !== undefined &&
@@ -68,15 +111,13 @@ export function parseRefSource(input: string): RefSource {
     REPO_RE.test(repo) &&
     repo !== "." &&
     repo !== ".." &&
-    deck !== undefined &&
-    DECK_RE.test(deck) &&
-    deck !== "." &&
-    deck !== ".." &&
+    isRefDeckName(deck) &&
     (rev === undefined || /^[^\s@]+$/.test(rev));
   if (!valid) {
     throw new DekError(`"${input}" is not a ref name`, { hint: REF_HINT });
   }
   return {
+    kind: "github",
     name: `${owner}/${repo}/${deck}`,
     owner,
     repo,
@@ -90,7 +131,7 @@ export function parseRefSource(input: string): RefSource {
  * link people copy from a browser. A branch name with a slash cannot be told
  * apart from the path, so such a branch goes after `@` instead.
  */
-function parseGithubUrl(input: string): RefSource {
+function parseGithubUrl(input: string): GithubRefSource {
   const url = new URL(input);
   const [owner = "", repo = "", kind, rev, ...rest] = url.pathname.split("/").filter(Boolean);
   const decks = rest.indexOf("decks");
@@ -106,5 +147,8 @@ function parseGithubUrl(input: string): RefSource {
     });
   }
   const source = parseRefSource(`${owner}/${repo.replace(/\.git$/, "")}/${deck}@${rev}`);
+  if (source.kind !== "github") {
+    throw new DekError(`"${input}" is not a link to a deck on GitHub`, { hint: REF_HINT });
+  }
   return { ...source, path: rest.slice(0, decks + 2).join("/") };
 }