@stringsync/splates 0.0.0-stage → 0.0.45

package/index-gcfq7awr.js

@@ -0,0 +1,740 @@
+import {
+  LEGACY_PLAN_FILE
+} from "./index-k73tsw5g.js";
+
+// exhibit.ts
+var EXHIBIT = /^### 🖼️?[ \t]+(.+?)[ \t]*$/;
+function exhibitTitle(line) {
+  return EXHIBIT.exec(line)?.[1] ?? null;
+}
+
+// plan.ts
+import { Markdown } from "webappwiz/md";
+var PLAN_FILE = "SPLATES.md";
+
+class Plans {
+  fs;
+  constructor(fs) {
+    this.fs = fs;
+  }
+  read(tree) {
+    return this.fs.read(`${tree}/${PLAN_FILE}`).catch(() => this.fs.read(`${tree}/${LEGACY_PLAN_FILE}`)).catch(() => null);
+  }
+  async exclude(gitDir) {
+    const info = `${gitDir}/info`;
+    const excluded = await this.fs.read(`${info}/exclude`).catch(() => "");
+    if (!excluded.split(`
+`).includes(PLAN_FILE)) {
+      await this.fs.mkdir(info);
+      await this.fs.write(`${info}/exclude`, `${excluded.trimEnd()}
+${PLAN_FILE}
+`.trimStart());
+    }
+  }
+}
+var STUB_STEP = "fill in Goal and list the steps here as `- [ ]` items";
+var SECTIONS = ["Goal", "Done", "Next", "Notes", "Assumptions", "Blocked"];
+var REQUIRED = ["Goal", "Next"];
+var UNCHECKED = /^[ \t]*- \[ \]/m;
+var QUESTION = /^[ \t]*- \[[ xX]\] [Qq]?\d+\./m;
+function goalLine(text) {
+  const md = Markdown.parse(text);
+  if (!md.has("Goal")) {
+    return null;
+  }
+  const line = md.section("Goal").body.split(`
+`).find((line) => line.trim() !== "");
+  return line === undefined ? null : line.trim();
+}
+function goalOf(text) {
+  const md = Markdown.parse(text);
+  return md.has("Goal") ? md.section("Goal").body.trim() : "";
+}
+var ITEM = /^[ \t]*- \[([ xX])\] [Qq]?(\d+)\.[ \t]*(.*)$/;
+var ARROW = " → ";
+var FOLLOW_UP = /^[ \t]+→[ \t]+(.*)$/;
+var CHOICE = /^([ \t]+)- (?:\(([a-z])\)|\[([a-z])\]|([a-z])\.)[ \t]+(.+?)[ \t]*$/;
+var CHOSEN = /[ \t]*\(chosen\)$/i;
+var SIZES = ["small", "medium", "large"];
+var SIZE = /^\(([a-z]+)\)[ \t]+/;
+function sized(text) {
+  const size = SIZE.exec(text);
+  return size === null ? { text, size: null } : { text: text.slice(size[0].length), size: size[1] };
+}
+function questions(text) {
+  return items(sectionLines(text, "Blocked"));
+}
+function assumptions(text) {
+  return items(sectionLines(text, "Assumptions"));
+}
+function items(lines) {
+  const found = [];
+  let last;
+  for (const { line } of lines) {
+    const asked = question(line);
+    if (asked !== null) {
+      last = { asked, body: [] };
+      found.push(last);
+      continue;
+    }
+    if (line.trim() !== "" && !/^[ \t]/.test(line)) {
+      last = undefined;
+    }
+    if (last === undefined) {
+      continue;
+    }
+    const followUp = FOLLOW_UP.exec(line);
+    if (followUp !== null) {
+      last.asked.followUps.push((followUp[1] ?? "").trim());
+    } else if (!offers(last.asked, line)) {
+      last.body.push(line);
+    }
+  }
+  return found.map(({ asked, body }) => settled(asked, body));
+}
+var INDENTS = new WeakMap;
+function offers(asked, line) {
+  const choice = CHOICE.exec(line);
+  if (choice === null) {
+    const last = asked.choices.at(-1);
+    const indent = /^[ \t]*/.exec(line)?.[0].length ?? 0;
+    if (last === undefined || line.trim() === "" || indent <= (INDENTS.get(last) ?? indent)) {
+      return false;
+    }
+    last.body = last.body === "" ? line : `${last.body}
+${line}`;
+    return true;
+  }
+  const [, indent = "", one, any, order, text = ""] = choice;
+  const offered = {
+    key: one ?? any ?? order ?? "",
+    text: text.replace(CHOSEN, ""),
+    body: "",
+    why: "",
+    chosen: CHOSEN.test(text)
+  };
+  INDENTS.set(offered, indent.length);
+  asked.choices.push(offered);
+  asked.pick ??= one !== undefined ? "one" : any !== undefined ? "any" : "order";
+  return true;
+}
+function settled(asked, body) {
+  asked.body = dedent(body);
+  for (const choice of asked.choices) {
+    Object.assign(choice, reasoned(dedent(choice.body.split(`
+`))));
+  }
+  return asked;
+}
+var WHY = /^why:[ \t]*(.*)$/i;
+function reasoned(body) {
+  const lines = body.split(`
+`);
+  const at = lines.findIndex((line) => WHY.test(line));
+  if (at === -1) {
+    return { body, why: "" };
+  }
+  return {
+    body: dedent(lines.filter((_, index) => index !== at)),
+    why: (WHY.exec(lines[at] ?? "")?.[1] ?? "").trim()
+  };
+}
+function dedent(lines) {
+  const indents = lines.filter((line) => line.trim() !== "").map((line) => /^[ \t]*/.exec(line)?.[0].length ?? 0);
+  const cut = indents.length === 0 ? 0 : Math.min(...indents);
+  return lines.map((line) => line.slice(cut).trimEnd()).join(`
+`).replace(/^\n+|\s+$/g, "");
+}
+function picks(text) {
+  const asked = questions(text);
+  const met = asked.map(metPick).filter((each) => each !== null);
+  return {
+    asked: asked.length,
+    picked: met.length,
+    overturned: met.filter((each) => each === "overturned").length,
+    amended: met.filter((each) => each === "amended").length
+  };
+}
+function metPick(asked) {
+  const chosen = asked.choices.find((choice) => choice.chosen);
+  const reply = asked.reply ?? "";
+  const [lead, wrapped, bare] = /^(?:- )?(?:\(([a-z])\)|([a-z])(?=[.,]|$))/i.exec(reply) ?? [];
+  const key = wrapped ?? bare;
+  if (chosen === undefined || key === undefined || asked.pick !== "one") {
+    return null;
+  }
+  if (key.toLowerCase() !== chosen.key) {
+    return "overturned";
+  }
+  return /[a-z0-9]/i.test(reply.slice(lead?.length ?? 0)) || asked.followUps.length > 0 ? "amended" : "kept";
+}
+function decisions(text) {
+  const each = (item, how, ended) => ({
+    number: item.number,
+    text: item.text,
+    size: item.size,
+    how,
+    ended
+  });
+  return [
+    ...assumptions(text).map((item) => each(item, "assumed", "kept")),
+    ...questions(text).map((item) => CHALLENGED.test(item.reply ?? "") ? each(item, "assumed", "challenged") : each(item, "asked", metPick(item)))
+  ].sort((one, other) => Number(one.number) - Number(other.number));
+}
+var CHALLENGED = /^challenged\b/i;
+function assumptionCounts(text) {
+  const challenged = questions(text).filter((each) => CHALLENGED.test(each.reply ?? "")).length;
+  return { made: assumptions(text).length + challenged, challenged };
+}
+var STEP = /^[ \t]*- \[ \][ \t]*(.*)$/;
+function unfinished(text) {
+  const md = Markdown.parse(text);
+  const next = md.has("Next") ? md.section("Next").body.split(`
+`) : [];
+  return {
+    questions: questions(text).filter((asked) => !asked.done).map((asked) => asked.number),
+    steps: next.flatMap((line) => {
+      const step = STEP.exec(line)?.[1];
+      return step === undefined ? [] : [step.trim()];
+    })
+  };
+}
+function ready({ questions, steps }) {
+  return questions.length === 0 && steps.length === 0;
+}
+function whatIsLeft({ questions, steps }) {
+  return [
+    questions.length > 0 ? `questions ${questions.join(", ")} unchecked under ## Blocked` : "",
+    steps.length > 0 ? `${steps.length} step${steps.length === 1 ? "" : "s"} unchecked under ## Next` : ""
+  ].filter(Boolean).join(" and ");
+}
+function question(line) {
+  const item = ITEM.exec(line);
+  if (item === null) {
+    return null;
+  }
+  const [, check = " ", number = "", rest = ""] = item;
+  const arrow = rest.indexOf(ARROW);
+  const { text, size } = sized((arrow === -1 ? rest : rest.slice(0, arrow)).trim());
+  return {
+    number,
+    done: check !== " ",
+    text,
+    size,
+    body: "",
+    reply: arrow === -1 ? null : rest.slice(arrow + ARROW.length).trim(),
+    followUps: [],
+    choices: [],
+    pick: null
+  };
+}
+function sectionLines(text, name) {
+  const { sections } = Markdown.parse(text);
+  const at = sections.findIndex((section) => section.heading.toLowerCase() === name.toLowerCase());
+  const blocked = sections[at];
+  if (blocked === undefined) {
+    return [];
+  }
+  const lines = text.split(`
+`);
+  const end = sections.slice(at + 1).find((later) => later.level <= blocked.level)?.line ?? lines.length + 1;
+  return lines.slice(blocked.line, end - 1).map((line, offset) => ({ index: blocked.line + offset, line }));
+}
+function checkPlan(text, { task, escalated = false, review = false }) {
+  const md = Markdown.parse(text);
+  const problems = [];
+  const section = (name) => md.has(name) ? md.section(name).body : null;
+  if (md.title !== task) {
+    problems.push(md.title === null ? `no title: the first line should be "# ${task}"` : `title is "# ${md.title}", should be "# ${task}"`);
+  }
+  for (const name of REQUIRED) {
+    if (!md.has(name)) {
+      problems.push(`no ## ${name} section`);
+    }
+  }
+  if (section("Goal") === "") {
+    problems.push("## Goal is empty: say in a line or two what done means");
+  }
+  const done = section("Done");
+  if (done !== null && UNCHECKED.test(done)) {
+    problems.push("## Done has a `- [ ]` item: it belongs under ## Next");
+  }
+  const blocked = section("Blocked");
+  if (escalated && !review && blocked === null) {
+    problems.push("escalated with no ## Blocked section: add `- [ ] 1.` items for what the reviewer must do");
+  }
+  if (blocked !== null && !QUESTION.test(blocked)) {
+    problems.push("## Blocked lists nothing: add `- [ ] 1.` items for what the reviewer must do");
+  }
+  const open = questions(text).filter((asked) => !asked.done && asked.reply === null);
+  if (!escalated && open.length > 0) {
+    const numbers = open.map((asked) => asked.number).join(", ");
+    problems.push(`## Blocked has open questions ${numbers}: ask the reviewer before merging`);
+  }
+  for (const assumed of assumptions(text)) {
+    if (!assumed.choices.some((choice) => choice.chosen)) {
+      problems.push(`## Assumptions item ${assumed.number} marks no choice \`(chosen)\`: offer what else it could have been, and mark the one taken`);
+    }
+  }
+  const numbers = [...questions(text), ...assumptions(text)].map((item) => item.number);
+  const twice = [
+    ...new Set(numbers.filter((each, at) => numbers.indexOf(each) !== at))
+  ];
+  if (twice.length > 0) {
+    problems.push(`${twice.join(", ")} numbered twice across ## Assumptions and ## Blocked: a challenged assumption moves to ## Blocked rather than being copied, and new items continue from the highest`);
+  }
+  const known = SECTIONS.map((section) => section.toLowerCase());
+  for (const section of md.sections) {
+    if (section.level === 2 && !known.includes(section.heading.toLowerCase())) {
+      problems.push(`unexpected section "## ${section.heading}" (line ${section.line}): keep to ${SECTIONS.join(", ")}`);
+    }
+  }
+  return problems;
+}
+
+// assumed.ts
+var ASSUMED = /^- Assumed (\d+):[ \t]+(.+?)[ \t]*$/;
+var HEADING = /^#{1,3}[ \t]/;
+var FENCE = /^[ \t]*(```|~~~)/;
+function isAssumed(line) {
+  return ASSUMED.test(line);
+}
+function assumedAt(lines, start) {
+  const assumed = [];
+  let end = start;
+  let exhibit;
+  for (let i = start;i < lines.length; i += 1) {
+    const line = lines[i];
+    const title = exhibitTitle(line);
+    if (title !== null) {
+      const shown = shownEnd(lines, i + 1);
+      if (!ASSUMED.test(lines[shown] ?? "")) {
+        break;
+      }
+      exhibit = { title, body: trimmed(lines.slice(i + 1, shown)) };
+      i = shown - 1;
+      continue;
+    }
+    const said = ASSUMED.exec(line);
+    if (said !== null) {
+      assumed.push({
+        number: said[1],
+        text: said[2],
+        ...exhibit === undefined ? {} : { exhibit }
+      });
+      end = i + 1;
+    } else if (line.trim() !== "") {
+      break;
+    } else {
+      exhibit = undefined;
+    }
+  }
+  return assumed.length === 0 ? null : { assumed, end };
+}
+function shownEnd(lines, start) {
+  let fenced = false;
+  for (let i = start;i < lines.length; i += 1) {
+    const line = lines[i];
+    if (FENCE.test(line)) {
+      fenced = !fenced;
+    } else if (!fenced && (HEADING.test(line) || ASSUMED.test(line))) {
+      return i;
+    }
+  }
+  return lines.length;
+}
+function trimmed(lines) {
+  return lines.join(`
+`).replace(/^\n+|\s+$/g, "");
+}
+
+// demo.ts
+var DEMO = /^### 🎬 Demo(?::[ \t]*(.*?))?[ \t]*$/;
+var STEP2 = /^(\d+)\.[ \t]+(.+)$/;
+function demoAt(lines, start, until) {
+  const title = DEMO.exec(lines[start]);
+  if (title === null) {
+    return null;
+  }
+  const first = lines.findIndex((line, at) => at > start && at < until && STEP2.exec(line)?.[1] === "1");
+  const steps = [];
+  let end = first === -1 ? until : first;
+  if (first !== -1) {
+    let body = [];
+    for (let i = first;i < lines.length; i += 1) {
+      const line = lines[i];
+      const item = STEP2.exec(line);
+      if (item !== null && item[1] === String(steps.length + 1)) {
+        body = [];
+        steps.push({
+          number: item[1],
+          action: (item[2] ?? "").trim(),
+          expect: ""
+        });
+        end = i + 1;
+        continue;
+      }
+      if (line.trim() === "") {
+        continue;
+      }
+      if (!/^[ \t]/.test(line)) {
+        break;
+      }
+      body.push(...lines.slice(end, i).map(() => ""), line);
+      steps.at(-1).expect = dedented(body);
+      end = i + 1;
+    }
+  }
+  return {
+    demo: {
+      title: title[1] || null,
+      intro: trimmed2(lines.slice(start + 1, first === -1 ? until : first)),
+      steps
+    },
+    end
+  };
+}
+function isDemoTitle(line) {
+  return DEMO.test(line);
+}
+function dedented(lines) {
+  const indent = Math.min(...lines.filter((line) => line.trim() !== "").map((line) => /^[ \t]*/.exec(line)?.[0].length ?? 0));
+  return trimmed2(lines.map((line) => line.slice(indent)));
+}
+function trimmed2(lines) {
+  return lines.join(`
+`).replace(/^\n+|\s+$/g, "");
+}
+
+// asked.ts
+function stretches2(text) {
+  const lines = text.split(`
+`);
+  const found = [];
+  let from = 0;
+  let fenced = false;
+  for (let i = 0;i < lines.length; i += 1) {
+    const line = lines[i];
+    if (FENCE2.test(line)) {
+      fenced = !fenced;
+      continue;
+    }
+    if (fenced) {
+      continue;
+    }
+    const title = REVIEW.exec(line);
+    const end = lines.findIndex((each, at) => at > i && each.trim() === REVIEW_END);
+    if (title !== null && end !== -1) {
+      found.push(...prose(lines.slice(from, i)));
+      found.push({
+        type: "review",
+        review: {
+          task: title[1],
+          base: title[2],
+          ...reviewOf(lines.slice(i + 1, end))
+        }
+      });
+      from = end + 1;
+      i = end;
+      continue;
+    }
+    const proposed = PROPOSED.exec(line);
+    if (proposed !== null) {
+      const end = endAt(lines, i + 1);
+      found.push(...prose(lines.slice(from, i)));
+      found.push({
+        type: "proposal",
+        proposal: {
+          subject: proposed[1],
+          body: trimmed3(lines.slice(i + 1, end))
+        }
+      });
+      from = end;
+      i = end - 1;
+      continue;
+    }
+    const demo = demoHere(lines, i);
+    if (demo !== null) {
+      found.push(...prose(lines.slice(from, i)));
+      found.push({ type: "demo", demo: demo.demo });
+      from = demo.end;
+      i = demo.end - 1;
+      continue;
+    }
+    const assumed = assumedAt(lines, i);
+    if (assumed !== null) {
+      found.push(...prose(lines.slice(from, i)));
+      found.push({ type: "assumed", assumed: assumed.assumed });
+      from = assumed.end;
+      i = assumed.end - 1;
+      continue;
+    }
+    const kept = keptAt(lines, i);
+    if (kept !== null) {
+      found.push(...prose(lines.slice(from, i)));
+      found.push(kept.stretch);
+      from = kept.end;
+      i = kept.end - 1;
+      continue;
+    }
+    if (ITEM2.exec(line)?.[1] !== "1") {
+      continue;
+    }
+    const list = listAt(lines, i);
+    if (list === null) {
+      continue;
+    }
+    found.push(...prose(lines.slice(from, i)));
+    found.push({ type: "questions", questions: list.questions });
+    from = list.end;
+    i = list.end - 1;
+  }
+  found.push(...prose(lines.slice(from)));
+  return found;
+}
+var ASKS = /\?(?:[ \t]+\([^()]*\))?$/;
+var ASKS_THEN = /^(.*?\?(?:[ \t]+\([^()]*\))?)[ \t]+(\S.*)$/;
+var MERGED = /^## ✅ Merged (\S+) onto (\S+)[ \t]*$/;
+var ENDED = /^## (?:(🛑) Removed|⚠\uFE0F? Escalated) (\S+?)(?::[ \t]*(.*?))?[ \t]*$/;
+var FINISHED = /^## 🏁 Finished lanes? (.*?)[ \t]*$/;
+var WAITING = /^## ⏸\uFE0F? Waiting lanes? (.*?)(?::[ \t]*(.*?))?[ \t]*$/;
+var WORKING = /^## ⏳ Working lanes? (.*?)(?::[ \t]*(.*?))?[ \t]*$/;
+var WORKING_TASK = /^## ⏳ Working (\S+?)(?::[ \t]*(.*?))?[ \t]*$/;
+var HANDED = /^## 🤝 Handed off (\S+) to (.+?)(?::[ \t]*(.*?))?[ \t]*$/;
+var STARTED = /^## 🌱 Started lanes? (.*?)[ \t]*$/;
+var PROPOSAL = /^### 📝 (.+?) \[#(\d+)\][ \t]*$/;
+var HEADING2 = /^#{1,3}[ \t]/;
+var REVIEW = /^## 🔍 Ready to merge (\S+) onto (\S+)[ \t]*$/;
+var REVIEW_END = 'Reply "merge", or say what to change.';
+var PROPOSED = /^## 💡 Proposed (.+?)[ \t]*$/;
+var CHECKS = /^Checks:[ \t]*(.*)$/;
+var FAILED = /^Failed:[ \t]*(.*)$/;
+var ITEM2 = /^(\d+)\.[ \t]+(.+)$/;
+var FENCE2 = /^[ \t]*(```|~~~)/;
+function keptAt(lines, start) {
+  const line = lines[start];
+  const merged = MERGED.exec(line);
+  const ended = ENDED.exec(line);
+  const finished = FINISHED.exec(line);
+  const waiting = WAITING.exec(line);
+  const working = WORKING.exec(line);
+  const workingTask = working === null ? WORKING_TASK.exec(line) : null;
+  const handed = HANDED.exec(line);
+  const started = STARTED.exec(line);
+  const proposed = PROPOSAL.exec(line);
+  if (merged === null && ended === null && finished === null && waiting === null && working === null && workingTask === null && handed === null && started === null && proposed === null) {
+    return null;
+  }
+  const end = proposed !== null ? paragraphEnd(lines, start + 1, endAt(lines, start + 1)) : endAt(lines, start + 1);
+  const body = lines.slice(start + 1, end).join(`
+`).replace(/^\n+|\s+$/g, "");
+  if (started !== null) {
+    return {
+      stretch: {
+        type: "start",
+        start: { lanes: lanesOf(started[1]), goal: body }
+      },
+      end
+    };
+  }
+  if (proposed !== null) {
+    return {
+      stretch: {
+        type: "todo",
+        todo: {
+          id: Number(proposed[2]),
+          subject: proposed[1],
+          body
+        }
+      },
+      end
+    };
+  }
+  const source = lines.slice(start, end).join(`
+`).replace(/\s+$/, "");
+  const report = finished !== null ? {
+    ending: "finished",
+    lanes: lanesOf(finished[1]),
+    reason: null,
+    body,
+    source
+  } : waiting !== null || working !== null ? {
+    ending: waiting !== null ? "waiting" : "working",
+    lanes: lanesOf((waiting ?? working)?.[1]),
+    reason: (waiting ?? working)?.[2] || null,
+    body,
+    source
+  } : merged !== null ? {
+    ending: "merged",
+    task: merged[1],
+    base: merged[2],
+    to: null,
+    reason: null,
+    body,
+    source
+  } : workingTask !== null ? {
+    ending: "working",
+    task: workingTask[1],
+    base: null,
+    to: null,
+    reason: workingTask[2] || null,
+    body,
+    source
+  } : handed !== null ? {
+    ending: "handed",
+    task: handed[1],
+    base: null,
+    to: handed[2],
+    reason: handed[3] || null,
+    body,
+    source
+  } : {
+    ending: ended?.[1] === undefined ? "escalated" : "removed",
+    task: ended?.[2],
+    base: null,
+    to: null,
+    reason: ended?.[3] || null,
+    body,
+    source
+  };
+  return { stretch: { type: "report", report }, end };
+}
+function lanesOf(listed) {
+  return listed.split(",").map((lane) => lane.trim()).filter((lane) => lane !== "");
+}
+function reviewOf(lines) {
+  const { body, demo } = withDemo(lines);
+  let rest = body.split(`
+`);
+  const named = (line) => {
+    const at = rest.findIndex((said) => line.test(said));
+    if (at === -1) {
+      return [];
+    }
+    const found = Array.from(rest[at].matchAll(/`([^`]+)`/g), (code) => code[1]);
+    rest = rest.toSpliced(at, rest[at + 1]?.trim() === "" ? 2 : 1);
+    return found;
+  };
+  const checks = named(CHECKS);
+  const failed = named(FAILED);
+  const gap = rest.findIndex((line) => line.trim() === "");
+  return {
+    summary: trimmed3(gap === -1 ? rest : rest.slice(0, gap)),
+    demo,
+    checks,
+    failed,
+    details: gap === -1 ? "" : trimmed3(rest.slice(gap))
+  };
+}
+function withDemo(lines) {
+  const at = lines.findIndex((_, index) => demoHere(lines, index) !== null);
+  const found = at === -1 ? null : demoHere(lines, at);
+  if (found === null) {
+    return { body: trimmed3(lines), demo: null };
+  }
+  return {
+    body: trimmed3([...lines.slice(0, at), ...lines.slice(found.end)]),
+    demo: found.demo
+  };
+}
+function demoHere(lines, start) {
+  return isDemoTitle(lines[start]) ? demoAt(lines, start, endAt(lines, start + 1)) : null;
+}
+function trimmed3(lines) {
+  return lines.join(`
+`).replace(/^\n+|\s+$/g, "");
+}
+function paragraphEnd(lines, start, end) {
+  let begun = false;
+  let fenced = false;
+  for (let i = start;i < end; i += 1) {
+    const line = lines[i];
+    if (FENCE2.test(line)) {
+      fenced = !fenced;
+    }
+    if (line.trim() !== "") {
+      begun = true;
+    } else if (begun && !fenced) {
+      return i;
+    }
+  }
+  return end;
+}
+function endAt(lines, start) {
+  let fenced = false;
+  for (let i = start;i < lines.length; i += 1) {
+    const line = lines[i];
+    if (FENCE2.test(line)) {
+      fenced = !fenced;
+      continue;
+    }
+    if (!fenced && (HEADING2.test(line) || isAssumed(line) || ITEM2.exec(line)?.[1] === "1" && listAt(lines, i) !== null)) {
+      return i;
+    }
+  }
+  return lines.length;
+}
+function listAt(lines, start) {
+  const items = [];
+  let end = start;
+  for (let i = start;i < lines.length; i += 1) {
+    const line = lines[i];
+    const item = ITEM2.exec(line);
+    if (item !== null && item[1] === String(items.length + 1)) {
+      items.push({ asked: question2(item[1], item[2] ?? ""), body: [] });
+      end = i + 1;
+      continue;
+    }
+    if (line.trim() === "") {
+      continue;
+    }
+    if (!/^[ \t]/.test(line)) {
+      break;
+    }
+    const last = items.at(-1);
+    last.body.push(...lines.slice(end, i).map(() => ""));
+    if (!offers(last.asked, line)) {
+      last.body.push(line);
+    }
+    end = i + 1;
+  }
+  if (!items.every(asks)) {
+    return null;
+  }
+  return {
+    questions: items.map(({ asked, body }) => settled(asked, body)),
+    end
+  };
+}
+function asks({ asked, body }) {
+  if (ASKS.test(asked.text)) {
+    return true;
+  }
+  const then = ASKS_THEN.exec(asked.text);
+  if (then !== null) {
+    asked.text = then[1];
+    const indent = /^[ \t]*/.exec(body.find((line) => line.trim()) ?? "");
+    body.unshift(`${indent?.[0] ?? ""}${then[2]}`);
+    return true;
+  }
+  return asked.choices.length > 0;
+}
+function question2(number, line) {
+  return {
+    number,
+    done: false,
+    ...sized(line.trim()),
+    body: "",
+    reply: null,
+    followUps: [],
+    choices: [],
+    pick: null
+  };
+}
+function prose(lines) {
+  const text = lines.join(`
+`).replace(/^\n+|\s+$/g, "");
+  return text === "" ? [] : [{ type: "text", text }];
+}
+
+export { PLAN_FILE, Plans, STUB_STEP, goalLine, goalOf, SIZES, questions, picks, decisions, assumptionCounts, unfinished, ready, whatIsLeft, checkPlan, stretches2 };