@drawnagency/primitives 0.1.118 → 0.1.119

package/src/document/engine/blocks.ts

@@ -1,116 +0,0 @@
-// Elements that are never allowed to survive into rendered output, wherever
-// they occur (top-level or nested).
-const DISALLOWED_TAGS = new Set([
-  "script",
-  "style",
-  "iframe",
-  "object",
-  "embed",
-  "link",
-  "meta",
-  "base",
-  "form",
-  // Raw-text / escapable-raw-text and declarative elements whose contents are
-  // not parsed as normal markup. Left in place they enable serialize/reparse
-  // (mXSS) bypasses — e.g. an <img onerror> smuggled inside <noscript> text.
-  // Removing the element drops its contents too (including <template> content).
-  "noscript",
-  "xmp",
-  "noembed",
-  "noframes",
-  "plaintext",
-  "template",
-]);
-const DISALLOWED_SELECTOR = Array.from(DISALLOWED_TAGS).join(",");
-
-// Attributes that can carry a URL and therefore need scheme scrutiny. `poster`
-// and `srcset` matter because <video>/<img>/<source> survive the scrub; the
-// rest belong to elements DISALLOWED_TAGS already removes, and are listed so a
-// future relaxation of that set doesn't quietly open a hole.
-const URL_ATTRS = new Set([
-  "href",
-  "src",
-  "srcset",
-  "poster",
-  "xlink:href",
-  "formaction",
-  "action",
-  "ping",
-  "data",
-  "background",
-]);
-
-function isDangerousUrl(attrName: string, rawValue: string): boolean {
-  // Browsers strip ASCII tab/CR/LF anywhere in a URL (and ignore leading
-  // controls) before resolving its scheme, so "jav\tascript:" runs like
-  // "javascript:". Over-stripping here only makes the check more conservative.
-  const value = rawValue.toLowerCase().replace(/[\u0000-\u0020]/g, "");
-  if (value.startsWith("javascript:") || value.startsWith("vbscript:")) return true;
-  if (attrName === "src" && value.startsWith("data:text/html")) return true;
-  return false;
-}
-
-// srcset is a comma-separated candidate list, so a startsWith check over the
-// whole value misses "a.png 1x, javascript:alert(1) 2x". Scrutinize each
-// candidate's URL part instead.
-function hasDangerousUrl(attrName: string, rawValue: string): boolean {
-  if (attrName !== "srcset") return isDangerousUrl(attrName, rawValue);
-  return rawValue
-    .split(",")
-    .some((candidate) => isDangerousUrl("src", candidate.trim().split(/\s+/)[0] ?? ""));
-}
-
-// Defense-in-depth scrub applied at the dangerouslySetInnerHTML/innerHTML
-// boundary. Upstream portal content is sanitized at authoring time, but
-// /print runs in an authed headless browser, so this engine (kept
-// dependency-free — no DOMPurify) removes known-dangerous elements and
-// attributes from the DOM it already parsed, in place.
-function scrubElement(root: Element): void {
-  root.querySelectorAll(DISALLOWED_SELECTOR).forEach((el) => el.remove());
-
-  const elements: Element[] = [root, ...Array.from(root.querySelectorAll("*"))];
-  for (const el of elements) {
-    for (const attr of Array.from(el.attributes)) {
-      const name = attr.name.toLowerCase();
-      if (name.startsWith("on") || name === "srcdoc") {
-        el.removeAttribute(attr.name);
-        continue;
-      }
-      if (URL_ATTRS.has(name) && hasDangerousUrl(name, attr.value)) {
-        el.removeAttribute(attr.name);
-      }
-    }
-  }
-}
-
-// Elements that carry meaning with no text of their own. The keep test used to
-// name <img> alone, so a rule, a video, an inline SVG diagram or a <picture>
-// was silently dropped from the printed document.
-const VISIBLE_EMPTY_SELECTOR = "img, hr, video, svg, picture, canvas";
-
-// Split sanitized rich-text HTML into atomic top-level blocks. Pagination
-// never splits inside a block — a block that doesn't fit moves wholesale to
-// the next page (spec: "pagination by block measurement").
-export function splitProseBlocks(html: string): string[] {
-  if (!html.trim()) return [];
-  const doc = new DOMParser().parseFromString(html, "text/html");
-  const blocks: string[] = [];
-  for (const node of Array.from(doc.body.childNodes)) {
-    if (node.nodeType === Node.ELEMENT_NODE) {
-      const el = node as Element;
-      if (DISALLOWED_TAGS.has(el.tagName.toLowerCase())) continue;
-      scrubElement(el);
-      if ((el.textContent ?? "").trim() || el.matches(VISIBLE_EMPTY_SELECTOR) || el.querySelector(VISIBLE_EMPTY_SELECTOR)) {
-        blocks.push(el.outerHTML);
-      }
-    } else if (node.nodeType === Node.TEXT_NODE) {
-      const text = (node.textContent ?? "").trim();
-      if (text) {
-        const p = doc.createElement("p");
-        p.textContent = text;
-        blocks.push(p.outerHTML);
-      }
-    }
-  }
-  return blocks;
-}

