@sutrata/editor 0.1.0 → 0.1.2

package/src/file/docx-importer.ts

@@ -1,313 +0,0 @@
-import JSZip from 'jszip'
-
-const W_NS = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main'
-
-/** Paragraph styles produced by docx-exporter.ts that mark actual screenplay body content
- *  (as opposed to the free-form title-page paragraphs, which carry no style, or CineTitle /
- *  CineAuthor / CineLogline, which belong to the title page and are not reimported here). */
-const BODY_STYLES = new Set([
-  'CineSceneHeading', 'CineSection', 'CineAction', 'CineCharacter',
-  'CineParenthetical', 'CineDialogue', 'CineTransition', 'CineCentered',
-  'CineLyrics', 'CineNote', 'CineComment',
-])
-
-interface RunFlags {
-  bold: boolean
-  italic: boolean
-  underline: boolean
-}
-
-interface ParsedParagraph {
-  style: string | null
-  text: string
-  runs: (RunFlags & { text: string })[]
-  isPageBreak: boolean
-}
-
-interface ParsedTable {
-  cells: ParsedParagraph[][]
-}
-
-type BodyItem = { kind: 'para'; para: ParsedParagraph } | { kind: 'table'; table: ParsedTable }
-
-export interface DocxImportResult {
-  /** Reconstructed Sutra body text (no frontmatter), or null if nothing importable was found. */
-  bodyText: string | null
-  warnings: string[]
-}
-
-function attrVal(el: Element, tag: string): string | null {
-  const child = el.getElementsByTagNameNS(W_NS, tag)[0]
-  if (!child) return null
-  const val = child.getAttributeNS(W_NS, 'val')
-  return val
-}
-
-function flagOn(el: Element, tag: string): boolean {
-  const child = el.getElementsByTagNameNS(W_NS, tag)[0]
-  if (!child) return false
-  const val = child.getAttributeNS(W_NS, 'val')
-  if (val === null) return true
-  return !['false', '0', 'off', 'none'].includes(val.toLowerCase())
-}
-
-function parseParagraph(p: Element): ParsedParagraph {
-  let style: string | null = null
-  const runs: (RunFlags & { text: string })[] = []
-  let isPageBreak = false
-
-  for (const child of Array.from(p.children)) {
-    if (child.localName === 'pPr') {
-      style = attrVal(child, 'pStyle')
-      continue
-    }
-    if (child.localName === 'r') {
-      const rPr = child.getElementsByTagNameNS(W_NS, 'rPr')[0]
-      const bold = !!rPr && flagOn(rPr, 'b')
-      const italic = !!rPr && flagOn(rPr, 'i')
-      const underline = !!rPr && flagOn(rPr, 'u')
-      let text = ''
-      for (const rc of Array.from(child.children)) {
-        if (rc.localName === 't') text += rc.textContent ?? ''
-        // Word normalizes a literal tab character inside <w:t> (what docx.js emits) into a
-        // <w:tab/> element when it resaves the file — recognize both forms.
-        else if (rc.localName === 'tab') text += '\t'
-        else if (rc.localName === 'br') isPageBreak = true
-      }
-      if (text) runs.push({ text, bold, italic, underline })
-    }
-  }
-
-  return { style, text: runs.map(r => r.text).join(''), runs, isPageBreak }
-}
-
-function parseTable(tbl: Element): ParsedTable {
-  const tr = tbl.getElementsByTagNameNS(W_NS, 'tr')[0]
-  const cells: ParsedParagraph[][] = []
-  if (tr) {
-    for (const tc of Array.from(tr.children)) {
-      if (tc.localName !== 'tc') continue
-      const paras = Array.from(tc.children)
-        .filter(c => c.localName === 'p')
-        .map(p => parseParagraph(p))
-      cells.push(paras)
-    }
-  }
-  return { cells }
-}
-
-/** Rebuilds bold/italic/underline markup from formatting runs, matching the parser's inline syntax.
- *  Types that don't support inline spans in Sutra source (headings, character cues, notes, etc.)
- *  should pass all three `allow` flags false so forced style formatting (e.g. bold character names)
- *  isn't reinterpreted as user markup. */
-function renderInline(
-  runs: (RunFlags & { text: string })[],
-  opts: { allowBold: boolean; allowItalic: boolean; allowUnderline: boolean }
-): string {
-  let out = ''
-  for (const r of runs) {
-    const bold = opts.allowBold && r.bold
-    const italic = opts.allowItalic && r.italic
-    const underline = opts.allowUnderline && r.underline
-    let text = r.text
-    if (!text) continue
-    if (underline) text = `_${text}_`
-    if (italic) text = `*${text}*`
-    if (bold) text = `**${text}**`
-    out += text
-  }
-  return out
-}
-
-function plainText(para: ParsedParagraph): string {
-  return para.text
-}
-
-function splitNameExtension(text: string): { name: string; extension: string | null } {
-  const m = text.trim().match(/^(.*)\s(\([^()]*\))$/)
-  if (m) return { name: m[1]!.trim(), extension: m[2]! }
-  return { name: text.trim(), extension: null }
-}
-
-function renderCharacterLine(text: string, isDual: boolean): string {
-  const { name, extension } = splitNameExtension(text)
-  return `@${name}${extension ? ` ${extension}` : ''}${isDual ? ' ^' : ''}`
-}
-
-function renderSceneHeading(para: ParsedParagraph): string {
-  const text = plainText(para)
-  const tabIdx = text.indexOf('\t')
-  if (tabIdx === -1) return `## ${text.trim()}`
-  const heading = text.slice(0, tabIdx).trim()
-  const id = text.slice(tabIdx + 1).trim()
-  return id ? `## ${heading} {#${id}}` : `## ${heading}`
-}
-
-class BlockBuilder {
-  private blocks: string[] = []
-  private charLines: string[] | null = null
-  unstyledCount = 0
-
-  private flushChar() {
-    if (this.charLines) {
-      this.blocks.push(this.charLines.join('\n'))
-      this.charLines = null
-    }
-  }
-
-  push(block: string) {
-    this.flushChar()
-    this.blocks.push(block)
-  }
-
-  startCharacter(line: string) {
-    this.flushChar()
-    this.charLines = [line]
-  }
-
-  appendToCharacter(line: string): boolean {
-    if (!this.charLines) return false
-    this.charLines.push(line)
-    return true
-  }
-
-  finish(): string {
-    this.flushChar()
-    return this.blocks.join('\n\n')
-  }
-}
-
-function addParagraph(para: ParsedParagraph, builder: BlockBuilder) {
-  if (para.isPageBreak) {
-    builder.push('===')
-    return
-  }
-  const text = plainText(para).trim()
-
-  switch (para.style) {
-    case 'CineSceneHeading':
-      builder.push(renderSceneHeading(para))
-      return
-    case 'CineSection':
-      builder.push(`# ${text}`)
-      return
-    case 'CineAction': {
-      const rendered = renderInline(para.runs, { allowBold: true, allowItalic: true, allowUnderline: true })
-      if (rendered.trim()) builder.push(rendered)
-      return
-    }
-    case 'CineCharacter':
-      builder.startCharacter(renderCharacterLine(text, false))
-      return
-    case 'CineParenthetical':
-      if (!builder.appendToCharacter(text)) builder.push(text)
-      return
-    case 'CineDialogue': {
-      const rendered = renderInline(para.runs, { allowBold: true, allowItalic: true, allowUnderline: true })
-      if (!builder.appendToCharacter(rendered)) builder.push(rendered)
-      return
-    }
-    case 'CineTransition':
-      builder.push(`>> ${text}`)
-      return
-    case 'CineCentered':
-      builder.push(`>> ${text} <<`)
-      return
-    case 'CineLyrics': {
-      const rendered = renderInline(para.runs, { allowBold: true, allowItalic: false, allowUnderline: true })
-      builder.push(`~ ${rendered}`)
-      return
-    }
-    case 'CineNote':
-      builder.push(text)
-      return
-    case 'CineComment':
-      builder.push(text)
-      return
-    default: {
-      if (!text) return
-      builder.unstyledCount++
-      const rendered = renderInline(para.runs, { allowBold: true, allowItalic: true, allowUnderline: true })
-      builder.push(rendered)
-    }
-  }
-}
-
-function isBodyStart(item: BodyItem): boolean {
-  if (item.kind === 'table') return true
-  return item.para.style !== null && BODY_STYLES.has(item.para.style)
-}
-
-/** Parses a .docx file (as produced by exportToDocx, possibly re-saved from Word with
- *  corrections and/or font changes) back into Sutra body text. The title page, if any,
- *  is not reimported — only content carrying the CineXxx paragraph styles the exporter
- *  applies to the screenplay body is recognized. */
-export async function importDocx(buffer: ArrayBuffer): Promise<DocxImportResult> {
-  const warnings: string[] = []
-  let zip: JSZip
-  try {
-    zip = await JSZip.loadAsync(buffer)
-  } catch {
-    throw new Error('This file is not a valid .docx (Word) document.')
-  }
-  const docXml = zip.file('word/document.xml')
-  if (!docXml) throw new Error('This file is not a valid .docx (Word) document.')
-  const xmlText = await docXml.async('text')
-
-  const parser = new DOMParser()
-  const xmlDoc = parser.parseFromString(xmlText, 'application/xml')
-  if (xmlDoc.getElementsByTagName('parsererror').length > 0) {
-    throw new Error('Could not read the Word document — its XML appears corrupted.')
-  }
-  const body = xmlDoc.getElementsByTagNameNS(W_NS, 'body')[0]
-  if (!body) throw new Error('This .docx file has no document body.')
-
-  const items: BodyItem[] = []
-  for (const child of Array.from(body.children)) {
-    if (child.localName === 'p') items.push({ kind: 'para', para: parseParagraph(child) })
-    else if (child.localName === 'tbl') items.push({ kind: 'table', table: parseTable(child) })
-  }
-
-  const startIdx = items.findIndex(isBodyStart)
-  if (startIdx === -1) {
-    warnings.push('No Sutrata screenplay content was found in this document — nothing was imported.')
-    return { bodyText: null, warnings }
-  }
-
-  const builder = new BlockBuilder()
-  let skippedTables = 0
-
-  for (let i = startIdx; i < items.length; i++) {
-    const item = items[i]!
-    if (item.kind === 'para') {
-      addParagraph(item.para, builder)
-      continue
-    }
-    // dual-dialogue table: exactly two cells, each a character block
-    if (item.table.cells.length !== 2) {
-      skippedTables++
-      continue
-    }
-    const [left, right] = item.table.cells as [ParsedParagraph[], ParsedParagraph[]]
-    for (const p of left) addParagraph(p, builder)
-    const rightFirst = right[0]
-    if (rightFirst && rightFirst.style === 'CineCharacter') {
-      builder.startCharacter(renderCharacterLine(plainText(rightFirst).trim(), true))
-      for (const p of right.slice(1)) addParagraph(p, builder)
-    } else {
-      for (const p of right) addParagraph(p, builder)
-    }
-  }
-
-  const bodyText = builder.finish()
-
-  if (builder.unstyledCount > 0) {
-    warnings.push(`${builder.unstyledCount} paragraph(s) had no recognized Sutrata style and were imported as action lines.`)
-  }
-  if (skippedTables > 0) {
-    warnings.push(`${skippedTables} table(s) in the document were not recognized as dual dialogue and were skipped.`)
-  }
-  warnings.push('The title page was not imported — edit it from the Title Page panel if it also needs corrections.')
-
-  return { bodyText: bodyText || null, warnings }
-}

