@podlite/schema 0.0.65 → 0.0.67

package/lib/guard.d.ts

@@ -0,0 +1,5 @@
+export declare const isCovered: (node: unknown, ctx?: {
+    maskMode?: boolean;
+    renderMode?: string;
+}) => boolean;
+export declare const markGuarded: <T>(node: T, inherited?: boolean) => T;

package/lib/guard.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markGuarded = exports.isCovered = void 0;
+const config_1 = __importDefault(require("./helpers/config"));
+// Covered content is marked on the node, not decided at render time. A block
+// carrying :masked or a G<> code can be lifted out of its document by =include,
+// by a data: reference, by an alias expansion or by a selector; the mark travels
+// with the node, so whatever pulls the node out cannot strip the cover off it.
+const GUARD_CODE = 'G';
+const isGuardCode = (node) => node.type === 'fcode' && node.name === GUARD_CODE;
+const isMaskedBlock = (node) => {
+    if (node.type !== 'block')
+        return false;
+    const conf = (0, config_1.default)(node, {});
+    return conf.exists('masked') && Boolean(conf.getFirstValue('masked'));
+};
+// The mark says the content is covered; the render mode says whether the cover
+// is applied. Draft shows what production hides, and the mark alone must not
+// override that.
+const isCovered = (node, ctx) => {
+    if (ctx?.maskMode)
+        return true;
+    if (ctx?.renderMode === 'draft')
+        return false;
+    return Boolean(node?.guarded);
+};
+exports.isCovered = isCovered;
+const markGuarded = (node, inherited = false) => {
+    if (!node || typeof node !== 'object')
+        return node;
+    if (Array.isArray(node)) {
+        node.forEach(child => (0, exports.markGuarded)(child, inherited));
+        return node;
+    }
+    const target = node;
+    const covered = inherited || target.guarded === true || isGuardCode(target) || isMaskedBlock(target);
+    if (covered)
+        target.guarded = true;
+    if (Array.isArray(target.content))
+        target.content.forEach(child => (0, exports.markGuarded)(child, covered));
+    return node;
+};
+exports.markGuarded = markGuarded;
+//# sourceMappingURL=guard.js.map

package/lib/index.d.ts

