explico 0.11.1 → 0.13.0

package/dist/compiler/exports/static-tree.js

@@ -0,0 +1,625 @@
+import { parse, parseFragment } from "parse5";
+import {
+  attribute,
+  childrenOf,
+  elements,
+  hasClass,
+  inferBasePrefix,
+  isElement
+} from "./html-tree.js";
+const SKIPPED_TAGS = /* @__PURE__ */ new Set([
+  "button",
+  "input",
+  "nav",
+  "noscript",
+  "script",
+  "select",
+  "style",
+  "svg",
+  "template",
+  "textarea",
+  "astro-island"
+]);
+const SKIPPED_CLASSES = [
+  "sr-only",
+  "sl-anchor-link",
+  "keyed-equation__controls",
+  "float-tools",
+  "float-caption__anchor",
+  "keyed-figure__tools-stub",
+  "short-note__collapse",
+  "notation-enhancement-help",
+  "pagination-links",
+  "explico-site-footer",
+  "lesson-breadcrumb",
+  // A part page's stats line and chapter list are navigation the site builds;
+  // a print export's own contents replace them. Its objectives stay.
+  "part-meta",
+  "part-chapters"
+];
+const REF_CLASSES = [
+  ["equation-ref", "equation"],
+  ["figure-ref", "figure"],
+  ["table-ref", "table"],
+  ["diagram-ref", "diagram"],
+  ["section-ref", "section"],
+  ["example-ref", "example"],
+  ["knowledge-check-ref", "check"],
+  ["memo-ref", "memo"]
+];
+function skipped(node) {
+  if (SKIPPED_TAGS.has(node.tagName)) return true;
+  if (attribute(node, "aria-hidden") === "true") return true;
+  if (attribute(node, "data-print-omit") !== void 0) return true;
+  return SKIPPED_CLASSES.some((name) => hasClass(node, name));
+}
+function readableText(node) {
+  if (!isElement(node)) {
+    return node.nodeName === "#text" ? node.value : "";
+  }
+  if (skipped(node)) return "";
+  return childrenOf(node).map(readableText).join("");
+}
+function collapse(text) {
+  return text.replace(/[ \t\r\n\f]+/gu, " ");
+}
+function texOf(katex) {
+  const annotation = elements(
+    katex,
+    (node) => node.tagName === "annotation" && attribute(node, "encoding") === "application/x-tex"
+  )[0];
+  if (!annotation) return void 0;
+  return childrenOf(annotation).map((child) => "value" in child ? String(child.value) : "").join("").trim();
+}
+function firstByClass(root, name) {
+  return elements(root, (node) => hasClass(node, name))[0];
+}
+function cleanRoute(pathname, base) {
+  let path = pathname;
+  if (path.startsWith(base)) path = path.slice(base.length);
+  return path.replace(/\/index\.html$/u, "").replace(/\.html$/u, "").replace(/^\/+|\/+$/gu, "");
+}
+function courseTarget(href, context) {
+  const trimmed = href.trim();
+  if (trimmed.startsWith("#")) {
+    return { route: context.route, anchor: decodeURIComponent(trimmed.slice(1)) };
+  }
+  if (/^[a-z][a-z0-9+.-]*:/iu.test(trimmed) || trimmed.startsWith("//")) return void 0;
+  const page = new URL(
+    `${context.base}${context.route ? `${context.route}/` : ""}`,
+    "https://explico.invalid"
+  );
+  const url = new URL(trimmed, page);
+  return {
+    route: cleanRoute(url.pathname, context.base),
+    anchor: decodeURIComponent(url.hash.slice(1))
+  };
+}
+function trimInlines(inlines) {
+  const result = [...inlines];
+  while (result[0]?.kind === "text" && !result[0].value.trim()) result.shift();
+  while (result.at(-1)?.kind === "text" && !result.at(-1).value.trim()) {
+    result.pop();
+  }
+  const first = result[0];
+  if (first?.kind === "text") result[0] = { kind: "text", value: first.value.replace(/^ +/u, "") };
+  const last = result.at(-1);
+  if (last?.kind === "text") {
+    result[result.length - 1] = { kind: "text", value: last.value.replace(/ +$/u, "") };
+  }
+  return result;
+}
+function readLink(node, context) {
+  const href = attribute(node, "href") ?? "";
+  const children = readInlines(node, context);
+  if (hasClass(node, "citation-ref")) {
+    const number = attribute(node, "data-citation-number") ?? readableText(node).replace(/\D/gu, "");
+    return [
+      {
+        kind: "cite",
+        number,
+        anchor: href.replace(/^#/u, ""),
+        sourceId: attribute(node, "data-citation-id"),
+        locator: attribute(node, "data-citation-locator") || void 0
+      }
+    ];
+  }
+  if (hasClass(node, "memo-marker")) {
+    return [
+      {
+        kind: "memoMark",
+        anchor: href.replace(/^#/u, ""),
+        label: attribute(node, "data-memo-number") ?? readableText(node).trim()
+      }
+    ];
+  }
+  if (hasClass(node, "short-note-marker")) {
+    return [{ kind: "noteMark", anchor: href.replace(/^#/u, ""), children }];
+  }
+  if (hasClass(node, "notation-term")) {
+    return [{ kind: "term", key: attribute(node, "data-notation-key") ?? "", children }];
+  }
+  if (!href) return children;
+  const target = courseTarget(href, context);
+  if (!target) return [{ kind: "link", href, children }];
+  const refKind = REF_CLASSES.find(([name]) => hasClass(node, name))?.[1] ?? (target.route === context.route ? "anchor" : "page");
+  return [{ kind: "ref", refKind, target, children }];
+}
+function readInline(node, context) {
+  if (!isElement(node)) {
+    if (node.nodeName !== "#text") return [];
+    const value = collapse(node.value);
+    return value ? [{ kind: "text", value }] : [];
+  }
+  if (hasClass(node, "katex")) {
+    const tex = texOf(node);
+    return tex ? [{ kind: "math", tex }] : [];
+  }
+  if (skipped(node)) return [];
+  switch (node.tagName) {
+    case "em":
+    case "i":
+      return [{ kind: "emphasis", children: readInlines(node, context) }];
+    case "strong":
+    case "b":
+      return [{ kind: "strong", children: readInlines(node, context) }];
+    case "sup":
+      if (hasClass(node, "memo-marker-wrap")) return readInlines(node, context);
+      return [{ kind: "superscript", children: readInlines(node, context) }];
+    case "sub":
+      return [{ kind: "subscript", children: readInlines(node, context) }];
+    case "code":
+    case "kbd":
+      return [{ kind: "code", value: readableText(node) }];
+    case "br":
+      return [{ kind: "break" }];
+    case "a":
+      return readLink(node, context);
+    default:
+      return readInlines(node, context);
+  }
+}
+function readInlines(node, context) {
+  const result = [];
+  for (const child of childrenOf(node)) {
+    for (const inline of readInline(child, context)) {
+      const previous = result.at(-1);
+      if (inline.kind === "text" && previous?.kind === "text") {
+        result[result.length - 1] = {
+          kind: "text",
+          value: collapse(previous.value + inline.value)
+        };
+      } else {
+        result.push(inline);
+      }
+    }
+  }
+  return result;
+}
+function inlineContent(node, context) {
+  return node ? trimInlines(readInlines(node, context)) : [];
+}
+function numberAttribute(node, name) {
+  return Number.parseFloat(attribute(node, name) ?? "0") || 0;
+}
+function readDiagramGeometry(figure) {
+  const svg = elements(figure, (node) => node.tagName === "svg" && !!attribute(node, "viewBox")).find((node) => elements(node, (child) => hasClass(child, "diagram-node")).length > 0);
+  if (!svg) return void 0;
+  const [, , width, height] = (attribute(svg, "viewBox") ?? "0 0 0 0").trim().split(/[\s,]+/u).map(Number);
+  const nodes = elements(svg, (node) => hasClass(node, "diagram-node")).flatMap((group) => {
+    const rect = elements(group, (node) => node.tagName === "rect")[0];
+    if (!rect) return [];
+    const text = firstByClass(group, "diagram-node-text");
+    const formula = firstByClass(group, "diagram-node-formula");
+    const katex = formula ? elements(formula, (node) => hasClass(node, "katex"))[0] : void 0;
+    const label = text ? collapse(readableText(text)).trim() : "";
+    const tex = katex ? texOf(katex) : void 0;
+    return [
+      {
+        x: numberAttribute(rect, "x"),
+        y: numberAttribute(rect, "y"),
+        width: numberAttribute(rect, "width"),
+        height: numberAttribute(rect, "height"),
+        radius: numberAttribute(rect, "rx"),
+        ...label ? { text: label } : {},
+        ...tex ? { tex } : {}
+      }
+    ];
+  });
+  const edges = elements(svg, (node) => node.tagName === "path" && hasClass(node, "diagram-edge")).map(
+    (path) => [...(attribute(path, "d") ?? "").matchAll(/[ML]\s*(-?[\d.]+)[\s,]+(-?[\d.]+)/gu)].map(
+      (match) => [Number(match[1]), Number(match[2])]
+    )
+  ).filter((points) => points.length >= 2);
+  return { width: width ?? 0, height: height ?? 0, nodes, edges };
+}
+function readCaption(figcaption, context) {
+  if (!figcaption) return [];
+  const text = firstByClass(figcaption, "float-caption__text");
+  return inlineContent(text, context);
+}
+function floatBase(node, prefix, context) {
+  const figcaption = elements(node, (child) => child.tagName === "figcaption")[0];
+  const key = attribute(node, `data-${prefix}-key`);
+  const short = attribute(node, `data-${prefix}-short`);
+  return {
+    anchor: attribute(node, "id") ?? "",
+    number: attribute(node, `data-${prefix}-number`) ?? "",
+    ...key ? { key } : {},
+    ...short ? { short } : {},
+    caption: readCaption(figcaption, context)
+  };
+}
+function readFigurePicture(body) {
+  if (!body) return { kind: "capture" };
+  const diagram = elements(body, (node) => node.tagName === "figure" && hasClass(node, "diagram"))[0];
+  if (diagram) {
+    const geometry = readDiagramGeometry(diagram);
+    if (geometry) return { kind: "diagram", geometry };
+  }
+  const meaningful = childrenOf(body).filter(
+    (child) => isElement(child) && !["script", "style"].includes(child.tagName) || child.nodeName === "#text" && child.value.trim()
+  );
+  const only = meaningful.length === 1 && isElement(meaningful[0]) ? meaningful[0] : void 0;
+  const image = only?.tagName === "img" ? only : only?.tagName === "picture" ? elements(only, (node) => node.tagName === "img")[0] : void 0;
+  if (image && attribute(image, "src")) {
+    return { kind: "image", src: attribute(image, "src"), alt: attribute(image, "alt") ?? "" };
+  }
+  return { kind: "capture" };
+}
+function readTableCells(row, context) {
+  return childrenOf(row).filter((cell) => isElement(cell) && ["td", "th"].includes(cell.tagName)).map((cell) => {
+    const style = attribute(cell, "style") ?? "";
+    const align = attribute(cell, "align") ?? /text-align:\s*(left|center|right)/u.exec(style)?.[1];
+    return {
+      header: cell.tagName === "th",
+      colspan: Number.parseInt(attribute(cell, "colspan") ?? "1", 10) || 1,
+      rowspan: Number.parseInt(attribute(cell, "rowspan") ?? "1", 10) || 1,
+      ...align === "left" || align === "center" || align === "right" ? { align } : {},
+      children: inlineContent(cell, context)
+    };
+  });
+}
+function readTable(table, context) {
+  const rows = (section) => elements(table, (node) => node.tagName === section).flatMap(
+    (group) => childrenOf(group).filter(
+      (row) => isElement(row) && row.tagName === "tr" && !hasClass(row, "keyed-table__more-row")
+    )
+  ).map((row) => readTableCells(row, context));
+  const head = rows("thead");
+  const body = rows("tbody");
+  if (head.length === 0 && body.length === 0) {
+    return {
+      head: [],
+      body: childrenOf(table).filter((row) => isElement(row) && row.tagName === "tr").map((row) => readTableCells(row, context))
+    };
+  }
+  return { head, body };
+}
+function headingOf(wrapper) {
+  return childrenOf(wrapper).find(
+    (child) => isElement(child) && /^h[1-6]$/u.test(child.tagName)
+  );
+}
+function blockTitle(heading, context) {
+  if (!heading) return [];
+  return inlineContent(firstByClass(heading, "block-heading__title") ?? heading, context);
+}
+function readExamples(node, context) {
+  const heading = elements(node, (child) => hasClass(child, "block-heading"))[0];
+  const items = elements(node, (child) => hasClass(child, "compact-example")).map((section) => {
+    const title = elements(section, (child) => hasClass(child, "compact-example__heading"))[0];
+    return {
+      title: title ? inlineContent(title, context) : [{ kind: "text", value: attribute(section, "data-example-label") ?? "" }],
+      children: readBlocks(section, context, (child) => child !== title)
+    };
+  });
+  return {
+    kind: "examples",
+    anchor: attribute(heading ?? node, "id") ?? "",
+    number: (heading && attribute(heading, "data-ex-number")) ?? "",
+    title: blockTitle(heading, context),
+    items
+  };
+}
+function readNotationEntry(entry, context) {
+  const key = attribute(entry, "data-notation-entry") ?? "";
+  const symbol = elements(entry, (node) => hasClass(node, "notation-symbol"))[0];
+  const symbolKatex = symbol ? elements(symbol, (node) => hasClass(node, "katex"))[0] : void 0;
+  const label = elements(entry, (node) => node.tagName === "a" && !!attribute(node, "data-notation-link"))[0];
+  const summary = elements(entry, (node) => attribute(node, "data-notation-summary") !== void 0)[0];
+  const units = elements(entry, (node) => attribute(node, "data-notation-units") !== void 0)[0];
+  const formula = elements(entry, (node) => attribute(node, "data-notation-formula") !== void 0)[0];
+  const formulaKatex = formula ? elements(formula, (node) => hasClass(node, "katex"))[0] : void 0;
+  const unitsInlines = units ? trimInlines(
+    readInlines(units, context).filter(
+      (inline) => !(inline.kind === "strong")
+    )
+  ) : void 0;
+  const symbolTex = symbolKatex ? texOf(symbolKatex) : void 0;
+  const formulaTex = formulaKatex ? texOf(formulaKatex) : void 0;
+  return {
+    key,
+    anchor: attribute(entry, "id") ?? `notation-${key}`,
+    ...symbolTex ? { symbolTex } : {},
+    label: inlineContent(label, context),
+    summary: inlineContent(summary, context),
+    ...unitsInlines && unitsInlines.length > 0 ? { units: unitsInlines } : {},
+    ...formulaTex ? { formulaTex } : {}
+  };
+}
+function readBlocks(node, context, keep = () => true) {
+  const blocks = [];
+  let pending = [];
+  const flush = () => {
+    const content = trimInlines(pending);
+    if (content.length > 0) blocks.push({ kind: "paragraph", children: content });
+    pending = [];
+  };
+  for (const child of childrenOf(node)) {
+    if (!keep(child)) continue;
+    const block = isElement(child) ? readBlock(child, context) : void 0;
+    if (block === void 0) {
+      pending.push(...readInline(child, context));
+      continue;
+    }
+    flush();
+    blocks.push(...block);
+  }
+  flush();
+  return blocks;
+}
+function readBlock(node, context) {
+  if (hasClass(node, "katex-display")) {
+    const katex = elements(node, (child) => hasClass(child, "katex"))[0];
+    const tex = katex ? texOf(katex) : void 0;
+    return tex ? [{ kind: "displayMath", tex }] : [];
+  }
+  if (skipped(node)) return [];
+  if (hasClass(node, "notation-layer")) return [];
+  if (hasClass(node, "keyed-equation")) {
+    const katex = elements(node, (child) => hasClass(child, "katex"))[0];
+    const key = attribute(node, "data-eq-key");
+    return [
+      {
+        kind: "equation",
+        anchor: attribute(node, "id") ?? "",
+        number: attribute(node, "data-eq-number") ?? "",
+        ...key ? { key } : {},
+        tex: (katex && texOf(katex)) ?? ""
+      }
+    ];
+  }
+  if (node.tagName === "figure" && hasClass(node, "keyed-figure")) {
+    const body = firstByClass(node, "keyed-figure__body");
+    const island = body ? elements(body, (child) => child.tagName === "astro-island")[0] : void 0;
+    const figcaption = elements(node, (child) => child.tagName === "figcaption")[0];
+    const live = figcaption ? firstByClass(figcaption, "float-caption__state") : void 0;
+    const alt = island ? void 0 : body && attribute(body, "aria-label");
+    return [
+      {
+        kind: "figure",
+        ...floatBase(node, "fig", context),
+        live: inlineContent(live, context),
+        picture: readFigurePicture(body),
+        ...alt ? { alt } : {}
+      }
+    ];
+  }
+  if (node.tagName === "figure" && hasClass(node, "keyed-table")) {
+    const table = elements(node, (child) => child.tagName === "table")[0];
+    return [
+      {
+        kind: "table",
+        ...floatBase(node, "tab", context),
+        ...table ? readTable(table, context) : { head: [], body: [] }
+      }
+    ];
+  }
+  if (node.tagName === "figure" && hasClass(node, "diagram")) {
+    const geometry = readDiagramGeometry(node);
+    return [
+      {
+        kind: "diagram",
+        ...floatBase(node, "dia", context),
+        geometry: geometry ?? { width: 0, height: 0, nodes: [], edges: [] }
+      }
+    ];
+  }
+  if (hasClass(node, "memo-block")) {
+    const heading = elements(node, (child) => hasClass(child, "memo-block__heading"))[0];
+    const body = firstByClass(node, "memo-block__body");
+    const short = attribute(node, "data-memo-short");
+    return [
+      {
+        kind: "memo",
+        anchor: (heading && attribute(heading, "id")) ?? `memo-${attribute(node, "data-memo-key") ?? ""}`,
+        label: attribute(node, "data-memo-number") ?? "",
+        ...short ? { short } : {},
+        title: inlineContent(heading, context),
+        children: body ? readBlocks(body, context) : []
+      }
+    ];
+  }
+  if (node.tagName === "aside" && hasClass(node, "short-note")) {
+    const body = firstByClass(node, "short-note__body");
+    return [
+      {
+        kind: "note",
+        anchor: attribute(node, "id") ?? "",
+        title: attribute(node, "aria-label") ?? "",
+        children: body ? readBlocks(body, context) : []
+      }
+    ];
+  }
+  if (node.tagName === "aside" && hasClass(node, "starlight-aside")) {
+    const variant = /starlight-aside--([a-z]+)/u.exec(attribute(node, "class") ?? "")?.[1] ?? "note";
+    const title = firstByClass(node, "starlight-aside__title");
+    const content = firstByClass(node, "starlight-aside__content");
+    return [
+      {
+        kind: "aside",
+        variant,
+        title: inlineContent(title, context),
+        children: content ? readBlocks(content, context) : []
+      }
+    ];
+  }
+  if (hasClass(node, "fold")) {
+    const label = firstByClass(node, "fold__label");
+    const body = firstByClass(node, "fold__body");
+    const namesFloats = attribute(node, "data-names-floats") !== void 0;
+    return [
+      {
+        kind: "fold",
+        ...label && !namesFloats ? { title: inlineContent(label, context) } : {},
+        children: body ? readBlocks(body, context) : []
+      }
+    ];
+  }
+  if (node.tagName === "compact-examples" || hasClass(node, "compact-examples")) {
+    return [readExamples(node, context)];
+  }
+  if (hasClass(node, "sl-heading-wrapper")) {
+    const heading = headingOf(node);
+    if (!heading) return readBlocks(node, context);
+    if (attribute(heading, "data-block-kind") === "check") {
+      const anchor = attribute(heading, "id") ?? "";
+      return [
+        {
+          kind: "check",
+          anchor,
+          number: attribute(heading, "data-check-number") ?? "",
+          assessmentId: anchor.replace(/^check-/u, ""),
+          title: blockTitle(heading, context)
+        }
+      ];
+    }
+    return readBlock(heading, context) ?? [];
+  }
+  if (/^h[1-6]$/u.test(node.tagName)) {
+    if (hasClass(node, "citations-heading")) return [];
+    const anchor = attribute(node, "id");
+    const number = attribute(node, "data-sec-number");
+    return [
+      {
+        kind: "heading",
+        level: Number(node.tagName.slice(1)),
+        ...anchor ? { anchor } : {},
+        ...number ? { number } : {},
+        children: inlineContent(node, context)
+      }
+    ];
+  }
+  if (node.tagName === "ol" && hasClass(node, "citations-list")) {
+    return [
+      {
+        kind: "references",
+        items: childrenOf(node).filter((item) => isElement(item) && item.tagName === "li").map((item) => {
+          const anchor = attribute(item, "id") ?? "";
+          return {
+            number: anchor.replace(/^cite-/u, ""),
+            anchor,
+            children: trimInlines(
+              readInlines(item, context).filter(
+                (inline) => !(inline.kind === "ref" && inline.target.anchor.startsWith("cite-ref-"))
+              )
+            )
+          };
+        })
+      }
+    ];
+  }
+  switch (node.tagName) {
+    case "p": {
+      const children = inlineContent(node, context);
+      return children.length > 0 ? [{ kind: "paragraph", children }] : [];
+    }
+    case "ul":
+    case "ol": {
+      const start = Number.parseInt(attribute(node, "start") ?? "", 10);
+      return [
+        {
+          kind: "list",
+          ordered: node.tagName === "ol",
+          ...Number.isFinite(start) ? { start } : {},
+          items: childrenOf(node).filter((item) => isElement(item) && item.tagName === "li").map((item) => readBlocks(item, context))
+        }
+      ];
+    }
+    case "blockquote":
+      return [{ kind: "quote", children: readBlocks(node, context) }];
+    case "pre":
+      return [{ kind: "code", value: readableText(node).replace(/\n$/u, "") }];
+    case "hr":
+      return [{ kind: "rule" }];
+    case "img": {
+      const src = attribute(node, "src");
+      return src ? [{ kind: "image", src, alt: attribute(node, "alt") ?? "" }] : [];
+    }
+    case "table":
+      return [
+        {
+          kind: "table",
+          anchor: attribute(node, "id") ?? "",
+          number: "",
+          caption: [],
+          ...readTable(node, context)
+        }
+      ];
+    case "details":
+      return readBlocks(node, context, (child) => !(isElement(child) && child.tagName === "summary"));
+    case "div":
+    case "section":
+    case "article":
+    case "header":
+    case "footer":
+    case "main":
+    case "figure":
+    case "aside":
+    case "dl":
+    case "dd":
+    case "dt":
+    case "li":
+    case "compact-example":
+      return readBlocks(node, context);
+    default:
+      return void 0;
+  }
+}
+function readInlineFragment(html, route, base = "/") {
+  return inlineContent(parseFragment(html), { route, base });
+}
+function readStaticPage(html, slug, route) {
+  const document = parse(html);
+  const base = inferBasePrefix(document);
+  const context = { route, base };
+  const main = elements(document, (node) => node.tagName === "main")[0];
+  if (!main) throw new Error(`Built page ${slug} has no <main> element.`);
+  const title = elements(main, (node) => node.tagName === "h1")[0];
+  const content = elements(main, (node) => hasClass(node, "sl-markdown-content"))[0];
+  if (!content) throw new Error(`Built page ${slug} has no .sl-markdown-content element.`);
+  const layer = elements(
+    main,
+    (node) => hasClass(node, "notation-layer") && attribute(node, "data-notation-layer-id") === "page-notation"
+  )[0];
+  const entries = layer ? elements(layer, (node) => hasClass(node, "notation-entry") && attribute(node, "data-notation-entry") !== void 0) : [];
+  const remarks = layer ? elements(layer, (node) => node.tagName === "ul" && hasClass(node, "notation-suspended")).flatMap(
+    (list) => childrenOf(list).filter((item) => isElement(item) && item.tagName === "li").map((item) => inlineContent(item, context))
+  ) : [];
+  return {
+    slug,
+    route,
+    title: title ? collapse(readableText(title)).trim() : slug,
+    blocks: readBlocks(content, context),
+    notation: entries.map((entry) => readNotationEntry(entry, context)),
+    notationRemarks: remarks
+  };
+}
+export {
+  courseTarget,
+  readDiagramGeometry,
+  readInlineFragment,
+  readStaticPage,
+  readableText
+};

package/dist/compiler/exports/zip.d.ts

@@ -0,0 +1,16 @@
+import { Buffer } from 'node:buffer';
+
+/**
+ * A minimal, deterministic ZIP writer for export downloads: entries sorted by
+ * path, one fixed timestamp (1980-01-01, the format's epoch), UTF-8 names,
+ * deflate where it helps. The same files always give the same bytes, so a
+ * rebuild does not churn the published download.
+ */
+interface ZipEntry {
+    /** Path inside the archive, `/`-separated, no leading slash. */
+    readonly path: string;
+    readonly content: string | Uint8Array;
+}
+declare function zip(entries: readonly ZipEntry[]): Buffer;
+
+export { type ZipEntry, zip };