package/src/file/print-paginator.ts

@@ -1,301 +0,0 @@
-/** Per-page headers ("<scene> CONTINUED:" on the left, "p<n>" on the right) need to know
- *  where the page breaks actually fall, and a browser tells no one that: Chromium supports
- *  neither CSS Paged Media margin boxes (@top-left/@top-right) nor running elements, and
- *  exposes no JS hook for its own break positions. So the print document paginates itself:
- *  the script below runs inside the print window (or the hidden WebView2 window the Windows
- *  desktop export prints from) and distributes the rendered blocks into fixed-height
- *  .print-page boxes it can then put a real header on.
- *
- *  It runs in that window, not here — `printPaginatorScript` stringifies the function into
- *  the exported HTML — so `paginatePrintDocument` must stay self-contained: no imports, no
- *  module-scope references, nothing a bundler could rename out from under it. */
-
-export interface PrintPaginationOptions {
-  /** Printable height of one page in CSS px (paper height minus the style's top/bottom
-   *  margins) — the browser applies those margins via @page, so a box of exactly this
-   *  height fills one sheet. */
-  contentHeightPx: number
-  /** Right-hand header cell: this prefix plus the page number (e.g. "p" -> "p12"). */
-  pageNumberPrefix: string
-  /** Left-hand header cell on a page that opens mid-scene: the scene number, then this
-   *  (e.g. "8 CONTINUED:"). */
-  continuedSuffix: string
-}
-
-export function paginatePrintDocument(opts: PrintPaginationOptions): void {
-  const flow = document.getElementById('print-flow')
-  const pagesRoot = document.getElementById('print-pages')
-  if (!flow || !pagesRoot) return
-  const root: HTMLElement = pagesRoot
-
-  const blocks: HTMLElement[] = []
-  for (let i = 0; i < flow.children.length; i++) blocks.push(flow.children[i] as HTMLElement)
-  if (blocks.length === 0) return
-
-  // Elements that may be broken across a page boundary mid-paragraph. Everything else
-  // moves to the next page whole (a cue, a heading and a note are all short enough that
-  // splitting one is always the wrong answer).
-  const SPLITTABLE = /\bprint-(action|dialogue|lyrics)\b/
-  // ...and elements that must not be the last thing on a page — the same rule
-  // styles/pagination.ts states for DOCX/CSS, re-stated here because inside a
-  // self-paginated flow the browser's own break-after: avoid never comes into play.
-  // (?![\w-] so this doesn't also catch the print-character-block wrapper — a *finished*
-  // speech is free to end a page; it's the cue inside it that must not.)
-  const KEEP_WITH_NEXT = /\bprint-(scene-heading|character|parenthetical|section)(?![\w-])/
-  // A cue + its dialogue: not splittable as text, but its children can be distributed.
-  const CONTAINER = /\bprint-character-block\b/
-  const MIN_LINES = 2
-  // Slack against sub-pixel rounding: a box that measures a hair over the page height
-  // would spill a stray sliver onto the next sheet.
-  const SLACK_PX = 4
-
-  type Page = { el: HTMLElement; body: HTMLElement; continued: HTMLElement; number: HTMLElement }
-  const pages: Page[] = []
-  function newPage(): Page {
-    const el = document.createElement('section')
-    el.className = 'print-page'
-    el.style.height = opts.contentHeightPx + 'px'
-    const header = document.createElement('div')
-    header.className = 'print-page-header'
-    const continued = document.createElement('span')
-    continued.className = 'print-page-continued'
-    const number = document.createElement('span')
-    number.className = 'print-page-number'
-    header.appendChild(continued)
-    header.appendChild(number)
-    const body = document.createElement('div')
-    body.className = 'print-page-body'
-    el.appendChild(header)
-    el.appendChild(body)
-    root.appendChild(el)
-    const page = { el, body, continued, number }
-    pages.push(page)
-    // Numbered as soon as the page exists, not in the header pass at the end: an empty
-    // header measures as a bare margin, and every block would then be placed against a
-    // page height ~one line too generous.
-    number.textContent = opts.pageNumberPrefix + String(pages.length)
-    return page
-  }
-
-  let page = newPage()
-  /** How much of the page box is left for body content, in the body's own coordinates —
-   *  i.e. page height less everything above the body (the header and its margin). */
-  const limit = () =>
-    opts.contentHeightPx
-    - (page.body.getBoundingClientRect().top - page.el.getBoundingClientRect().top)
-    - SLACK_PX
-
-  function lineCount(el: HTMLElement): number {
-    const range = document.createRange()
-    range.selectNodeContents(el)
-    return range.getClientRects().length
-  }
-
-  /** Every position a line could break at, as (text node, offset) pairs. */
-  function wordBoundaries(el: HTMLElement): { node: Text; offset: number }[] {
-    const spots: { node: Text; offset: number }[] = []
-    const walker = document.createTreeWalker(el, NodeFilter.SHOW_TEXT)
-    let node = walker.nextNode() as Text | null
-    while (node) {
-      const text = node.data
-      for (let i = 1; i < text.length; i++) {
-        if (/\s/.test(text[i - 1]!) && !/\s/.test(text[i]!)) spots.push({ node, offset: i })
-      }
-      node = walker.nextNode() as Text | null
-    }
-    return spots
-  }
-
-  /** Cut `el` so that what stays fits in `maxHeight`, returning the remainder as a new
-   *  element of the same kind (or null when there is no split leaving MIN_LINES on both
-   *  sides — then the whole block moves to the next page instead). */
-  function split(el: HTMLElement, maxHeight: number): HTMLElement | null {
-    const range = document.createRange()
-    // Nothing to split against without a layout engine to measure line boxes with
-    // (a headless DOM, say) — blocks then move whole rather than being cut blind.
-    if (typeof range.getClientRects !== 'function') return null
-    const spots = wordBoundaries(el)
-    if (spots.length === 0) return null
-    const top = el.getBoundingClientRect().top
-    const fits = (spot: { node: Text; offset: number }) => {
-      range.setStartBefore(el)
-      range.setEnd(spot.node, spot.offset)
-      const rects = range.getClientRects()
-      const last = rects[rects.length - 1]
-      return last ? last.bottom - top <= maxHeight : true
-    }
-    let lo = 0
-    let hi = spots.length - 1
-    let best = -1
-    while (lo <= hi) {
-      const mid = (lo + hi) >> 1
-      if (fits(spots[mid]!)) {
-        best = mid
-        lo = mid + 1
-      } else {
-        hi = mid - 1
-      }
-    }
-    if (best < 0) return null
-
-    const cut = spots[best]!
-    const rest = el.cloneNode(false) as HTMLElement
-    const tail = document.createRange()
-    tail.setStart(cut.node, cut.offset)
-    tail.setEndAfter(el.lastChild!)
-    rest.appendChild(tail.extractContents())
-    page.body.appendChild(rest)
-    const ok = lineCount(el) >= MIN_LINES && lineCount(rest) >= MIN_LINES
-    page.body.removeChild(rest)
-    if (!ok) {
-      // Put it back exactly as it was rather than leaving a half-cut paragraph behind.
-      while (rest.firstChild) el.appendChild(rest.firstChild)
-      el.normalize()
-      return null
-    }
-    return rest
-  }
-
-  /** A character block is a cue plus its parentheticals and dialogue lines. When it
-   *  straddles a break, the split runs *between* those children (and, where the straddling
-   *  line is dialogue, inside it) so a long speech doesn't jump to the next page whole and
-   *  leave a hole behind. The cue never ends up alone: a continuation is only produced
-   *  when the cue keeps at least part of the first speech with it. */
-  function splitContainer(el: HTMLElement, maxHeight: number): HTMLElement | null {
-    const children: HTMLElement[] = []
-    for (let i = 0; i < el.children.length; i++) children.push(el.children[i] as HTMLElement)
-    if (children.length < 2) return null
-    const top = el.getBoundingClientRect().top
-    let cut = -1
-    for (let i = 0; i < children.length; i++) {
-      if (children[i]!.getBoundingClientRect().bottom - top > maxHeight) { cut = i; break }
-    }
-    if (cut <= 0) return null // the cue itself doesn't fit: the whole block moves down
-
-    const rest = el.cloneNode(false) as HTMLElement
-    const crossing = children[cut]!
-    let from = cut
-    if (SPLITTABLE.test(crossing.className)) {
-      const tail = split(crossing, maxHeight - (crossing.getBoundingClientRect().top - top))
-      if (tail) {
-        rest.appendChild(tail)
-        from = cut + 1
-      }
-    }
-    if (from === cut && cut < 2) return null // would strand the cue on its own
-    for (let i = from; i < children.length; i++) rest.appendChild(children[i]!)
-    return rest.children.length > 0 ? rest : null
-  }
-
-  /** Break `block` so what's left fits in `room`, returning the continuation (or null when
-   *  it can't be broken and has to move down whole). */
-  function breakBlock(block: HTMLElement, room: number): HTMLElement | null {
-    if (SPLITTABLE.test(block.className)) return split(block, room)
-    if (CONTAINER.test(block.className)) return splitContainer(block, room)
-    return null
-  }
-
-  /** The run of keep-with-next blocks immediately before the break, which have to travel
-   *  to the next page with the block they introduce. */
-  function trailingKeepWithNext(): HTMLElement[] {
-    const moved: HTMLElement[] = []
-    let last = page.body.lastElementChild as HTMLElement | null
-    while (last && KEEP_WITH_NEXT.test(last.className)) {
-      moved.unshift(last)
-      last = last.previousElementSibling as HTMLElement | null
-    }
-    // Never empty a page for the sake of the rule — that would loop forever.
-    return moved.length < page.body.children.length ? moved : []
-  }
-
-  let pending: HTMLElement | null = null
-  for (let i = 0; i < blocks.length; i++) {
-    const block: HTMLElement = pending ?? blocks[i]!
-    pending = null
-
-    // An explicit Sutra page break (===) just starts the next page.
-    if (block.className.indexOf('print-page-break') >= 0) {
-      if (page.body.children.length > 0) page = newPage()
-      continue
-    }
-
-    page.body.appendChild(block)
-    if (page.body.scrollHeight <= limit()) continue
-
-    // Doesn't fit. Break the block itself where that's allowed...
-    const rest = breakBlock(block, limit() - block.offsetTop)
-    if (rest) {
-      page = newPage()
-      pending = rest // re-measured next time round: a long speech can span three pages
-      i--
-      continue
-    }
-
-    // ...otherwise the whole block moves down, dragging any cue/heading introducing it.
-    page.body.removeChild(block)
-    const travelling = trailingKeepWithNext()
-    if (page.body.children.length === travelling.length) {
-      // Nothing would be left behind: this block is simply taller than a page, so let
-      // it sit here and overflow rather than bounce between empty pages forever.
-      page.body.appendChild(block)
-      continue
-    }
-    page = newPage()
-    for (let k = 0; k < travelling.length; k++) page.body.appendChild(travelling[k]!)
-    page.body.appendChild(block)
-    if (page.body.scrollHeight > limit()) {
-      const tail = breakBlock(block, limit() - block.offsetTop)
-      if (tail) {
-        page = newPage()
-        pending = tail
-        i--
-      }
-    }
-  }
-
-  // Headers, once every block has landed: which page a scene starts on is only knowable
-  // after the fact (a heading can be pushed to the next page by the keep-with-next rule).
-  const sceneFirstPage: Record<string, number> = {}
-  for (let i = 0; i < pages.length; i++) {
-    const body = pages[i]!.body
-    for (let k = 0; k < body.children.length; k++) {
-      const scene = body.children[k]!.getAttribute('data-scene-start')
-      if (scene !== null && sceneFirstPage[scene] === undefined) sceneFirstPage[scene] = i
-    }
-  }
-  for (let i = 0; i < pages.length; i++) {
-    const p = pages[i]!
-    const first = p.body.firstElementChild
-    const scene = first ? first.getAttribute('data-scene') : null
-    const startsHere = first !== null && first.getAttribute('data-scene-start') !== null
-    if (scene !== null && !startsHere && sceneFirstPage[scene] !== undefined && sceneFirstPage[scene]! < i) {
-      p.continued.textContent = scene + ' ' + opts.continuedSuffix
-    }
-  }
-
-  flow.parentNode?.removeChild(flow)
-}
-
-/** The `<script>` that runs `paginatePrintDocument` in the exported document, once web
- *  fonts have settled — measuring before that would paginate against fallback metrics
- *  (and Indic text reflows a lot between the two). Any failure leaves the un-paginated
- *  flow exactly as it was, so the export degrades to the browser's own page breaks
- *  (which styles/pagination.ts's CSS rules still govern) instead of producing nothing. */
-export function printPaginatorScript(opts: PrintPaginationOptions): string {
-  return `<script>
-      (function () {
-        var run = function () {
-          try {
-            (${paginatePrintDocument.toString()})(${JSON.stringify(opts)});
-          } catch (e) {
-            console.error('Sutrata: pagination failed, falling back to browser page breaks', e);
-          }
-        };
-        if (document.fonts && document.fonts.ready) {
-          document.fonts.ready.then(run, run);
-        } else {
-          run();
-        }
-      })();
-    </script>`
-}

