@chilts/weave 0.7.0 → 0.8.0

package/dist/codegen/sourcemap.d.ts

@@ -1,4 +1,4 @@
-import type { SourceLocation } from '../parser/types.js';
+import type { SourceLocation, ValueLoc } from '../parser/types.js';
 /** A single mapping segment: generated position → source position (all 0-based) */
 export interface Mapping {
     genLine: number;
@@ -29,6 +29,34 @@ export declare function encodeVLQ(value: number): string;
 export declare function encodeMappings(mappings: Mapping[]): string;
 /** Create a CodeChunk with an optional mapping at position (0,0) tied to a source location. */
 export declare function chunk(code: string, loc?: SourceLocation): CodeChunk;
+/** A zero-width chunk that maps the code following it to `loc`. */
+export declare function mark(loc: SourceLocation): CodeChunk;
+/**
+ * Concatenate code and chunks, placing each chunk's mappings where it lands:
+ * its first line shifts by the column it starts at, every line by the line.
+ */
+export declare function concat(...parts: (string | CodeChunk)[]): CodeChunk;
+/** Captured TS text and where its lines start in the source, when known. */
+export interface Captured {
+    text: string;
+    loc?: ValueLoc | undefined;
+}
+/**
+ * The part of a captured value from `start` to `end`, with its line starts
+ * moved to match. Trims surrounding whitespace, as the slice is re-emitted on
+ * its own.
+ */
+export declare function sliceCaptured(value: Captured, start: number, end?: number): Captured;
+/**
+ * A chunk for captured TS, which weave re-emits character for character. Every
+ * token (a run of word characters, or any other non-space character) gets a
+ * mapping to its own source position, so a diagnostic anywhere in the value
+ * lands on the token it names. Splitting on character classes is not a TS
+ * parse; it only needs to put a mapping wherever tsc might start a span.
+ * Without a location the text is emitted unmapped, covered by whatever
+ * mapping precedes it.
+ */
+export declare function verbatim(value: Captured): CodeChunk;
 /** Offset all mappings in an array by a line delta. */
 export declare function offsetMappings(mappings: Mapping[], lineOffset: number): Mapping[];
 /** Count newlines in a string. */
@@ -40,4 +68,24 @@ export declare function lineCount(code: string): number;
 export declare function joinChunks(chunks: CodeChunk[], separator: string): CodeChunk;
 /** Build a complete V3 source map object. */
 export declare function buildSourceMap(mappings: Mapping[], file: string, sourceFile: string): SourceMap;
+/**
+ * Decode a V3 `mappings` string into absolute mappings (the inverse of
+ * encodeMappings). The source index and names are ignored: weave emits a
+ * single source and no names. Segments with no source position are skipped.
+ */
+export declare function decodeMappings(mappings: string): Mapping[];
+/** A position in the original source (1-based line and col). */
+export interface OriginalPosition {
+    source: string;
+    line: number;
+    col: number;
+}
+/**
+ * Find the source position for a generated position (1-based line and col).
+ * Uses the last mapping at or before it on the same line, else the last
+ * mapping on the nearest earlier line. Weave maps every token of a captured TS
+ * expression to its own source position, and generated wrapper code to the
+ * start of the node that produced it.
+ */
+export declare function originalPosition(map: SourceMap, line: number, col: number): OriginalPosition | undefined;
 //# sourceMappingURL=sourcemap.d.ts.map

package/dist/codegen/sourcemap.js

@@ -24,14 +24,13 @@ export function encodeMappings(mappings) {
         return '';
     // Find max generated line
     const maxLine = sorted[sorted.length - 1].genLine;
-    let prevGenCol = 0;
     let prevSrcLine = 0;
     let prevSrcCol = 0;
     let idx = 0;
     const lines = [];
     for (let line = 0; line <= maxLine; line++) {
         const segments = [];
-        prevGenCol = 0; // genCol resets per line
+        let prevGenCol = 0; // genCol resets per line
         while (idx < sorted.length && sorted[idx].genLine === line) {
             const m = sorted[idx];
             let seg = encodeVLQ(m.genCol - prevGenCol);
@@ -62,6 +61,88 @@ export function chunk(code, loc) {
     }
     return { code, mappings };
 }
+/** A zero-width chunk that maps the code following it to `loc`. */
+export function mark(loc) {
+    return chunk('', loc);
+}
+/**
+ * Concatenate code and chunks, placing each chunk's mappings where it lands:
+ * its first line shifts by the column it starts at, every line by the line.
+ */
+export function concat(...parts) {
+    let code = '';
+    const mappings = [];
+    let line = 0;
+    let col = 0;
+    for (const part of parts) {
+        const c = typeof part === 'string' ? { code: part, mappings: [] } : part;
+        for (const m of c.mappings) {
+            mappings.push({
+                ...m,
+                genLine: m.genLine + line,
+                genCol: m.genLine === 0 ? m.genCol + col : m.genCol,
+            });
+        }
+        code += c.code;
+        const lastNewline = c.code.lastIndexOf('\n');
+        if (lastNewline === -1) {
+            col += c.code.length;
+        }
+        else {
+            line += lineCount(c.code);
+            col = c.code.length - lastNewline - 1;
+        }
+    }
+    return { code, mappings };
+}
+/**
+ * The part of a captured value from `start` to `end`, with its line starts
+ * moved to match. Trims surrounding whitespace, as the slice is re-emitted on
+ * its own.
+ */
+export function sliceCaptured(value, start, end = value.text.length) {
+    const raw = value.text.slice(start, end);
+    const from = start + (raw.length - raw.trimStart().length);
+    const text = raw.trim();
+    if (!value.loc)
+        return { text };
+    const before = value.text.slice(0, from);
+    const line = lineCount(before);
+    const first = value.loc[line];
+    if (!first)
+        return { text };
+    const col = first.col + from - (before.lastIndexOf('\n') + 1);
+    return { text, loc: [{ line: first.line, col }, ...value.loc.slice(line + 1, line + 1 + lineCount(text))] };
+}
+/**
+ * A chunk for captured TS, which weave re-emits character for character. Every
+ * token (a run of word characters, or any other non-space character) gets a
+ * mapping to its own source position, so a diagnostic anywhere in the value
+ * lands on the token it names. Splitting on character classes is not a TS
+ * parse; it only needs to put a mapping wherever tsc might start a span.
+ * Without a location the text is emitted unmapped, covered by whatever
+ * mapping precedes it.
+ */
+export function verbatim(value) {
+    const { text, loc } = value;
+    const mappings = [];
+    if (loc) {
+        text.split('\n').forEach((lineText, genLine) => {
+            const start = loc[genLine];
+            if (!start)
+                return;
+            for (const m of lineText.matchAll(/[\w$]+|\S/g)) {
+                mappings.push({
+                    genLine,
+                    genCol: m.index,
+                    srcLine: start.line - 1,
+                    srcCol: start.col - 1 + m.index,
+                });
+            }
+        });
+    }
+    return { code: text, mappings };
+}
 /** Offset all mappings in an array by a line delta. */
 export function offsetMappings(mappings, lineOffset) {
     if (lineOffset === 0)
@@ -110,4 +191,75 @@ export function buildSourceMap(mappings, file, sourceFile) {
         mappings: encodeMappings(mappings),
     };
 }
+// --- Decoding ---
+const BASE64_VALUES = new Map([...BASE64].map((c, i) => [c, i]));
+/** Decode one segment's VLQ fields. */
+function decodeSegment(segment) {
+    const values = [];
+    let shift = 0;
+    let vlq = 0;
+    for (const c of segment) {
+        const digit = BASE64_VALUES.get(c);
+        if (digit === undefined)
+            throw new Error(`Invalid base64 character in source map: ${c}`);
+        vlq += (digit & 0b11111) << shift;
+        if (digit & 0b100000) {
+            shift += 5;
+        }
+        else {
+            values.push(vlq & 1 ? -(vlq >>> 1) : vlq >>> 1);
+            shift = 0;
+            vlq = 0;
+        }
+    }
+    return values;
+}
+/**
+ * Decode a V3 `mappings` string into absolute mappings (the inverse of
+ * encodeMappings). The source index and names are ignored: weave emits a
+ * single source and no names. Segments with no source position are skipped.
+ */
+export function decodeMappings(mappings) {
+    const result = [];
+    let srcLine = 0;
+    let srcCol = 0;
+    mappings.split(';').forEach((line, genLine) => {
+        let genCol = 0; // genCol resets per line
+        for (const segment of line.split(',')) {
+            if (segment === '')
+                continue;
+            const fields = decodeSegment(segment);
+            genCol += fields[0];
+            if (fields.length < 4)
+                continue;
+            srcLine += fields[2];
+            srcCol += fields[3];
+            result.push({ genLine, genCol, srcLine, srcCol });
+        }
+    });
+    return result;
+}
+/**
+ * Find the source position for a generated position (1-based line and col).
+ * Uses the last mapping at or before it on the same line, else the last
+ * mapping on the nearest earlier line. Weave maps every token of a captured TS
+ * expression to its own source position, and generated wrapper code to the
+ * start of the node that produced it.
+ */
+export function originalPosition(map, line, col) {
+    const source = map.sources[0];
+    if (source === undefined)
+        return undefined;
+    const genLine = line - 1;
+    const genCol = col - 1;
+    let best;
+    for (const m of decodeMappings(map.mappings)) {
+        if (m.genLine > genLine || (m.genLine === genLine && m.genCol > genCol))
+            break;
+        best = m;
+    }
+    if (!best)
+        return undefined;
+    return { source, line: best.srcLine + 1, col: best.srcCol + 1 };
+}
 //# sourceMappingURL=sourcemap.js.map

package/dist/diagnostics/index.d.ts

@@ -0,0 +1,25 @@
+/** A diagnostic at a 1-based line and col, from tsc or anything else. */
+export interface Diagnostic {
+    file: string;
+    line: number;
+    col: number;
+    message: string;
+}
+/** Returns a file's contents, or undefined if it cannot be read. */
+export type ReadFile = (file: string) => string | undefined;
+/**
+ * Translate a diagnostic in a compiled .ts file to its .weave source, using
+ * the source map weave wrote beside it. The returned file is the .weave path,
+ * resolved the same way as the diagnostic's file (relative stays relative).
+ * Returns undefined when the file has no usable map — it is not a weave
+ * output, or was compiled with --no-sourcemap — so the caller can report the
+ * diagnostic as-is.
+ */
+export declare function mapDiagnostic(diag: Diagnostic, readFile?: ReadFile): Diagnostic | undefined;
+export declare function formatCodeFrame(source: string, line: number, col: number): string;
+/**
+ * Format a diagnostic like a LexerError or ParserError: `weave: file:L:C: msg`,
+ * followed by a code frame when the source is given.
+ */
+export declare function formatDiagnostic(diag: Diagnostic, source?: string): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/diagnostics/index.js

@@ -0,0 +1,68 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { originalPosition } from '../codegen/sourcemap.js';
+function readFromDisk(file) {
+    try {
+        return readFileSync(file, 'utf-8');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The map file a compiled .ts points at, falling back to `<file>.map`. */
+function mapFileFor(file, code) {
+    const url = code?.match(/^\/\/# sourceMappingURL=(.+)$/m)?.[1]?.trim();
+    return url ? path.join(path.dirname(file), url) : file + '.map';
+}
+function parseSourceMap(json) {
+    try {
+        const map = JSON.parse(json);
+        return map.version === 3 && Array.isArray(map.sources) && typeof map.mappings === 'string'
+            ? map
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Translate a diagnostic in a compiled .ts file to its .weave source, using
+ * the source map weave wrote beside it. The returned file is the .weave path,
+ * resolved the same way as the diagnostic's file (relative stays relative).
+ * Returns undefined when the file has no usable map — it is not a weave
+ * output, or was compiled with --no-sourcemap — so the caller can report the
+ * diagnostic as-is.
+ */
+export function mapDiagnostic(diag, readFile = readFromDisk) {
+    const json = readFile(mapFileFor(diag.file, readFile(diag.file)));
+    if (json === undefined)
+        return undefined;
+    const map = parseSourceMap(json);
+    if (!map)
+        return undefined;
+    const pos = originalPosition(map, diag.line, diag.col);
+    if (!pos)
+        return undefined;
+    const file = path.join(path.dirname(diag.file), map.sourceRoot ?? '', pos.source);
+    return { file, line: pos.line, col: pos.col, message: diag.message };
+}
+export function formatCodeFrame(source, line, col) {
+    const lines = source.split('\n');
+    if (line < 1 || line > lines.length)
+        return '';
+    const sourceLine = lines[line - 1];
+    const lineNum = String(line);
+    const gutter = ' '.repeat(lineNum.length);
+    return `\n ${lineNum} | ${sourceLine}\n ${gutter} | ${' '.repeat(col - 1)}^`;
+}
+/**
+ * Format a diagnostic like a LexerError or ParserError: `weave: file:L:C: msg`,
+ * followed by a code frame when the source is given.
+ */
+export function formatDiagnostic(diag, source) {
+    let result = `weave: ${diag.file}:${diag.line}:${diag.col}: ${diag.message}`;
+    if (source)
+        result += formatCodeFrame(source, diag.line, diag.col);
+    return result;
+}
+//# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -1,7 +1,11 @@
-export { h, doctype, Fragment, raw, mergeClass, escape, SafeHtml } from './runtime/index.js';
-export type { Attrs } from './runtime/index.js';
+export { h, doctype, Fragment, raw, mergeClass, each, interpolate, escape, SafeHtml } from './runtime/index.js';
+export type { Attrs, AttrValue, ClassValue, StyleValue } from './runtime/index.js';
 export { compile, compileWithSourceMap, generate, generateExpr, definedMixins, CodegenError } from './codegen/index.js';
 export type { GenerateResult, GenerateOptions, IncludeResolver, CodeChunk, Mapping, SourceMap } from './codegen/index.js';
+export { decodeMappings, originalPosition } from './codegen/sourcemap.js';
+export type { OriginalPosition } from './codegen/sourcemap.js';
+export { mapDiagnostic, formatDiagnostic, formatCodeFrame } from './diagnostics/index.js';
+export type { Diagnostic, ReadFile } from './diagnostics/index.js';
 export { lex, LexerError } from './lexer/index.js';
 export type { Token, TokenType } from './lexer/index.js';
 export { parse, ParserError } from './parser/index.js';

package/dist/index.js

@@ -1,7 +1,9 @@
 // Runtime
-export { h, doctype, Fragment, raw, mergeClass, escape, SafeHtml } from './runtime/index.js';
+export { h, doctype, Fragment, raw, mergeClass, each, interpolate, escape, SafeHtml } from './runtime/index.js';
 // Compiler
 export { compile, compileWithSourceMap, generate, generateExpr, definedMixins, CodegenError } from './codegen/index.js';
+export { decodeMappings, originalPosition } from './codegen/sourcemap.js';
+export { mapDiagnostic, formatDiagnostic, formatCodeFrame } from './diagnostics/index.js';
 export { lex, LexerError } from './lexer/index.js';
 export { parse, ParserError } from './parser/index.js';
 //# sourceMappingURL=index.js.map

package/dist/lexer/index.d.ts

@@ -1,9 +1,13 @@
-export type TokenType = 'NEWLINE' | 'INDENT' | 'DEDENT' | 'EOF' | 'IMPORT' | 'TEMPLATE' | 'MIXIN' | 'EXTENDS' | 'BLOCK' | 'INCLUDE' | 'DOCTYPE' | 'IF' | 'ELSE_IF' | 'ELSE' | 'FOR' | 'TAG' | 'CLASS' | 'ID' | 'ATTR_START' | 'ATTR_END' | 'ATTR_NAME' | 'ATTR_VALUE' | 'SPREAD' | 'BUFFERED_CODE' | 'TEXT' | 'INTERPOLATION' | 'PIPE' | 'RAW_TEXT' | 'MIXIN_CALL' | 'COMMENT' | 'PASSTHROUGH_COMMENT' | 'PARAMS' | 'IDENTIFIER' | 'PATH';
+export type TokenType = 'NEWLINE' | 'INDENT' | 'DEDENT' | 'EOF' | 'IMPORT' | 'TEMPLATE' | 'MIXIN' | 'EXTENDS' | 'BLOCK' | 'INCLUDE' | 'DOCTYPE' | 'IF' | 'UNLESS' | 'ELSE_IF' | 'ELSE' | 'FOR' | 'TAG' | 'CLASS' | 'ID' | 'ATTR_START' | 'ATTR_END' | 'ATTR_NAME' | 'ATTR_VALUE' | 'SPREAD' | 'BUFFERED_CODE' | 'TEXT' | 'INTERPOLATION' | 'PIPE' | 'RAW_TEXT' | 'MIXIN_CALL' | 'COMMENT' | 'PASSTHROUGH_COMMENT' | 'PARAMS' | 'IDENTIFIER' | 'PATH';
 export interface Token {
     type: TokenType;
     value: string;
     line: number;
     col: number;
+    starts?: {
+        line: number;
+        col: number;
+    }[];
 }
 export declare class LexerError extends Error {
     readonly line: number;

package/dist/lexer/index.js

@@ -19,8 +19,24 @@ const KEYWORDS = new Set([
     'include',
     'doctype',
     'if',
+    'unless',
     'for',
 ]);
+// Pug's 'block append' / 'block prepend' have no Weave form: a page fills
+// a block by replacing it, so extra content needs a slot of its own.
+const APPEND_HINT = "there is no 'append' or 'prepend'; add a second, empty slot to the layout " +
+    "(e.g. 'block pageScripts' after 'block scripts') and fill that instead";
+// Pug keywords with no Weave equivalent, and what to write instead. Without
+// this they lex as elements and render as e.g. <case> and <when>.
+const PUG_KEYWORDS = new Map([
+    ['case', "use 'if' / 'else if' / 'else' instead of 'case' / 'when'"],
+    ['when', "use 'if' / 'else if' / 'else' instead of 'case' / 'when'"],
+    ['default', "use 'else' instead of 'case' / 'default'"],
+    ['each', "use 'for ( const item of items )' instead of 'each'"],
+    ['while', "iterate with 'for ( const item of items )' instead of 'while'"],
+    ['append', APPEND_HINT],
+    ['prepend', APPEND_HINT],
+]);
 class Lexer {
     lines;
     lineIndex = 0;
@@ -198,6 +214,9 @@ class Lexer {
             case 'if':
                 this.scanIf();
                 break;
+            case 'unless':
+                this.scanUnless();
+                break;
             case 'for':
                 this.scanFor();
                 break;
@@ -229,6 +248,14 @@ class Lexer {
         this.emit('BLOCK', 'block');
         const nameStart = this.skipSpacesFrom('block '.length);
         const name = this.currentLine.slice(nameStart).trim();
+        // A bare 'block' (mixin call-site content) has no name.
+        if (name !== '' && !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+            const word = name.split(/\s/)[0];
+            const message = word === 'append' || word === 'prepend'
+                ? `'block ${word}' is not supported; ${APPEND_HINT}`
+                : `Block name '${name}' must be a single identifier`;
+            throw new LexerError(message, this.lineIndex + 1, this.indentWidth + nameStart + 1);
+        }
         this.emit('IDENTIFIER', name, nameStart);
         this.pos = this.currentLine.length;
     }
@@ -272,6 +299,13 @@ class Lexer {
         this.emit('BUFFERED_CODE', expr);
         this.pos = this.currentLine.length;
     }
+    scanUnless() {
+        this.emit('UNLESS', 'unless', 0);
+        this.pos = 'unless '.length;
+        const expr = this.currentLine.slice(this.pos);
+        this.emit('BUFFERED_CODE', expr);
+        this.pos = this.currentLine.length;
+    }
     scanElseIf() {
         this.emit('ELSE_IF', 'else if', 0);
         this.pos = 'else if '.length;
@@ -298,6 +332,7 @@ class Lexer {
         else {
             const tagStart = this.pos;
             const tag = this.scanTagName();
+            this.checkTagName(tag, tagStart);
             this.emit('TAG', tag, tagStart);
         }
         // Classes and IDs
@@ -312,6 +347,14 @@ class Lexer {
         // Raw block: tag!
         if (this.pos < this.currentLine.length && this.currentLine[this.pos] === '!') {
             this.pos++; // skip !
+            // Anything after the '!' used to be dropped without a word, which
+            // silently lost the expression in Pug's unescaped 'p!= html'.
+            const rest = this.currentLine.slice(this.pos);
+            if (rest.trim() !== '') {
+                throw new LexerError(rest.startsWith('=')
+                    ? "Unescaped buffered code ('!=') is not supported; use '= raw(expr)' instead"
+                    : "A raw block 'tag!' takes no content on its own line; put the raw text on indented lines below it", this.lineIndex + 1, this.indentWidth + this.pos);
+            }
             this.rawBlockIndent = elementIndent;
             this.rawBlockBaseIndent = null;
             return;
@@ -332,6 +375,29 @@ class Lexer {
         }
         return this.currentLine.slice(start, this.pos);
     }
+    // Rejects tag names that can't be an element. Pug syntax Weave doesn't
+    // have used to land here and come out as bogus elements: '- const x = 1'
+    // became a '-' element and 'case'/'when' became <case>/<when>.
+    checkTagName(tag, tagStart) {
+        let message = null;
+        if (tag.startsWith('-')) {
+            message =
+                "Unbuffered code ('- ...') is not supported; templates hold no statements. " +
+                    "Compute values in TypeScript before rendering, or use a buffered expression 'tag= expr'";
+        }
+        else if (tag === '') {
+            message = `Unexpected '${this.currentLine[tagStart]}'; expected a tag name, '.class' or '#id'`;
+        }
+        else if (!/^[a-zA-Z]/.test(tag)) {
+            message = `Tag name '${tag}' must start with a letter`;
+        }
+        else if (PUG_KEYWORDS.has(tag)) {
+            message = `'${tag}' is not a Weave keyword; ${PUG_KEYWORDS.get(tag)}`;
+        }
+        if (message !== null) {
+            throw new LexerError(message, this.lineIndex + 1, this.indentWidth + tagStart + 1);
+        }
+    }
     scanClassesAndIds() {
         let prevClass = null;
         while (this.pos < this.currentLine.length) {
@@ -341,6 +407,13 @@ class Lexer {
                 const dotCol = this.indentWidth + dotPos + 1;
                 this.pos++; // skip dot
                 const { name, raw } = this.scanShorthandName();
+                if (name === '') {
+                    // Pug's 'p.' block text emitted class="" and then lexed
+                    // the text lines below it as elements.
+                    throw new LexerError(this.pos >= this.currentLine.length
+                        ? "Block text ('tag.') is not supported; use 'tag!' for raw text, or '|' lines for escaped text"
+                        : "Expected a class name after '.'", this.lineIndex + 1, dotCol);
+                }
                 // A dot is a class separator, so '.gap-1.5' silently became
                 // 'gap-1' plus a stray '5'. A class that is a bare number is
                 // almost certainly that mistake, so reject it and name the fix.
@@ -357,7 +430,11 @@ class Lexer {
                 const hashPos = this.pos;
                 this.pos++; // skip hash
                 prevClass = null;
-                this.emit('ID', this.scanShorthandName().name, hashPos);
+                const { name } = this.scanShorthandName();
+                if (name === '') {
+                    throw new LexerError("Expected an id after '#'", this.lineIndex + 1, this.indentWidth + hashPos + 1);
+                }
+                this.emit('ID', name, hashPos);
             }
             else {
                 break;
@@ -500,7 +577,7 @@ class Lexer {
             // Without this guard the caller's loop spins forever emitting
             // empty ATTR_NAME tokens until the process aborts.
             throw new LexerError(`Unexpected '${this.currentLine[this.pos]}' in attribute list; ` +
-                `wrap complex attribute values in (parentheses) or \`backticks\``, this.lineIndex + 1, this.indentWidth + this.pos + 1);
+                'wrap complex attribute values in (parentheses) or `backticks`', this.lineIndex + 1, this.indentWidth + this.pos + 1);
         }
         this.emit('ATTR_NAME', name, start);
         // Check for = value
@@ -586,6 +663,21 @@ class Lexer {
             this.pos = this.currentLine.length;
             return;
         }
+        // Anything else used to be dropped along with the rest of the line,
+        // e.g. the child in Pug's block expansion 'li: a(href="/") Home'.
+        let message;
+        if (ch === ':') {
+            message =
+                "Block expansion ('tag: child') is not supported; " +
+                    'put the child element on its own indented line';
+        }
+        else if (ch === '/') {
+            message = "Self-closing 'tag/' is not supported; void elements like 'br' and 'img' close themselves";
+        }
+        else {
+            message = `Unexpected '${ch}' after element; separate inline text from the tag with a space`;
+        }
+        throw new LexerError(message, this.lineIndex + 1, this.indentWidth + this.pos + 1);
     }
     // --- Mixin call scanner ---
     scanMixinCall() {
@@ -603,6 +695,17 @@ class Lexer {
             this.scanAttributes(elementIndent);
             this.emit('ATTR_END', ')', this.pos - 1);
         }
+        // One line of call-site content may follow, as for an element:
+        // '+btn("x") Save' or '+btn("x")= label'. Trailing spaces alone are
+        // not content.
+        const rest = this.currentLine.slice(this.pos);
+        if (rest.trim() === '')
+            return;
+        if (rest[0] === ' ' || rest[0] === '=') {
+            this.scanTrailingContent();
+            return;
+        }
+        throw new LexerError(`Unexpected '${rest[0]}' after mixin call; separate inline content from the call with a space`, this.lineIndex + 1, this.indentWidth + this.pos + 1);
     }
     // --- Pipe scanner ---
     scanPipe() {
@@ -625,6 +728,16 @@ class Lexer {
         let buf = '';
         let bufStart = 0;
         while (i < text.length) {
+            // Pug's tag interpolation '#[strong x]' and unescaped '!{html}'
+            // used to pass through as literal text, so the markup characters
+            // rendered (escaped) on the page.
+            if ((text[i] === '#' && text[i + 1] === '[') || (text[i] === '!' && text[i + 1] === '{')) {
+                throw new LexerError((text[i] === '#'
+                    ? "Tag interpolation ('#[tag ...]') is not supported; put the element on its own " +
+                        "indented line, with '|' lines for the text around it"
+                    : "Unescaped interpolation ('!{...}') is not supported; use '#{raw(expr)}' instead") +
+                    `. For literal '${text.slice(i, i + 2)}' text, use a string expression: 'tag= "..."'`, this.lineIndex + 1, this.indentWidth + this.pos + i + 1);
+            }
             // Check for interpolation #{...}
             if (text[i] === '#' && i + 1 < text.length && text[i + 1] === '{') {
                 // Emit accumulated text
@@ -708,6 +821,7 @@ class Lexer {
         this.pos++; // skip opening (
         let depth = 1;
         const pieces = [];
+        const starts = [];
         let prefix = ''; // this line's indentation relative to the owner
         for (;;) {
             const start = this.pos;
@@ -744,17 +858,22 @@ class Lexer {
             }
             const isComment = end !== -1 && depth > 0;
             const text = this.currentLine.slice(start, end === -1 ? this.currentLine.length : end).trimEnd();
-            if (depth === 0 && pieces.length === 0) {
-                // Closed on the line it opened on: the common, single-line case.
-                this.pos++; // skip closing )
-                return text.trim();
-            }
+            const line = this.lineIndex + 1;
             if (pieces.length === 0) {
+                const lead = text.length - text.trimStart().length;
+                starts.push({ line, col: this.indentWidth + start + lead + 1 });
+                if (depth === 0) {
+                    // Closed on the line it opened on: the common, single-line case.
+                    this.pos++; // skip closing )
+                    return { value: text.trim(), starts };
+                }
                 pieces.push(text.trimStart());
             }
             else if (text !== '' || !isComment) {
                 // Lines holding nothing but a comment are dropped entirely.
+                // A kept line is `prefix + text`, so it starts at the owner's indent.
                 pieces.push(text === '' ? '' : prefix + text);
+                starts.push({ line, col: ownerIndent + 1 });
             }
             if (depth === 0)
                 break;
@@ -763,7 +882,7 @@ class Lexer {
         }
         this.pos++; // skip closing )
         const content = pieces.join('\n');
-        return content.trim() === '' ? '' : content;
+        return content.trim() === '' ? { value: '', starts: [] } : { value: content, starts };
     }
     // Moves onto the next non-blank line of a multi-line paren group. Lines in
     // the group must be indented under its owner; the one exception is the
@@ -911,8 +1030,8 @@ class Lexer {
         if (this.pos < this.currentLine.length && this.currentLine[this.pos] === '(') {
             const line = this.lineIndex + 1;
             const col = this.indentWidth + this.pos + 1;
-            const params = this.scanBalancedParens();
-            this.tokens.push({ type: 'PARAMS', value: params, line, col });
+            const { value, starts } = this.scanBalancedParens();
+            this.tokens.push({ type: 'PARAMS', value, line, col, starts });
         }
     }
     // Returns the first non-space position at or after `pos` on the current line.

package/dist/parser/index.d.ts

@@ -1,5 +1,5 @@
 import type { Token } from '../lexer/index.js';
-export type { AstNode, SourceLocation, TextSegment, AttributeNode, ConditionalBranch, DocumentNode, TemplateNode, MixinDefinitionNode, MixinCallNode, ElementNode, TextNode, BufferedCodeNode, ConditionalNode, IterationNode, BlockNode, ExtendsNode, IncludeNode, ImportNode, DoctypeNode, CommentNode, PassthroughCommentNode, PipeNode, RawBlockNode, } from './types.js';
+export type { AstNode, SourceLocation, ValueLoc, TextSegment, AttributeNode, ConditionalBranch, DocumentNode, TemplateNode, MixinDefinitionNode, MixinCallNode, ElementNode, TextNode, BufferedCodeNode, ConditionalNode, IterationNode, BlockNode, ExtendsNode, IncludeNode, ImportNode, DoctypeNode, CommentNode, PassthroughCommentNode, PipeNode, RawBlockNode, } from './types.js';
 import type { DocumentNode } from './types.js';
 export declare class ParserError extends Error {
     readonly line: number;