package/src/document/engine/harvest.ts

@@ -1,95 +0,0 @@
-import { splitProseBlocks } from "./blocks";
-import { PREAMBLE_ID, type Chunk, type DocImage, type DocSectionInput, type SplitAt } from "./types";
-
-// Shape of the fields harvest reads, checked structurally at runtime — the
-// engine must tolerate any future portal section without crashing (allowlist).
-type Loose = Record<string, unknown>;
-
-function str(v: unknown): string {
-  return typeof v === "string" ? v : "";
-}
-
-// Normalizes any runtime value (including null/undefined from malformed
-// portal data) into a safe-to-index object so field access never throws.
-function asRecord(v: unknown): Loose {
-  return v && typeof v === "object" ? (v as Loose) : {};
-}
-
-// One section's contribution to the current chunk (containers recurse).
-function harvestInto(
-  target: Chunk,
-  type: string,
-  content: unknown,
-  imagesById: Record<string, DocImage>,
-): void {
-  const c = asRecord(content);
-  switch (type) {
-    case "sub_heading":
-    case "link_heading": // nested (inside a container) — not a boundary here
-      target.textBlocks.push({ kind: "heading", level: 2, text: str(c.heading) });
-      break;
-    case "sub_sub_heading":
-      target.textBlocks.push({ kind: "heading", level: 3, text: str(c.heading) });
-      break;
-    case "prose":
-      for (const html of splitProseBlocks(str(c.body))) {
-        target.textBlocks.push({ kind: "prose", html });
-      }
-      break;
-    case "media": {
-      const ref = asRecord(c.ref);
-      const image = imagesById[str(ref.imageId)];
-      if (image) target.images.push(image);
-      break;
-    }
-    case "container": {
-      const children = Array.isArray(c.children) ? c.children : [];
-      for (const child of children) {
-        const cc = asRecord(child);
-        if (typeof cc.type === "string") {
-          harvestInto(target, cc.type, cc.content, imagesById);
-        }
-      }
-      break;
-    }
-    default:
-      break; // allowlist: video, button, spacer, colors, do/dont, icon list, unknown future types
-  }
-}
-
-export function harvest(
-  sections: DocSectionInput[],
-  pageTitle: string,
-  imagesById: Record<string, DocImage>,
-  splitAtFor: (chunkId: string) => SplitAt = () => "none",
-): Chunk[] {
-  const chunks: Chunk[] = [];
-  const preamble: Chunk = { id: PREAMBLE_ID, title: pageTitle, textBlocks: [], images: [] };
-  let parent = preamble; // current top-level chunk — owns the splitAt setting
-  let current = preamble; // chunk receiving harvested content
-  let splitAt = splitAtFor(PREAMBLE_ID);
-
-  for (const section of sections) {
-    const heading = str(asRecord(section.content).heading);
-    if (section.type === "link_heading") {
-      parent = { id: section.id, title: heading, textBlocks: [], images: [] };
-      current = parent;
-      splitAt = splitAtFor(section.id);
-      chunks.push(parent);
-    } else if (section.type === "sub_heading" && splitAt === "sub_heading") {
-      // Promotion: the boundary heading becomes the chunk title, not a TextBlock.
-      current = { id: section.id, title: heading, textBlocks: [], images: [], parentId: parent.id, kicker: parent.title, depth: 1 };
-      chunks.push(current);
-    } else {
-      harvestInto(current, section.type, section.content, imagesById);
-    }
-  }
-
-  // Kept when it has own content OR spawned sub-chunks — an emptied-but-split
-  // preamble must stay selectable (its ghost is the way back to splitAt).
-  const keepPreamble =
-    preamble.textBlocks.length > 0 ||
-    preamble.images.length > 0 ||
-    chunks.some((c) => c.parentId === PREAMBLE_ID);
-  return keepPreamble ? [preamble, ...chunks] : chunks;
-}