@@ -87,7 +87,8 @@ export declare const parseFormattingCodes: (text: string, options?: {
 export { default as toHtml } from './exportHtml';
 export { default as toMarkdown } from './exportMarkdown';
 export { default as Writer } from './writer';
-export { parseSelector, runSelector } from './selectors';
+export { parseSelector, runSelector, filePathMatches } from './selectors';
+export { markGuarded, isCovered } from './guard';
 export type { SelectorDoc, ParsedSelector } from './selectors';
 export { applyImageBase } from './image-base';
 export { version } from './version';

package/lib/index.js

@@ -39,7 +39,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.version = exports.applyImageBase = exports.runSelector = exports.parseSelector = exports.Writer = exports.toMarkdown = exports.toHtml = exports.parseFormattingCodes = exports.parse = exports.frozenIds = exports.cleanIds = exports.podlitePluggable = exports.toAnyRules = exports.pluginCleanLocation = exports.readLinkConfig = exports.parseAttributes = exports.codeConfigWithDefaults = exports.makeAttrs = exports.toAny = exports.isSemanticBlock = exports.isNamedBlock = exports.makeTransformer = exports.makeInterator = void 0;
+exports.version = exports.applyImageBase = exports.isCovered = exports.markGuarded = exports.filePathMatches = exports.runSelector = exports.parseSelector = exports.Writer = exports.toMarkdown = exports.toHtml = exports.parseFormattingCodes = exports.parse = exports.frozenIds = exports.cleanIds = exports.podlitePluggable = exports.toAnyRules = exports.pluginCleanLocation = exports.readLinkConfig = exports.parseAttributes = exports.codeConfigWithDefaults = exports.makeAttrs = exports.toAny = exports.isSemanticBlock = exports.isNamedBlock = exports.makeTransformer = exports.makeInterator = void 0;
 exports.toAst = toAst;
 exports.getTextContentFromNode = getTextContentFromNode;
 exports.getPodContentFromNode = getPodContentFromNode;
@@ -226,6 +226,10 @@ Object.defineProperty(exports, "Writer", { enumerable: true, get: function () {
 var selectors_1 = require("./selectors");
 Object.defineProperty(exports, "parseSelector", { enumerable: true, get: function () { return selectors_1.parseSelector; } });
 Object.defineProperty(exports, "runSelector", { enumerable: true, get: function () { return selectors_1.runSelector; } });
+Object.defineProperty(exports, "filePathMatches", { enumerable: true, get: function () { return selectors_1.filePathMatches; } });
+var guard_1 = require("./guard");
+Object.defineProperty(exports, "markGuarded", { enumerable: true, get: function () { return guard_1.markGuarded; } });
+Object.defineProperty(exports, "isCovered", { enumerable: true, get: function () { return guard_1.isCovered; } });
 var image_base_1 = require("./image-base");
 Object.defineProperty(exports, "applyImageBase", { enumerable: true, get: function () { return image_base_1.applyImageBase; } });
 var version_1 = require("./version");

package/lib/pluggableParser.js

@@ -11,6 +11,7 @@ const corePlugins_1 = __importDefault(require("./helpers/corePlugins"));
 const configPropagation_1 = require("./helpers/configPropagation");
 const headingNumbering_1 = require("./helpers/headingNumbering");
 const itemNumbering_1 = require("./helpers/itemNumbering");
+const guard_1 = require("./guard");
 var ids_2 = require("./helpers/ids");
 Object.defineProperty(exports, "cleanIds", { enumerable: true, get: function () { return ids_2.cleanIds; } });
 Object.defineProperty(exports, "frozenIds", { enumerable: true, get: function () { return ids_2.frozenIds; } });
@@ -78,6 +79,7 @@ const podlitePluggable = ({ plugins = {} } = {}) => {
                 (0, configPropagation_1.propagateConfigDefaults)(resultAfter.interator);
                 (0, itemNumbering_1.promoteOrderedLists)(resultAfter.interator);
                 (0, headingNumbering_1.attachHeadingNumberPrefix)(resultAfter.interator);
+                (0, guard_1.markGuarded)(resultAfter.interator);
             }
             return resultAfter;
         }
@@ -85,6 +87,7 @@ const podlitePluggable = ({ plugins = {} } = {}) => {
             (0, configPropagation_1.propagateConfigDefaults)(result.interator);
             (0, itemNumbering_1.promoteOrderedLists)(result.interator);
             (0, headingNumbering_1.attachHeadingNumberPrefix)(result.interator);
+            (0, guard_1.markGuarded)(result.interator);
         }
         return result;
     };

package/lib/plugin-data-table.d.ts

@@ -1,2 +1,2 @@
-declare const _default: () => (tree: any) => any;
+declare const _default: (opt?: {}) => (tree: any) => any;
 export default _default;

package/lib/plugin-data-table.js

@@ -43,7 +43,8 @@ function resolveColumnIndex(col, headerRow, maxCols) {
     }
     const idx = headerRow.indexOf(col);
     if (idx === -1) {
-        throw new Error(`column name "${col}" not found in header`);
+        const names = headerRow.map(h => `"${h}"`).join(', ');
+        throw new Error(`column name "${col}" not found in header; header has ${names}`);
     }
     return idx;
 }
@@ -65,7 +66,7 @@ function applyRename(rows, rename, hasHeader) {
     }
     return [headerRow, ...rows.slice(1)];
 }
-function processDataTable(node, tree) {
+function processDataTable(node, tree, report) {
     const attrs = (0, config_1.default)(node, {});
     const srcRaw = attrs.getFirstValue('src');
     const mimeAttr = attrs.getFirstValue('mime-type');
@@ -91,7 +92,7 @@ function processDataTable(node, tree) {
         if (scheme === 'data') {
             const dataBlock = (0, plugin_tables_1.findDataBlockByKey)(tree, target);
             if (!dataBlock) {
-                console.warn(`[data-table] no =data block found for data:${target} — rendered as empty`);
+                report('table-source-unreadable', `no =data block found for data:${target}, table rendered as empty`, node);
                 return { ...node, name: 'table', content: [] };
             }
             if (mimeAttr) {
@@ -99,7 +100,7 @@ function processDataTable(node, tree) {
             }
             const dataMime = (0, config_1.default)(dataBlock, {}).getFirstValue('mime-type');
             if (!dataMime) {
-                console.warn(`[data-table] =data block ${target} has no :mime-type — rendered as empty`);
+                report('table-source-unreadable', `=data block ${target} has no :mime-type, table rendered as empty`, node);
                 return { ...node, name: 'table', content: [] };
             }
             const parsed = (0, plugin_tables_1.parseMimeType)(dataMime);
@@ -123,12 +124,12 @@ function processDataTable(node, tree) {
     const isCsv = mimeType === 'text/csv';
     const isTsv = mimeType === 'text/tab-separated-values';
     if (!isCsv && !isTsv) {
-        console.warn(`[data-table] unsupported mime-type ${mimeType} — rendered as empty`);
+        report('table-source-unreadable', `unsupported mime-type ${mimeType}, table rendered as empty`, node);
         return { ...node, name: 'table', content: [] };
     }
     let rows = isCsv ? (0, plugin_tables_1.parseCsv)(csvText) : (0, plugin_tables_1.parseTsv)(csvText);
     if (rows.length === 0) {
-        console.warn(`[data-table] ${isCsv ? 'CSV' : 'TSV'} parse produced no rows — rendered as empty`);
+        report('table-source-unreadable', `${isCsv ? 'CSV' : 'TSV'} source has no rows, table rendered as empty`, node);
         return { ...node, name: 'table', content: [] };
     }
     if (columns) {
@@ -142,16 +143,17 @@ function processDataTable(node, tree) {
         name: 'table',
         content: (0, plugin_tables_1.csvToTableContent)(rows, hasHeader, attrs.getAllValues('allow')),
     };
-    return (0, plugin_tables_1.normalizeCellCounts)(filledNode, 'data-table');
+    return (0, plugin_tables_1.normalizeCellCounts)(filledNode, 'data-table', report);
 }
-exports.default = () => tree => {
+exports.default = (opt = {}) => tree => {
+    const report = (0, plugin_tables_1.makeTableReport)(opt);
     const transformer = (0, makeTransformer_1.default)({
         'data-table': node => {
             try {
-                return processDataTable(node, tree);
+                return processDataTable(node, tree, report);
             }
             catch (err) {
-                console.warn(`[data-table] ${err.message}`);
+                report('table-source-unreadable', err.message, node);
                 return { ...node, name: 'table', content: [] };
             }
         },

package/lib/plugin-formatting-codes.js

@@ -41,49 +41,85 @@ const makeTransformer_1 = __importDefault(require("./helpers/makeTransformer"));
 const makeTransformer_2 = require("./helpers/makeTransformer");
 const config_1 = __importDefault(require("./helpers/config"));
 const parseAttributes_1 = require("./helpers/parseAttributes");
+// `=config C<> :allow<I>` names a markup code, not a block: the trailing angles
+// are the marker, and what it declares belongs to the code they name
+const codeConfigOwner = (name) => typeof name === 'string' && /^[A-Z]<>$/.test(name) ? name[0] : null;
+const collectAllowedIn = (content, inherited) => {
+    if (!Array.isArray(content))
+        return inherited;
+    let map = inherited;
+    for (const child of content) {
+        if (!child || typeof child !== 'object')
+            continue;
+        const node = child;
+        if (node.type !== 'config')
+            continue;
+        const owner = codeConfigOwner(node.name);
+        if (!owner)
+            continue;
+        if (map === inherited)
+            map = { ...inherited };
+        map[owner] = (0, config_1.default)(node, {}).getAllValues('allow');
+    }
+    return map;
+};
 const middle = () => tree => {
     const transformerBlocks = (0, makeTransformer_1.default)({
         ':para': (n, ctx, visiter) => {
+            const allowedIn = ctx.allowedIn;
             return (0, makeTransformer_1.default)({
                 ':text': (n, ctx) => {
-                    return fcparser.parse(n.value, { parseAttributes: parseAttributes_1.parseAttributes });
+                    return fcparser.parse(n.value, { allowedIn, parseAttributes: parseAttributes_1.parseAttributes });
                 },
                 ':verbatim': (n, ctx) => {
-                    return fcparser.parse(n.value, { parseAttributes: parseAttributes_1.parseAttributes });
+                    return fcparser.parse(n.value, { allowedIn, parseAttributes: parseAttributes_1.parseAttributes });
                 },
             })(n, { ...ctx });
             return n;
         },
         ':block': (n, ctx, visiter) => {
+            // a block is a lexical scope: a code configured inside it stays inside
+            const allowedIn = collectAllowedIn('content' in n ? n.content : undefined, ctx.allowedIn || {});
             // only =pod may have childs blocks
             if ('name' in n && n.name === 'pod')
                 return {
                     ...n,
-                    content: visiter(n.content, ctx, visiter),
+                    content: visiter(n.content, { ...ctx, allowedIn }, visiter),
                 };
             const conf = (0, config_1.default)(n, ctx);
             const name = 'name' in n ? n.name : '';
             // Blocks whose content is verbatim by default — fcode parsing only
             // kicks in when :allow opts in (per spec, "Formatting within code blocks").
             const isVerbatimDefault = ['code', 'data', 'markdown', 'picture', 'formula'].includes(name);
-            const allowValues = conf.getAllValues('allow');
             if ((0, makeTransformer_2.isNamedBlock)(name))
                 return n;
+            // A table owns rows, and the text sits in the cells, so :allow written on
+            // the table reaches them. The nearest declaration wins: cell, row, table.
+            const inheritsAllow = name === 'row' || name === 'cell';
+            const declared = conf.exists('allow')
+                ? conf.getAllValues('allow')
+                : inheritsAllow
+                    ? ctx.allowFromTable
+                    : undefined;
+            const allowValues = declared || [];
+            const passesAllow = name === 'table' || name === 'row' ? declared : ctx.allowFromTable;
             if (isVerbatimDefault && allowValues.length === 0)
                 return n;
-            // a cell built from data carries its own set; declared empty means no code acts
-            if (name === 'cell' && conf.exists('allow') && allowValues.length === 0)
-                return n;
-            const allowed = allowValues.sort();
+            // declared empty means no code acts on this text; nested blocks still get
+            // their turn, since a cell may declare a set of its own
+            const literal = inheritsAllow && declared !== undefined && declared.length === 0;
+            const allowed = [...allowValues].sort();
+            const inner = { ...ctx, allowedIn, allowFromTable: passesAllow };
             const transformer = (0, makeTransformer_1.default)({
-                ':verbatim': (n, ctx) => fcparser.parse(n.value, { allowed, parseAttributes: parseAttributes_1.parseAttributes }),
-                ':text': (n, ctx) => fcparser.parse(n.value, { allowed, parseAttributes: parseAttributes_1.parseAttributes }),
-                ':block': (n, ctx) => transformerBlocks(n, { ...ctx }),
+                ':verbatim': (node, ctx) => literal ? node : fcparser.parse(node.value, { allowed, allowedIn, parseAttributes: parseAttributes_1.parseAttributes }),
+                ':text': (node, ctx) => literal ? node : fcparser.parse(node.value, { allowed, allowedIn, parseAttributes: parseAttributes_1.parseAttributes }),
+                ':block': (node, ctx) => transformerBlocks(node, { ...ctx, allowedIn, allowFromTable: passesAllow }),
             });
-            return { ...n, content: transformer(n.content, { ...ctx }) };
+            return { ...n, content: transformer(n.content, inner) };
         },
     });
-    return transformerBlocks(tree, {});
+    // a document needs no enclosing block, so the top level is a scope of its own
+    return transformerBlocks(tree, { allowedIn: collectAllowedIn(tree, {}) });
 };
 exports.default = middle;
 //# sourceMappingURL=plugin-formatting-codes.js.map

package/lib/plugin-tables.d.ts

@@ -7,6 +7,8 @@ export declare function parseMimeType(raw: any): {
 export declare function findDataBlockByKey(tree: any, key: any): any;
 export declare function extractDataText(dataNode: any): any;
 export declare function csvToTableContent(csvRows: any, hasHeader?: boolean, allow?: string[]): any;
-export declare function normalizeCellCounts(tableNode: any, source?: string): any;
-declare const _default: () => (tree: any) => any;
+export type TableReport = (code: string, message: string, node: any) => void;
+export declare function makeTableReport(opt: any): TableReport;
+export declare function normalizeCellCounts(tableNode: any, source?: string, report?: TableReport): any;
+declare const _default: (opt?: {}) => (tree: any) => any;
 export default _default;

package/lib/plugin-tables.js

@@ -9,6 +9,7 @@ exports.parseMimeType = parseMimeType;
 exports.findDataBlockByKey = findDataBlockByKey;
 exports.extractDataText = extractDataText;
 exports.csvToTableContent = csvToTableContent;
+exports.makeTableReport = makeTableReport;
 exports.normalizeCellCounts = normalizeCellCounts;
 /**
  * Plugin for fill term's for defn. From S26:
@@ -216,16 +217,27 @@ function csvToTableContent(csvRows, hasHeader = false, allow = []) {
         return buildRowBlock(cells, hasHeader && i === 0);
     });
 }
-// ─── Error recovery (design notes Rules 2-4) ───────────────────────────────
+function makeTableReport(opt) {
+    const diagnostics = opt && Array.isArray(opt.diagnostics) ? opt.diagnostics : null;
+    return (code, message, node) => {
+        const location = node && node.location;
+        if (!diagnostics || !location)
+            return;
+        const seen = diagnostics.some(d => d.message === message && d.location.start.offset === location.start.offset);
+        if (!seen)
+            diagnostics.push({ severity: 'warning', code, message, location });
+    };
+}
+const noReport = () => { };
 // Rule 2 — table-level cell count validation. Pad short rows with empty
-// cells; truncate long rows. Emit a warning whenever a row is changed.
+// cells; truncate long rows. Report whenever a row is changed.
 // Expected count is taken from the `:header` row if present, otherwise from
 // the row with the maximum cell count.
 //
 // Skipped when any cell uses `:colspan` or `:rowspan`: a spanning cell
 // occupies multiple columns, so naive cell counting would misreport row
 // width and drop legitimate spanned cells.
-function normalizeCellCounts(tableNode, source = 'table') {
+function normalizeCellCounts(tableNode, source = 'table', report = noReport) {
     if (!tableNode || !Array.isArray(tableNode.content))
         return tableNode;
     const rows = tableNode.content.filter(c => c && c.type === 'block' && c.name === 'row');
@@ -252,13 +264,13 @@ function normalizeCellCounts(tableNode, source = 'table') {
             const padding = [];
             for (let i = cells.length; i < expected; i++)
                 padding.push(buildCellBlock(''));
-            console.warn(`[${source}] row has ${cells.length} cells, expected ${expected} — padded with ${padding.length} empty`);
+            report('table-row-cells', `${source} row has ${cells.length} of ${expected} cells, padded with ${padding.length} empty. A row continued on the next line needs a blank line before the next row`, tableNode);
             mutated = true;
             return { ...child, content: [...child.content, ...padding] };
         }
         // cells.length > expected → truncate
         const dropped = cells.length - expected;
-        console.warn(`[${source}] row has ${cells.length} cells, expected ${expected} — truncated ${dropped}`);
+        report('table-row-cells', `${source} row has ${cells.length} of ${expected} cells, dropped ${dropped}`, tableNode);
         mutated = true;
         // Keep non-cell entries (e.g. blanklines) and the first `expected` cells
         let keepCells = expected;
@@ -282,7 +294,7 @@ function normalizeCellCounts(tableNode, source = 'table') {
 // for visible separators (`|` / `+`) surrounded by whitespace; lines without
 // any visible separator fall back to whitespace separation. Warns when more
 // than one separator type is observed within a single table.
-function detectMixedSeparators(lines) {
+function detectMixedSeparators(lines, report = noReport, node = null) {
     const seen = new Set();
     for (const line of lines) {
         if (!line || typeof line !== 'string')
@@ -297,7 +309,7 @@ function detectMixedSeparators(lines) {
             break;
     }
     if (seen.size > 1) {
-        console.warn(`[table] mixed separator types detected: ${Array.from(seen).join(', ')} — recommend a single style`);
+        report('table-mixed-separators', `table mixes separator styles: ${Array.from(seen).join(', ')}. Keep one`, node);
     }
 }
 // Rule 4 — replace =table with =code block. Used when a referenced =data
@@ -448,9 +460,41 @@ const wrapImplicitCells = rowNode => {
     });
     return { ...rowNode, content: wrapped };
 };
+// An abbreviated `=for row` owns its own paragraph, so cells written under it
+// stay at table level and both the row and the cells lose their meaning. They
+// are attached to the row above, and the author is told, per the same recovery
+// contract that pads and truncates rows.
+const attachOrphanCells = (tableNode, report = noReport) => {
+    const content = tableNode.content;
+    if (!Array.isArray(content))
+        return tableNode;
+    if (!content.some(c => c && c.type === 'block' && c.name === 'cell'))
+        return tableNode;
+    const out = [];
+    let openRow = null;
+    for (const child of content) {
+        if (child && child.type === 'block' && child.name === 'row') {
+            openRow = { ...child, content: Array.isArray(child.content) ? [...child.content] : [] };
+            out.push(openRow);
+            continue;
+        }
+        if (child && child.type === 'block' && child.name === 'cell') {
+            if (!openRow) {
+                openRow = { type: 'block', name: 'row', margin: child.margin || '', content: [] };
+                out.push(openRow);
+            }
+            openRow.content.push(child);
+            continue;
+        }
+        out.push(child);
+    }
+    report('table-cell-outside-row', 'a cell written outside a row was attached to the row above it; an abbreviated =for row holds only its own paragraph, so write =begin row and =end row around the cells', tableNode);
+    return { ...tableNode, content: out };
+};
 const isStructured = tableNode => Array.isArray(tableNode.content) &&
     tableNode.content.some(c => c && c.type === 'block' && (c.name === 'row' || c.name === 'cell'));
-exports.default = () => tree => {
+exports.default = (opt = {}) => tree => {
+    const report = makeTableReport(opt);
     const transformer = (0, makeTransformer_1.default)({
         table: (node, ctx, visiter) => {
             // CSV/data source reference (spec §1672):
@@ -461,9 +505,12 @@ exports.default = () => tree => {
                 const dataBlock = findDataBlockByKey(tree, ref.target);
                 if (!dataBlock) {
                     // Rule 4: source not found → empty table (still a =table block)
-                    console.warn(`[table] no =data block found for data:${ref.target} — rendered as empty`);
+                    report('table-source-unreadable', `no =data block found for data:${ref.target}, table rendered as empty`, node);
                     return { ...node, content: [] };
                 }
+                // whatever is built out of a covered =data block is covered as well,
+                // otherwise the table is a way to read what the cover hides
+                const carryCover = built => (0, config_1.default)(dataBlock, {}).getFirstValue('masked') ? { ...built, guarded: true } : built;
                 const rawMime = (0, config_1.default)(dataBlock, {}).getFirstValue('mime-type');
                 const { type: mimeType, params: mimeParams } = parseMimeType(rawMime);
                 const isCsv = mimeType === 'text/csv';
@@ -472,22 +519,23 @@ exports.default = () => tree => {
                     const text = extractDataText(dataBlock);
                     const rows = isCsv ? parseCsv(text) : parseTsv(text);
                     if (rows.length === 0) {
-                        console.warn(`[table] ${isCsv ? 'CSV' : 'TSV'} parse produced no rows for data:${ref.target} — rendered as empty`);
+                        report('table-source-unreadable', `${isCsv ? 'CSV' : 'TSV'} source data:${ref.target} has no rows, table rendered as empty`, node);
                         return { ...node, content: [] };
                     }
                     const hasHeader = mimeParams.header === 'present';
                     const allow = (0, config_1.default)(node, {}).getAllValues('allow');
                     const filledNode = { ...node, content: csvToTableContent(rows, hasHeader, allow) };
-                    return normalizeCellCounts(filledNode, `table data:${ref.target}`);
+                    return carryCover(normalizeCellCounts(filledNode, `table data:${ref.target}`, report));
                 }
                 // Rule 4: source not tabular → render as code block so content remains visible
-                console.warn(`[table] =data :key<${ref.target}> has non-tabular mime-type ${rawMime || '(none)'} — rendered as =code`);
-                return buildCodeFromDataBlock(node, dataBlock);
+                report('table-source-unreadable', `=data :key<${ref.target}> has non-tabular mime-type ${rawMime || '(none)'}, rendered as =code`, node);
+                return carryCover(buildCodeFromDataBlock(node, dataBlock));
             }
             // structured mode: transform row children (wrap implicit cells), then
             // apply Rule 2 cell count normalization.
             if (isStructured(node)) {
-                const transformedContent = (node.content || []).map(c => {
+                const attached = attachOrphanCells(node, report);
+                const transformedContent = (attached.content || []).map(c => {
                     if (c && c.name === 'row')
                         return wrapImplicitCells(c);
                     return c;
@@ -495,7 +543,7 @@ exports.default = () => tree => {
                 // a matched rule replaces the node without descending, so recurse
                 // here or tables nested inside cells keep their raw text rows
                 const recursed = visiter ? visiter(transformedContent, ctx) : transformedContent;
-                return normalizeCellCounts({ ...node, content: recursed }, 'table');
+                return normalizeCellCounts({ ...attached, content: recursed }, 'table', report);
             }
             let rows = [];
             const collectValues = row => {
@@ -521,7 +569,7 @@ exports.default = () => tree => {
             const lines = flattenDeep(rows.map(splitToLines));
             const separators = flattenDeep(seps.map(splitToLines));
             // Rule 3: warn on mixed separator types within a single table
-            detectMixedSeparators(lines);
+            detectMixedSeparators(lines, report, node);
             // collect text rows
             let textRows = [];
             (0, makeTransformer_1.default)({
@@ -560,7 +608,7 @@ exports.default = () => tree => {
                 },
                 'head:text': head => makeHeaderRow(splitToCells(head.value).map(makeCell)),
             })(node);
-            return normalizeCellCounts(res, 'table');
+            return normalizeCellCounts(res, 'table', report);
         },
     });
     return transformer(tree, {});

package/lib/selectors.d.ts

@@ -31,4 +31,5 @@ export type ParsedSelector = {
     patterns: Pattern[];
 };
 export declare const parseSelector: (selector: string) => ParsedSelector | undefined;
+export declare const filePathMatches: (docFile: string, target: string) => boolean;
 export declare const runSelector: <T extends SelectorDoc>(selector: string, docs: T[]) => T[] | PodNode[];

package/lib/selectors.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runSelector = exports.parseSelector = void 0;
+exports.runSelector = exports.filePathMatches = exports.parseSelector = void 0;
 const index_1 = require("./index");
+const parseAttributes_1 = require("./helpers/parseAttributes");
 // --- predicate parser ---------------------------------------------------
 const isIdentStart = (c) => /[a-zA-Z_]/.test(c);
 const isIdentCont = (c) => /[a-zA-Z0-9_-]/.test(c);
@@ -229,6 +230,39 @@ const parseSelector = (selector) => {
     return undefined;
 };
 exports.parseSelector = parseSelector;
+// The operand is read by the same grammar as a declaration: the delimiters
+// around it decide whether it is a string, a list or a number. Reading it as
+// raw text would put values out of reach that a document can hold — a quoted
+// string among them.
+const readOperand = (raw) => {
+    const [item] = (0, parseAttributes_1.parseAttributes)(`:x<${raw}>`);
+    return item ? { value: item.value, type: item.type } : undefined;
+};
+// The declared value with its kind kept. makeAttrs flattens a list into the
+// surrounding values, which loses the very thing equality compares.
+const declaredValue = (node, name, ctx) => {
+    const anyNode = node;
+    const own = (Array.isArray(anyNode.config) ? anyNode.config : []).find(c => c && c.name === name);
+    if (own)
+        return { value: own.value, type: own.type };
+    const configured = (anyNode.name && ctx.config?.[anyNode.name]) || [];
+    const inherited = configured.find(c => c && c.name === name);
+    return inherited ? { value: inherited.value, type: inherited.type } : undefined;
+};
+const sameScalar = (a, b) => typeof a === typeof b && a === b;
+// A list equals another list when their elements match one by one, in order; a
+// value of one kind never equals a value of another.
+const sameValue = (a, b) => {
+    if (Array.isArray(a.value) || Array.isArray(b.value)) {
+        if (!Array.isArray(a.value) || !Array.isArray(b.value))
+            return false;
+        return a.value.length === b.value.length && a.value.every((item, i) => sameScalar(item, b.value[i]));
+    }
+    return sameScalar(a.value, b.value);
+};
+// Membership runs over the values as declared. A string is one value, even
+// when it holds spaces, so a word taken from its middle is not a member.
+const valuesOf = (typed) => (Array.isArray(typed.value) ? typed.value : [typed.value]);
 const matchCondition = (node, cond, ctx) => {
     const attrs = (0, index_1.makeAttrs)(node, ctx);
     const exists = attrs.exists(cond.attrName);
@@ -244,30 +278,19 @@ const matchCondition = (node, cond, ctx) => {
                 return !exists;
         }
     }
+    const declared = declaredValue(node, cond.attrName, ctx);
+    const operand = readOperand(cond.valueSpec.value);
     if (cond.valueSpec.kind === 'angle') {
-        if (!exists)
+        if (!exists || !declared || !operand)
             return false;
-        const equal = String(attrs.getFirstValue(cond.attrName)) === cond.valueSpec.value;
+        const equal = sameValue(declared, operand);
         return cond.modifier === '!' ? !equal : equal;
     }
     if (cond.valueSpec.kind === 'contains') {
-        if (!exists)
+        if (!exists || !declared || !operand)
             return false;
-        // Author-facing semantics: `:tags<a b c>` is a list of three elements.
-        // Grammar parses unquoted identifier sequences as a single string, so
-        // split string values on whitespace/comma to recover list shape.
-        const tokens = [];
-        for (const v of attrs.getAllValues(cond.attrName)) {
-            if (typeof v === 'string') {
-                for (const t of v.split(/[\s,]+/))
-                    if (t)
-                        tokens.push(t);
-            }
-            else {
-                tokens.push(String(v));
-            }
-        }
-        const present = tokens.includes(cond.valueSpec.value);
+        const values = valuesOf(declared);
+        const present = valuesOf(operand).every(wanted => values.some(held => sameScalar(held, wanted)));
         return cond.modifier === '!' ? !present : present;
     }
     return false;
@@ -388,6 +411,7 @@ const filePathMatches = (docFile, target) => {
     }
     return a === b || a.endsWith('/' + b) || b.endsWith('/' + a);
 };
+exports.filePathMatches = filePathMatches;
 const getDocIDs = (doc) => {
     const ids = [];
     (0, index_1.getFromTree)(doc.node, 'NAME', 'TITLE').forEach(block => {
@@ -421,7 +445,7 @@ const runSelector = (selector, docs) => {
         matchedDocs = docs.filter(doc => getDocIDs(doc).includes(document));
     }
     else if (scheme === 'file' && document) {
-        matchedDocs = docs.filter(doc => filePathMatches(doc.file, document));
+        matchedDocs = docs.filter(doc => (0, exports.filePathMatches)(doc.file, document));
     }
     else if (scheme && scheme !== 'doc' && scheme !== 'file') {
         return [];

package/lib/types.d.ts

@@ -98,6 +98,7 @@ export interface Image {
     type: 'image';
     src: string;
     alt?: string;
+    link?: string;
 }
 export interface Toc {
     type: 'toc';
@@ -139,7 +140,7 @@ export interface RootBlock extends Omit<Block, 'location'> {
 }
 export interface ParseDiagnostic {
     severity: 'warning';
-    code: 'value-unreadable' | 'directive-unreadable';
+    code: 'value-unreadable' | 'directive-unreadable' | 'table-row-cells' | 'table-cell-outside-row' | 'table-mixed-separators' | 'table-source-unreadable';
     message: string;
     location: Location;
 }
@@ -245,10 +246,12 @@ export interface Ambient {
 export interface Verbatim {
     type: 'verbatim';
     value: string;
+    guarded?: boolean;
 }
 export interface Text {
     type: 'text';
     value: string;
+    guarded?: boolean;
 }
 export interface Para {
     type: 'para';
@@ -308,6 +311,7 @@ export interface Block {
     margin: string;
     config?: Array<ConfigItem | BrokenConfigItem>;
     id?: string;
+    guarded?: boolean;
 }
 export interface BlockPod extends Block {
     name: 'pod';
@@ -364,7 +368,7 @@ export interface BlockTable extends Omit<Block, 'content'> {
 export interface TableCell {
     name: 'cell';
     type: 'block';
-    content: Array<string>;
+    content: Array<PodNode>;
 }
 export interface TableRow {
     name: 'row';