@sutrata/editor 0.1.0

package/dist/file/docx-importer.js

@@ -0,0 +1,283 @@
+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',
+]);
+function attrVal(el, tag) {
+    const child = el.getElementsByTagNameNS(W_NS, tag)[0];
+    if (!child)
+        return null;
+    const val = child.getAttributeNS(W_NS, 'val');
+    return val;
+}
+function flagOn(el, tag) {
+    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) {
+    let style = null;
+    const runs = [];
+    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) {
+    const tr = tbl.getElementsByTagNameNS(W_NS, 'tr')[0];
+    const cells = [];
+    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, opts) {
+    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) {
+    return para.text;
+}
+function splitNameExtension(text) {
+    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, isDual) {
+    const { name, extension } = splitNameExtension(text);
+    return `@${name}${extension ? ` ${extension}` : ''}${isDual ? ' ^' : ''}`;
+}
+function renderSceneHeading(para) {
+    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 {
+    blocks = [];
+    charLines = null;
+    unstyledCount = 0;
+    flushChar() {
+        if (this.charLines) {
+            this.blocks.push(this.charLines.join('\n'));
+            this.charLines = null;
+        }
+    }
+    push(block) {
+        this.flushChar();
+        this.blocks.push(block);
+    }
+    startCharacter(line) {
+        this.flushChar();
+        this.charLines = [line];
+    }
+    appendToCharacter(line) {
+        if (!this.charLines)
+            return false;
+        this.charLines.push(line);
+        return true;
+    }
+    finish() {
+        this.flushChar();
+        return this.blocks.join('\n\n');
+    }
+}
+function addParagraph(para, builder) {
+    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) {
+    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) {
+    const warnings = [];
+    let zip;
+    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 = [];
+    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;
+        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/dist/file/print-paginator.d.ts

@@ -0,0 +1,29 @@
+/** 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 declare function paginatePrintDocument(opts: PrintPaginationOptions): void;
+/** 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 declare function printPaginatorScript(opts: PrintPaginationOptions): string;

package/dist/file/print-paginator.js

@@ -0,0 +1,289 @@
+/** 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 function paginatePrintDocument(opts) {
+    const flow = document.getElementById('print-flow');
+    const pagesRoot = document.getElementById('print-pages');
+    if (!flow || !pagesRoot)
+        return;
+    const root = pagesRoot;
+    const blocks = [];
+    for (let i = 0; i < flow.children.length; i++)
+        blocks.push(flow.children[i]);
+    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;
+    const pages = [];
+    function newPage() {
+        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) {
+        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) {
+        const spots = [];
+        const walker = document.createTreeWalker(el, NodeFilter.SHOW_TEXT);
+        let node = walker.nextNode();
+        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();
+        }
+        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, maxHeight) {
+        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) => {
+            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);
+        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, maxHeight) {
+        const children = [];
+        for (let i = 0; i < el.children.length; i++)
+            children.push(el.children[i]);
+        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);
+        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, room) {
+        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() {
+        const moved = [];
+        let last = page.body.lastElementChild;
+        while (last && KEEP_WITH_NEXT.test(last.className)) {
+            moved.unshift(last);
+            last = last.previousElementSibling;
+        }
+        // Never empty a page for the sake of the rule — that would loop forever.
+        return moved.length < page.body.children.length ? moved : [];
+    }
+    let pending = null;
+    for (let i = 0; i < blocks.length; i++) {
+        const block = 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 = {};
+    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) {
+    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/dist/file/templates.d.ts

@@ -0,0 +1,2 @@
+export type TemplateType = 'feature' | 'tv-pilot' | 'short' | 'web-series' | 'stage-play';
+export declare const TEMPLATES: Record<TemplateType, string>;

package/dist/file/templates.js

@@ -0,0 +1,66 @@
+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 = {
+    'feature': BASE_FEATURE,
+    'tv-pilot': BASE_TV_PILOT,
+    'short': BASE_SHORT,
+    'web-series': BASE_WEB_SERIES,
+    'stage-play': BASE_STAGE_PLAY,
+};