token-goat 2.9.29 → 2.9.31

package/dist/token-goat-chunk-OXFMP75N.mjs

@@ -0,0 +1,566 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  eachUnfencedLine,
+  frontMatterEndIndex,
+  lineOpenDelimiterAfter,
+  stripTomlComment,
+  tomlBracketDelta,
+  yamlLineClosesQuote,
+  yamlOpenQuoteAfter
+} from "./token-goat-chunk-NISNMD7T.mjs";
+import {
+  ATX_CLASS_BREAK_RE,
+  matchAtxHeading,
+  matchRuleBannerTitle,
+  matchTableHeaderName
+} from "./token-goat-chunk-EVMZJ27Z.mjs";
+import {
+  _detectOpenQuote,
+  _lineClosesQuote,
+  detectLanguage,
+  redactIfDotenv,
+  refineLanguageByContent
+} from "./token-goat-chunk-GVB2MUST.mjs";
+import {
+  buildLineIndex,
+  findHtmlHeadingMatches,
+  offsetToLine
+} from "./token-goat-chunk-OUKDTVNU.mjs";
+import {
+  decodeSource
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/section_reader.ts
+init_define_import_meta_env();
+import { readFileSync } from "node:fs";
+function parseHeadingSpec(spec, headers) {
+  const m = /^([^#\r\n]+)#(\d+)$/.exec(spec);
+  if (m !== null && m[1] !== void 0 && m[2] !== void 0) {
+    const specLower = spec.trim().toLowerCase();
+    const isLiteralHeading = headers?.some((h) => h.heading.trim().toLowerCase() === specLower) ?? false;
+    if (isLiteralHeading) {
+      return { base: spec.trim(), ordinal: null };
+    }
+    return { base: m[1].trim(), ordinal: Number.parseInt(m[2], 10) };
+  }
+  return { base: spec.trim(), ordinal: null };
+}
+function normalizeHeading(s) {
+  let n = s.replace(/[—–]/g, "-");
+  n = n.replace(/\s*\([^)]+\)\s*$/, "");
+  n = n.replace(/^\d+\.\s+/, "");
+  return n.replace(/\s+/g, " ").trim();
+}
+function normalizeHeadingStrip(s) {
+  let n = s.replace(/\s*[—–].*$/, "");
+  n = n.replace(/\s*\([^)]+\)\s*$/, "");
+  n = n.replace(/^\d+\.\s+/, "");
+  return n.replace(/\s+/g, " ").trim();
+}
+var MIN_WIDEN_WORD_LEN = 3;
+var PYTHON_HEADER_RE = /^(\s*)(?:async\s+)?(?:def|class)\s+([A-Za-z_]\w*)/;
+var KEYVALUE_HEADER_RE = /^([A-Za-z_][\w.-]*)\s*(?:=|:(?!\/\/))/;
+var ENV_KEYVALUE_HEADER_RE = /^(?:export\s+)?([A-Za-z_][\w.-]*)\s*(?:=|:(?!\/\/))/;
+function findMarkdownHeaders(lines) {
+  const headers = [];
+  const fmEnd = frontMatterEndIndex(lines);
+  const unfenced = Array.from(eachUnfencedLine(lines)).filter(([i]) => i >= fmEnd);
+  let paraStart = -1;
+  for (let u = 0; u < unfenced.length; u++) {
+    const [i, line] = unfenced[u];
+    const atx = matchAtxHeading(line, ATX_CLASS_BREAK_RE, true);
+    if (atx !== null) {
+      headers.push({ heading: atx.name, level: atx.level, index: i });
+      paraStart = -1;
+      continue;
+    }
+    if (paraStart !== -1 && i !== unfenced[u - 1][0] + 1) paraStart = -1;
+    const trimmed = line.trim();
+    if (paraStart !== -1 && /^(=+|-+)$/.test(trimmed)) {
+      const heading = unfenced.slice(paraStart, u).map(([, text]) => text.trim()).join(" ");
+      headers.push({ heading, level: trimmed.startsWith("=") ? 1 : 2, index: unfenced[paraStart][0] });
+      paraStart = -1;
+      continue;
+    }
+    const isText = trimmed !== "" && !trimmed.startsWith("#") && !trimmed.startsWith("|") && !trimmed.startsWith("```") && !trimmed.startsWith("~~~") && !/^([-*+]|\d+\.)\s/.test(trimmed) && !/^(=+|-+)$/.test(trimmed);
+    if (!isText) paraStart = -1;
+    else if (paraStart === -1) paraStart = u;
+  }
+  return headers;
+}
+function findTableHeaders(lines, isToml) {
+  const headers = [];
+  let openDelim = null;
+  let arrayDepth = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    if (openDelim !== null) {
+      const closeIdx = line.indexOf(openDelim);
+      if (closeIdx === -1) continue;
+      const restStart = closeIdx + openDelim.length;
+      const name2 = matchTableHeaderName(line.slice(restStart));
+      if (name2 !== null) headers.push({ heading: name2.trim(), level: 1, index: i });
+      openDelim = lineOpenDelimiterAfter(stripTomlComment(line.slice(restStart)), 0);
+      continue;
+    }
+    if (isToml && arrayDepth > 0) {
+      arrayDepth = Math.max(0, arrayDepth + tomlBracketDelta(stripTomlComment(line)));
+      continue;
+    }
+    const name = matchTableHeaderName(line);
+    if (name !== null) headers.push({ heading: name.trim(), level: 1, index: i });
+    if (isToml) {
+      const code = stripTomlComment(line);
+      openDelim = lineOpenDelimiterAfter(code, 0);
+      if (openDelim === null) arrayDepth = Math.max(0, tomlBracketDelta(code));
+    }
+  }
+  return headers;
+}
+var VB_REGION_RE = /^\s*#\s*Region\s+"((?:[^"]|"")*)"/i;
+var VB_END_REGION_RE = /^\s*#\s*End\s+Region\b/i;
+function extractShellBannerHeading(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("#")) return null;
+  if (trimmed.startsWith("#!")) return null;
+  const mdMatch = /^(#{2,6})[^\S\r\n]+(\S(?:.*?\S)?)(?:[^\S\r\n]+#+)?$/.exec(trimmed);
+  if (mdMatch && mdMatch[1] && mdMatch[2]) {
+    const text = mdMatch[2].trim();
+    if (text && !/^[-=]+$/.test(text)) {
+      return { heading: text, level: mdMatch[1].length };
+    }
+  }
+  const ruleTitle = matchRuleBannerTitle(trimmed);
+  if (ruleTitle) {
+    const text = ruleTitle.trim();
+    if (text && !/^[-=]+$/.test(text)) {
+      return { heading: text, level: 1 };
+    }
+  }
+  const bracketMatch = /^#\s*\[([a-zA-Z0-9_.\-\s]+)\]$/.exec(trimmed);
+  if (bracketMatch && bracketMatch[1]) {
+    const text = bracketMatch[1].trim();
+    if (text) {
+      return { heading: text, level: 1 };
+    }
+  }
+  const regionMatch = /^#\s*(?:REGION|SECTION):\s*(\S.*)$/i.exec(trimmed);
+  if (regionMatch && regionMatch[1]) {
+    const text = regionMatch[1].trim();
+    if (text) {
+      return { heading: text, level: 1 };
+    }
+  }
+  return null;
+}
+function findShellBannerHeaders(lines) {
+  const headers = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const banner = extractShellBannerHeading(line);
+    if (banner !== null) {
+      headers.push({ heading: banner.heading, level: banner.level, index: i });
+    }
+  }
+  return headers;
+}
+function findVbRegionHeaders(lines) {
+  const headers = [];
+  const open = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const m = VB_REGION_RE.exec(line);
+    if (m !== null) {
+      open.push(headers.length);
+      headers.push({ heading: (m[1] ?? "").replace(/""/g, '"'), level: open.length, index: i });
+      continue;
+    }
+    if (VB_END_REGION_RE.test(line)) {
+      const pos = open.pop();
+      const h = pos === void 0 ? void 0 : headers[pos];
+      if (pos !== void 0 && h !== void 0) headers[pos] = { ...h, endIndex: i + 1 };
+    }
+  }
+  return headers;
+}
+function headerEndIndex(headers, kind, headerPos, totalLines) {
+  const explicit = headers[headerPos]?.endIndex;
+  if (explicit !== void 0) return explicit;
+  return kind === "table-toml" ? tableSectionEndIndex(headers, headerPos, totalLines) : sectionEndIndex(headers, headerPos, totalLines);
+}
+function findPythonHeaders(lines) {
+  const headers = [];
+  const indentStack = [];
+  let openDelim = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    if (openDelim !== null) {
+      const closeIdx = line.indexOf(openDelim);
+      if (closeIdx === -1) continue;
+      openDelim = lineOpenDelimiterAfter(line, closeIdx + openDelim.length);
+      continue;
+    }
+    const m = PYTHON_HEADER_RE.exec(line);
+    if (m === null || m[1] === void 0 || m[2] === void 0) {
+      openDelim = lineOpenDelimiterAfter(line, 0);
+      continue;
+    }
+    const indent = m[1].replace(/\t/g, "    ").length;
+    while (indentStack.length > 0 && indent <= (indentStack[indentStack.length - 1] ?? -1)) {
+      indentStack.pop();
+    }
+    const level = indentStack.length + 1;
+    indentStack.push(indent);
+    headers.push({ heading: m[2], level, index: i });
+    openDelim = lineOpenDelimiterAfter(line, 0);
+  }
+  return headers;
+}
+function findKeyValueHeaders(lines, language) {
+  const headers = [];
+  const isEnv = language === "env_file";
+  let openQuote = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    if (openQuote !== null) {
+      const closed = isEnv ? _lineClosesQuote(line, openQuote) : yamlLineClosesQuote(line, openQuote);
+      if (closed) openQuote = null;
+      continue;
+    }
+    const scanned = isEnv ? line.replace(/^[ \t]+/, "") : line;
+    const m = (isEnv ? ENV_KEYVALUE_HEADER_RE : KEYVALUE_HEADER_RE).exec(scanned);
+    if (m === null || m[1] === void 0) continue;
+    headers.push({ heading: m[1], level: 1, index: i });
+    openQuote = isEnv ? _detectOpenQuote(scanned.slice(m[0].length)) : yamlOpenQuoteAfter(line, m[0].length);
+  }
+  return headers;
+}
+function findHtmlHeaders(text) {
+  const lineIndex = buildLineIndex(text);
+  const headers = [];
+  for (const hm of findHtmlHeadingMatches(text)) {
+    if (!hm.heading) continue;
+    const index = offsetToLine(lineIndex, hm.offset) - 1;
+    headers.push({ heading: hm.heading, level: hm.level, index });
+  }
+  return headers;
+}
+function findHeaders(text, language) {
+  const lines = text.split("\n");
+  if (language === "markdown") return { headers: findMarkdownHeaders(lines), kind: "markdown" };
+  if (language === "html" || language === "liquid") return { headers: findHtmlHeaders(text), kind: "markdown" };
+  if (language === "toml") return { headers: findTableHeaders(lines, true), kind: "table-toml" };
+  if (language === "python") return { headers: findPythonHeaders(lines), kind: "python" };
+  if (language === "bash") {
+    const banners = findShellBannerHeaders(lines);
+    if (banners.length > 0) return { headers: banners, kind: "banner" };
+  }
+  if (language === "vb") return { headers: findVbRegionHeaders(lines), kind: "region" };
+  if (language === "ini") return { headers: findTableHeaders(lines, false), kind: "table-flat" };
+  if (language === "yaml" || language === "env_file")
+    return { headers: findKeyValueHeaders(lines, language), kind: "keyvalue" };
+  const md = findMarkdownHeaders(lines);
+  if (md.length > 0) return { headers: md, kind: "markdown" };
+  const tbl = findTableHeaders(lines, false);
+  if (tbl.length > 0) return { headers: tbl, kind: "table-toml" };
+  return { headers: findKeyValueHeaders(lines, language), kind: "keyvalue" };
+}
+function sectionEndIndex(headers, headerPos, totalLines) {
+  const current = headers[headerPos];
+  if (current === void 0) return totalLines;
+  for (let j = headerPos + 1; j < headers.length; j++) {
+    const next = headers[j];
+    if (next === void 0) continue;
+    if (next.level <= current.level) return next.index;
+  }
+  return totalLines;
+}
+function tableSectionEndIndex(headers, headerPos, totalLines) {
+  const current = headers[headerPos];
+  if (current === void 0) return totalLines;
+  const prefix = current.heading + ".";
+  for (let j = headerPos + 1; j < headers.length; j++) {
+    const next = headers[j];
+    if (next === void 0) continue;
+    if (next.heading.startsWith(prefix)) continue;
+    return next.index;
+  }
+  return totalLines;
+}
+function resolveHeaderPos(headers, base, ordinal, allowFuzzy = true) {
+  const target = base.toLowerCase();
+  const normalizedTarget = normalizeHeading(base).toLowerCase();
+  const strippedTarget = normalizeHeadingStrip(base).toLowerCase();
+  const exactMatches = [];
+  const normalizedMatches = [];
+  const strippedMatches = [];
+  for (let i = 0; i < headers.length; i++) {
+    const h = headers[i];
+    if (h === void 0) continue;
+    const headingLower = h.heading.toLowerCase();
+    if (headingLower === target) {
+      exactMatches.push(i);
+    } else if (normalizeHeading(h.heading).toLowerCase() === normalizedTarget) {
+      normalizedMatches.push(i);
+    } else if (normalizeHeadingStrip(h.heading).toLowerCase() === strippedTarget) {
+      strippedMatches.push(i);
+    }
+  }
+  const matches = exactMatches.length > 0 ? exactMatches : normalizedMatches.length > 0 ? normalizedMatches : strippedMatches;
+  if (matches.length > 0) {
+    const pick = ordinal === null ? 0 : ordinal - 1;
+    const headerPos = matches[pick];
+    if (headerPos === void 0) return null;
+    let occurrences = null;
+    if (ordinal === null && matches.length > 1) {
+      occurrences = [];
+      for (const i of matches) {
+        const h = headers[i];
+        if (h !== void 0) occurrences.push(h.index + 1);
+      }
+    }
+    return { headerPos, redirectedFrom: null, occurrences };
+  }
+  if (ordinal !== null || normalizedTarget.length === 0) return null;
+  let prefixPos = -1;
+  const distinct = /* @__PURE__ */ new Set();
+  for (let i = 0; i < headers.length; i++) {
+    const h = headers[i];
+    if (h === void 0) continue;
+    const norm = normalizeHeading(h.heading).toLowerCase();
+    if (norm.startsWith(normalizedTarget)) {
+      distinct.add(norm);
+      if (prefixPos === -1) prefixPos = i;
+    }
+  }
+  if (distinct.size === 1 && prefixPos !== -1) {
+    const chosen = headers[prefixPos];
+    if (chosen === void 0) return null;
+    return { headerPos: prefixPos, redirectedFrom: base, occurrences: null };
+  }
+  const queryWords = normalizedTarget.split(/\s+/).filter((w) => w.length >= MIN_WIDEN_WORD_LEN);
+  if (queryWords.length === 0) return null;
+  const widenedMatches = [];
+  for (let i = 0; i < headers.length; i++) {
+    const h = headers[i];
+    if (h === void 0) continue;
+    const headingWords = normalizeHeading(h.heading).toLowerCase().split(/\s+/);
+    const allWordsMatch = queryWords.every((qw) => headingWords.some((hw) => hw.includes(qw)));
+    if (allWordsMatch) widenedMatches.push(i);
+  }
+  if (widenedMatches.length === 1) {
+    const widenedPos = widenedMatches[0];
+    if (widenedPos !== void 0) {
+      return { headerPos: widenedPos, redirectedFrom: base, occurrences: null };
+    }
+  }
+  function sectionLevenshtein(a, b) {
+    if (a === b) return 0;
+    const la = a.length;
+    const lb = b.length;
+    if (la === 0) return lb;
+    if (lb === 0) return la;
+    const v0 = new Array(lb + 1);
+    const v1 = new Array(lb + 1);
+    for (let i = 0; i <= lb; i++) v0[i] = i;
+    for (let i = 0; i < la; i++) {
+      v1[0] = i + 1;
+      for (let j = 0; j < lb; j++) {
+        const cost = a.charCodeAt(i) === b.charCodeAt(j) ? 0 : 1;
+        v1[j + 1] = Math.min(v1[j] + 1, v0[j + 1] + 1, v0[j] + cost);
+      }
+      for (let j = 0; j <= lb; j++) v0[j] = v1[j];
+    }
+    return v0[lb];
+  }
+  const STOP_WORDS = /* @__PURE__ */ new Set(["a", "an", "the", "and", "or", "in", "on", "at", "to", "for", "of", "with", "by", "is", "&"]);
+  const cleanTokens = (str) => str.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 0);
+  const rawQTokens = cleanTokens(base);
+  const qTokens = rawQTokens.filter((t) => !STOP_WORDS.has(t) || rawQTokens.length <= 2);
+  if (allowFuzzy && qTokens.length > 0) {
+    const candidates = [];
+    for (let i = 0; i < headers.length; i++) {
+      const h = headers[i];
+      if (h === void 0) continue;
+      const rawHTokens = cleanTokens(h.heading);
+      const hTokens = rawHTokens.filter((t) => !STOP_WORDS.has(t) || rawHTokens.length <= 2);
+      if (hTokens.length === 0) continue;
+      const normH = normalizeHeading(h.heading).toLowerCase();
+      const maxLen = Math.max(normalizedTarget.length, normH.length);
+      const editDist = sectionLevenshtein(normalizedTarget, normH);
+      const strSim = maxLen > 0 ? 1 - editDist / maxLen : 0;
+      let matchedQ = 0;
+      for (const qw of qTokens) {
+        let best = 0;
+        for (const hw of hTokens) {
+          if (qw === hw) {
+            best = 1;
+            break;
+          }
+          if (qw.length >= 3 && hw.length >= 3) {
+            if (hw.startsWith(qw) || qw.startsWith(hw)) {
+              best = Math.max(best, 0.9);
+            } else if (sectionLevenshtein(qw, hw) <= 1) {
+              best = Math.max(best, 0.85);
+            }
+          }
+        }
+        matchedQ += best;
+      }
+      let matchedH = 0;
+      for (const hw of hTokens) {
+        let best = 0;
+        for (const qw of qTokens) {
+          if (qw === hw) {
+            best = 1;
+            break;
+          }
+          if (qw.length >= 3 && hw.length >= 3) {
+            if (hw.startsWith(qw) || qw.startsWith(hw)) {
+              best = Math.max(best, 0.9);
+            } else if (sectionLevenshtein(qw, hw) <= 1) {
+              best = Math.max(best, 0.85);
+            }
+          }
+        }
+        matchedH += best;
+      }
+      const wordRecall = matchedQ / qTokens.length;
+      const wordPrecision = matchedH / hTokens.length;
+      const tokenDice = 2 * matchedQ / (qTokens.length + hTokens.length);
+      let score = 0;
+      if (strSim >= 0.8) {
+        score = strSim;
+      } else if (tokenDice >= 0.75 && wordRecall >= 0.7 && wordPrecision >= 0.7) {
+        score = (tokenDice + wordRecall + wordPrecision) / 3;
+      }
+      if (score >= 0.75) {
+        candidates.push({ index: i, score });
+      }
+    }
+    if (candidates.length > 0) {
+      candidates.sort((a, b) => b.score - a.score);
+      const best = candidates[0];
+      const runnerUp = candidates[1];
+      if (candidates.length === 1 || runnerUp !== void 0 && best.score - runnerUp.score >= 0.08) {
+        return { headerPos: best.index, redirectedFrom: base, occurrences: null };
+      }
+    }
+  }
+  return null;
+}
+function buildSectionResult(headers, kind, lines, headerPos, redirectedFrom) {
+  const header = headers[headerPos];
+  if (header === void 0) return null;
+  const endIndex = headerEndIndex(headers, kind, headerPos, lines.length);
+  let endExclusive = endIndex;
+  while (endExclusive > header.index + 1 && (lines[endExclusive - 1] === "" || lines[endExclusive - 1] === "\r")) {
+    endExclusive--;
+  }
+  const content = lines.slice(header.index, endExclusive).join("\n");
+  const result = {
+    heading: header.heading,
+    content,
+    lineStart: header.index + 1,
+    lineEnd: endExclusive
+  };
+  return redirectedFrom === null ? result : { ...result, redirectedFrom };
+}
+function resolveSectionFromText(text, headingSpec, language, allowFuzzy = true) {
+  const { headers, kind } = findHeaders(text, language);
+  const { base, ordinal } = parseHeadingSpec(headingSpec, headers);
+  if (base.length === 0) return null;
+  const lines = text.split("\n");
+  const resolved = resolveHeaderPos(headers, base, ordinal, allowFuzzy);
+  if (resolved === null) return null;
+  const built = buildSectionResult(headers, kind, lines, resolved.headerPos, resolved.redirectedFrom);
+  if (built === null || resolved.occurrences === null) return built;
+  return { ...built, occurrences: resolved.occurrences };
+}
+function extractSection(text, headingSpec) {
+  return resolveSectionFromText(text, headingSpec, "unknown");
+}
+function readTextForSections(filePath, readFn) {
+  let text;
+  if (readFn !== void 0) {
+    const read = readFn(filePath);
+    if (read === null) return null;
+    text = read;
+  } else {
+    try {
+      text = decodeSource(readFileSync(filePath));
+    } catch {
+      return null;
+    }
+  }
+  if (text.charCodeAt(0) === 65279) {
+    text = text.slice(1);
+  }
+  return redactIfDotenv(filePath, text);
+}
+function readSection(filePath, headingSpec, readFn, allowFuzzy = true) {
+  const text = readTextForSections(filePath, readFn);
+  if (text === null) return null;
+  return resolveSectionFromText(text, headingSpec, refineLanguageByContent(filePath, detectLanguage(filePath), text), allowFuzzy);
+}
+function findContainingSection(filePath, lineStart, lineEnd, readFn) {
+  const text = readTextForSections(filePath, readFn);
+  if (text === null) return null;
+  const language = refineLanguageByContent(filePath, detectLanguage(filePath), text);
+  const { headers, kind } = findHeaders(text, language);
+  if (headers.length === 0) return null;
+  const lines = text.split("\n");
+  let bestPos = -1;
+  let bestHeaderLine = -1;
+  for (let i = 0; i < headers.length; i++) {
+    const header = headers[i];
+    if (header === void 0) continue;
+    const endIndex = headerEndIndex(headers, kind, i, lines.length);
+    const sectionLineStart = header.index + 1;
+    if (sectionLineStart <= lineStart && lineEnd <= endIndex) {
+      if (header.index > bestHeaderLine) {
+        bestHeaderLine = header.index;
+        bestPos = i;
+      }
+    }
+  }
+  if (bestPos === -1) return null;
+  const result = buildSectionResult(headers, kind, lines, bestPos, null);
+  if (result === null) return null;
+  const bestHeader = headers[bestPos];
+  if (bestHeader === void 0) return result;
+  const target = bestHeader.heading.toLowerCase();
+  const matches = [];
+  for (let i = 0; i < headers.length; i++) {
+    const h = headers[i];
+    if (h !== void 0 && h.heading.toLowerCase() === target) matches.push(i);
+  }
+  if (matches.length <= 1) return result;
+  const ordinal = matches.indexOf(bestPos) + 1;
+  return { ...result, heading: `${bestHeader.heading}#${ordinal}` };
+}
+function listSections(filePath, readFn) {
+  const text = readTextForSections(filePath, readFn);
+  if (text === null) return [];
+  const language = refineLanguageByContent(filePath, detectLanguage(filePath), text);
+  const { headers } = findHeaders(text, language);
+  return headers.map((h) => h.heading);
+}
+
+export {
+  normalizeHeading,
+  findMarkdownHeaders,
+  extractShellBannerHeading,
+  findShellBannerHeaders,
+  extractSection,
+  readSection,
+  findContainingSection,
+  listSections
+};

package/dist/{token-goat-chunk-ASLWOQ3I.mjs → token-goat-chunk-OYIYKDDT.mjs}

@@ -4,8 +4,9 @@ import {
   serveBatch,
   serveOne,
   swapEnv
-} from "./token-goat-chunk-S4VSXURL.mjs";
+} from "./token-goat-chunk-XRKUX6CM.mjs";
 import "./token-goat-chunk-YZAAZU2S.mjs";
+import "./token-goat-chunk-CO3UYX6G.mjs";
 import "./token-goat-chunk-A37V4PBF.mjs";
 export {
   serveBatch,