package/src/document/engine/masonry.ts

@@ -1,158 +0,0 @@
-const EPS = 1e-6;
-
-export type MasonryMode = "rows" | "columns";
-
-export type Sized = { width: number; height: number };
-
-export interface MasonryOpts {
-  mode: MasonryMode;
-  columns: 2 | 3 | 4 | 5 | 6;
-  bodyWIn: number;
-  bodyHIn: number;
-  gapIn: number;
-  targetRowHeightIn: number;
-  rows?: "auto" | 1 | 2 | 3 | 4;
-}
-
-export interface MasonryBox<T extends Sized = Sized> {
-  asset: T;
-  xIn: number;
-  yIn: number;
-  wIn: number;
-  hIn: number;
-}
-
-// A "cover" photo is laid out in a SQUARE cell (effective aspect 1) and the
-// image crops to fill it; "contain" (default) uses the photo's natural aspect.
-const effectiveAspect = (im: Sized, fit: "cover" | "contain" | undefined) => {
-  if (fit === "cover") return 1;
-  const aspect = im.width / im.height;
-  // A 0-height item (a legacy manifest row from before the decode guard) made
-  // this Infinity or NaN, and every downstream width went with it — the whole
-  // page laid out blank. Square is the same fallback the cover path uses.
-  return Number.isFinite(aspect) && aspect > 0 ? aspect : 1;
-};
-
-function layoutRows<T extends Sized>(images: T[], o: MasonryOpts, fits: ("cover" | "contain")[]): { boxes: MasonryBox<T>[]; used: number; endY: number } {
-  const asp = images.map((im, i) => effectiveAspect(im, fits[i]));
-  const boxes: MasonryBox<T>[] = [];
-  let y = 0, i = 0;
-  let used: number | null = null;
-  while (i < images.length) {
-    const row: number[] = []; // indices in this row
-    let natW = 0;
-    while (i + row.length < images.length) {
-      row.push(i + row.length);
-      const gaps = o.gapIn * (row.length - 1);
-      natW = row.reduce((s, idx) => s + asp[idx] * o.targetRowHeightIn, 0) + gaps;
-      if (natW >= o.bodyWIn) break;
-    }
-    const gaps = o.gapIn * (row.length - 1);
-    const sumAspect = row.reduce((s, idx) => s + asp[idx], 0);
-    const isFull = natW >= o.bodyWIn;
-    const rowH = isFull ? (o.bodyWIn - gaps) / sumAspect : o.targetRowHeightIn;
-    if (used === null && y + rowH > o.bodyHIn + EPS && boxes.length > 0) used = boxes.length;
-    let x = 0;
-    for (const idx of row) {
-      const w = asp[idx] * rowH;
-      boxes.push({ asset: images[idx], xIn: x, yIn: y, wIn: w, hIn: rowH });
-      x += w + o.gapIn;
-    }
-    y += rowH + o.gapIn;
-    i += row.length;
-  }
-  return { boxes, used: used ?? images.length, endY: y };
-}
-
-// Forced row count: partition the images into exactly N rows (fewer only if
-// there are fewer images), aspect-balanced, each row scaled to full width —
-// unless the stack would exceed the region height, in which case the whole
-// block scales down uniformly to fit (never up), left-aligned. Unlike
-// layoutRows there is no target height — the row's share of the total aspect
-// determines its height.
-function layoutForcedRows<T extends Sized>(
-  images: T[],
-  o: MasonryOpts,
-  fits: ("cover" | "contain")[],
-  n: number,
-): { boxes: MasonryBox<T>[]; used: number; endY: number } {
-  const asp = images.map((im, i) => effectiveAspect(im, fits[i]));
-  const count = Math.min(n, images.length);
-  // Greedy balance: each row takes images until it reaches the average
-  // aspect-sum of what's left, always leaving >=1 image per remaining row.
-  const rows: number[][] = [];
-  let i = 0;
-  for (let r = 0; r < count; r++) {
-    const remainingRows = count - r;
-    const target = asp.slice(i).reduce((s, a) => s + a, 0) / remainingRows;
-    const row: number[] = [];
-    let sum = 0;
-    while (i < asp.length) {
-      if (row.length > 0) {
-        if (asp.length - (i + 1) < remainingRows - 1) break; // taking i must leave >=1 image per remaining row
-        if (sum >= target - EPS) break;
-      }
-      row.push(i);
-      sum += asp[i];
-      i++;
-    }
-    rows.push(row);
-  }
-
-  // Pass 1: full-width row heights from the aspect math.
-  const rowMeta = rows.map((row) => {
-    const gaps = o.gapIn * (row.length - 1);
-    const sumAspect = row.reduce((s, a) => s + asp[a], 0);
-    return { row, gaps, sumAspect, hIn: (o.bodyWIn - gaps) / sumAspect };
-  });
-  // Pass 2: if the stack exceeds the region, scale everything down uniformly —
-  // natural aspects kept, gaps fixed, block left-aligned. Never upscale.
-  const rowGaps = o.gapIn * (rowMeta.length - 1);
-  const totalH = rowMeta.reduce((s, m) => s + m.hIn, 0);
-  const scale = totalH > 0 ? Math.min(1, Math.max(0, o.bodyHIn - rowGaps) / totalH) : 1;
-
-  const boxes: MasonryBox<T>[] = [];
-  let y = 0;
-  for (const m of rowMeta) {
-    const rowH = m.hIn * scale;
-    let x = 0;
-    for (const idx of m.row) {
-      const w = asp[idx] * rowH;
-      boxes.push({ asset: images[idx], xIn: x, yIn: y, wIn: w, hIn: rowH });
-      x += w + o.gapIn;
-    }
-    y += rowH + o.gapIn;
-  }
-  return { boxes, used: images.length, endY: y };
-}
-
-function layoutColumns<T extends Sized>(images: T[], o: MasonryOpts, fits: ("cover" | "contain")[]): { boxes: MasonryBox<T>[]; used: number; colHeights: number[]; colW: number } {
-  const n = o.columns;
-  const colW = (o.bodyWIn - o.gapIn * (n - 1)) / n;
-  const colH = new Array(n).fill(0);
-  const boxes: MasonryBox<T>[] = [];
-  let used: number | null = null;
-  images.forEach((im, idx) => {
-    let c = 0;
-    for (let k = 1; k < n; k++) if (colH[k] < colH[c]) c = k;
-    const y = colH[c];
-    const h = colW / effectiveAspect(im, fits[idx]);
-    if (used === null && y + h > o.bodyHIn + EPS && idx > 0) used = idx;
-    boxes.push({ asset: im, xIn: c * (colW + o.gapIn), yIn: y, wIn: colW, hIn: h });
-    colH[c] = y + h + o.gapIn;
-  });
-  return { boxes, used: used ?? images.length, colHeights: colH, colW };
-}
-
-export function layoutMasonryPage<T extends Sized>(
-  images: T[],
-  o: MasonryOpts,
-  fits: ("cover" | "contain")[] = [],
-): { boxes: MasonryBox<T>[]; used: number } {
-  if (o.mode === "columns") {
-    const r = layoutColumns(images, o, fits);
-    return { boxes: r.boxes, used: r.used };
-  }
-  const r = typeof o.rows === "number" ? layoutForcedRows(images, o, fits, o.rows) : layoutRows(images, o, fits);
-  return { boxes: r.boxes, used: r.used };
-}