package/src/file/templates.ts

@@ -1,73 +0,0 @@
-export type TemplateType = 'feature' | 'tv-pilot' | 'short' | 'web-series' | 'stage-play'
-
-const BASE_FEATURE = `---
-title: Untitled Feature
-author:
-page: A4
----
-
-# ACT ONE
-
-## INT. LOCATION - DAY {#sc1}
-=
-
-`
-
-const BASE_TV_PILOT = `---
-title: Untitled Pilot
-author:
-page: A4
-series:
-episode: 1
----
-
-## COLD OPEN
-
-## INT. LOCATION - DAY {#sc1}
-=
-
-`
-
-const BASE_SHORT = `---
-title: Untitled Short
-author:
-page: A4
----
-
-## INT. LOCATION - DAY {#sc1}
-=
-
-`
-
-const BASE_WEB_SERIES = `---
-title: Untitled Web Series
-author:
-page: A4
-series:
-episode: 1
----
-
-## INT. LOCATION - DAY {#sc1}
-=
-
-`
-
-const BASE_STAGE_PLAY = `---
-title: Untitled Play
-author:
-page: A4
----
-
-# ACT ONE
-
-## Scene 1 {#sc1}
-
-`
-
-export const TEMPLATES: Record<TemplateType, string> = {
-  'feature': BASE_FEATURE,
-  'tv-pilot': BASE_TV_PILOT,
-  'short': BASE_SHORT,
-  'web-series': BASE_WEB_SERIES,
-  'stage-play': BASE_STAGE_PLAY,
-}