package/src/document/engine/paginate.ts

@@ -1,232 +0,0 @@
-import { layoutMasonryPage } from "./masonry";
-import type { SectionSettings } from "./settings";
-import type { Chunk, DocImage, TextBlock } from "./types";
-
-export interface DocGeom {
-  bodyWIn: number;
-  bodyHIn: number;
-  titleBandIn: number;
-  gapIn: number;
-  leftColWIn: number;
-  colGutterIn: number;
-  minTextColIn: number;
-  minImageRegionIn: number;
-  masonryTargetRowIn: number;
-  topTextMaxFraction: number;
-}
-
-// Mirrors .deck-body in deck.css (17×11 page, top 1.35in, sides/bottom 0.6in).
-export const DOC_GEOM: DocGeom = {
-  bodyWIn: 15.8,
-  bodyHIn: 9.05,
-  titleBandIn: 0.9,
-  gapIn: 0.15,
-  leftColWIn: 4.6,
-  colGutterIn: 0.4,
-  minTextColIn: 1,
-  minImageRegionIn: 1.2,
-  masonryTargetRowIn: 2.6,
-  // Top text fills at most this fraction of the body height below the title
-  // band, so a text-heavy top section always leaves ≥ half the page for images.
-  topTextMaxFraction: 0.5,
-};
-
-const EPS = 1e-6;
-
-export interface Region { xIn: number; yIn: number; wIn: number; hIn: number; }
-export interface ImageBox {
-  image: DocImage;
-  xIn: number; yIn: number; wIn: number; hIn: number;
-  fit: "cover" | "contain";
-}
-export interface DerivedPage {
-  id: string;
-  chunkId: string;
-  title: string;
-  cont: boolean;
-  // Sub-chunk context (absent on top-level pages) — see Chunk.
-  kicker?: string;
-  depth?: 1;
-  textBlocks: TextBlock[];
-  textRegion: Region | null;
-  imageBoxes: ImageBox[];
-  warnings: string[];
-}
-
-function fitImages(
-  images: DocImage[],
-  layout: SectionSettings["imageLayout"],
-  region: Region,
-  geom: DocGeom,
-): { boxes: ImageBox[]; used: number } {
-  if (images.length === 0 || region.hIn < geom.minImageRegionIn) return { boxes: [], used: 0 };
-
-  if (layout.mode === "grid") {
-    const used = Math.min(layout.rows * layout.columns, images.length);
-    const cellW = (region.wIn - (layout.columns - 1) * geom.gapIn) / layout.columns;
-    const cellH = (region.hIn - (layout.rows - 1) * geom.gapIn) / layout.rows;
-    const boxes = images.slice(0, used).map((image, i) => {
-      const r = Math.floor(i / layout.columns);
-      const c = i % layout.columns;
-      return {
-        image,
-        xIn: region.xIn + c * (cellW + geom.gapIn),
-        yIn: region.yIn + r * (cellH + geom.gapIn),
-        wIn: cellW,
-        hIn: cellH,
-        fit: layout.fit,
-      };
-    });
-    return { boxes, used };
-  }
-
-  const r = layoutMasonryPage(images, {
-    mode: layout.flow,
-    columns: layout.columns,
-    rows: layout.rows,
-    bodyWIn: region.wIn,
-    bodyHIn: region.hIn,
-    gapIn: geom.gapIn,
-    targetRowHeightIn: geom.masonryTargetRowIn,
-  });
-  const boxes = r.boxes.slice(0, r.used).map((b) => ({
-    image: b.asset,
-    xIn: region.xIn + b.xIn,
-    yIn: region.yIn + b.yIn,
-    wIn: b.wIn,
-    hIn: b.hIn,
-    fit: "contain" as const,
-  }));
-  return { boxes, used: r.used };
-}
-
-export function paginateChunk(
-  chunk: Chunk,
-  settings: SectionSettings,
-  textHeightsIn: number[],
-  geom: DocGeom = DOC_GEOM,
-  naturalTextWIn?: number,
-): DerivedPage[] {
-  if (settings.excluded) return [];
-  if (chunk.textBlocks.length !== textHeightsIn.length) {
-    throw new Error("paginateChunk: textHeightsIn must match chunk.textBlocks");
-  }
-  if (chunk.textBlocks.length === 0 && chunk.images.length === 0) return [];
-
-  // leftColumn shrinks to the widest natural text line (+ slack so sub-pixel
-  // rounding can't re-wrap), floored/capped; absent measurement = legacy fixed
-  // column. The shrunk width is >= every block's natural width by
-  // construction, so measured heights remain valid.
-  const colWIn =
-    naturalTextWIn === undefined
-      ? geom.leftColWIn
-      : Math.min(geom.leftColWIn, Math.max(geom.minTextColIn, naturalTextWIn + 0.05));
-
-  const pages: DerivedPage[] = [];
-  let ti = 0;
-  let ii = 0;
-  const top = geom.titleBandIn;
-
-  while (ti < chunk.textBlocks.length || ii < chunk.images.length) {
-    const cont = pages.length > 0;
-    const warnings: string[] = [];
-    const textW = settings.textPlacement === "top" ? geom.bodyWIn : colWIn;
-
-    // 1. Greedy text fill. Top text is capped at half the body so a text-heavy
-    // section still leaves room for images below; leftColumn keeps full height.
-    // The cap only earns its keep while images are still waiting for room. Held
-    // on every page, it paginated a text-only section (or the text-only tail of
-    // one) at half utilisation and roughly doubled its page count.
-    const capY =
-      settings.textPlacement === "top" && ii < chunk.images.length
-        ? geom.titleBandIn + (geom.bodyHIn - geom.titleBandIn) * geom.topTextMaxFraction
-        : geom.bodyHIn;
-    const placed: TextBlock[] = [];
-    let textEnd = top;
-    while (ti < chunk.textBlocks.length) {
-      const h = textHeightsIn[ti];
-      const yAfter = placed.length === 0 ? top + h : textEnd + geom.gapIn + h;
-      if (yAfter <= capY + EPS) {
-        placed.push(chunk.textBlocks[ti]);
-        textEnd = yAfter;
-        ti++;
-      } else if (placed.length === 0) {
-        // Oversize block: it gets the page, clipped at the cap (masonry-notice style).
-        placed.push(chunk.textBlocks[ti]);
-        textEnd = capY;
-        ti++;
-        warnings.push("A text block is taller than the page and was clipped.");
-        break;
-      } else {
-        break;
-      }
-    }
-
-    // dropTextOverflow: on the FIRST page only, discard any text that didn't fit
-    // rather than flowing it onto Cont. pages. Images still paginate as usual.
-    if (!cont && settings.dropTextOverflow && ti < chunk.textBlocks.length) {
-      const dropped = chunk.textBlocks.length - ti;
-      ti = chunk.textBlocks.length;
-      warnings.push(`${dropped} text block(s) hidden (overflow dropped)`);
-    }
-    const textRegion: Region | null =
-      placed.length > 0 ? { xIn: 0, yIn: top, wIn: textW, hIn: textEnd - top } : null;
-
-    // 2. Image region. leftColumn+right runs beside the text; every other
-    // case — and any page whose text is exhausted — is full width below it.
-    let region: Region;
-    if (settings.textPlacement === "leftColumn" && settings.imagePlacement === "right" && placed.length > 0) {
-      region = {
-        xIn: colWIn + geom.colGutterIn,
-        yIn: top,
-        wIn: geom.bodyWIn - colWIn - geom.colGutterIn,
-        hIn: geom.bodyHIn - top,
-      };
-    } else {
-      const startY = placed.length > 0 ? textEnd + geom.gapIn : top;
-      region = { xIn: 0, yIn: startY, wIn: geom.bodyWIn, hIn: Math.max(0, geom.bodyHIn - startY) };
-    }
-
-    // 3. Fit images into the region.
-    const { boxes, used } = fitImages(chunk.images.slice(ii), settings.imageLayout, region, geom);
-    ii += used;
-    if (boxes.some((b) => b.yIn + b.hIn > region.yIn + region.hIn + 0.01)) {
-      warnings.push("An image overflows the page and is clipped.");
-    }
-
-    // Progress guard: unreachable with sane geometry (a text-free page always
-    // gets the full region, and both fitters place ≥1 there), but a config
-    // mistake must not hang the browser.
-    if (placed.length === 0 && used === 0) {
-      warnings.push("Pagination could not place remaining content.");
-      pages.push({
-        id: `${chunk.id}#${pages.length}`,
-        chunkId: chunk.id,
-        title: cont ? `${chunk.title} Cont.` : chunk.title,
-        cont,
-        kicker: chunk.kicker,
-        depth: chunk.depth,
-        textBlocks: placed,
-        textRegion,
-        imageBoxes: boxes,
-        warnings,
-      });
-      break;
-    }
-
-    pages.push({
-      id: `${chunk.id}#${pages.length}`,
-      chunkId: chunk.id,
-      title: cont ? `${chunk.title} Cont.` : chunk.title,
-      cont,
-      kicker: chunk.kicker,
-      depth: chunk.depth,
-      textBlocks: placed,
-      textRegion,
-      imageBoxes: boxes,
-      warnings,
-    });
-  }
-
-  return pages;
-}