rapier-markdown-kit 1.1.0

package/dist/spec/md-assets.mjs

@@ -0,0 +1,323 @@
+// SPDX-License-Identifier: MIT
+// Pure text and markdown-it tokens: no DOM, no byte decoding, no globalThis.Rapier* (MIT kit; decoders stay in images/assets.mjs).
+
+export const IMAGE_LIMITS = Object.freeze({bytes: 16 * 1024 * 1024, sourceChars: 25 * 1024 * 1024, dimension: 16384, pixels: 24000000, assets: 1024});
+const parsers = new WeakMap();
+const cached = [];
+let configured = null, splitSource = null;
+export function configureParser(parser, split) { configured = parser; splitSource = split; cached.length = 0; }
+function fail(reason) { throw new Error(reason); }
+export const normalizeLabel = label => String(label).trim().replace(/\s+/g, ' ').toLowerCase().toUpperCase();
+// New titles have one identity before hashing, serializing or matching a repeated append.
+// Existing document bytes are never rewritten; CommonMark entity decoding must not change a title.
+export const assetTitle = value => String(value || '').replace(/[\r\n]/g, ' ').replace(/\0/g, '\ufffd');
+
+// The same hook runs in the editor, its parse worker and the agent's parser.
+export function installMarkdownImages(md) {
+  if (md.__rapierImagesInstalled) return md;
+  md.__rapierImagesInstalled = true;
+  const validate = md.validateLink;
+  md.validateLink = url => /^data:image\/(?:jxl|svg\+xml);base64,[A-Za-z0-9+/]+={0,2}$/i.test(url) || validate(url);
+  const reference = md.block.ruler.__rules__.find(row => row.name === 'reference').fn;
+  md.block.ruler.at('reference', (state, start, end, silent) => {
+    if (silent) return reference(state, start, end, silent);
+    const saved = state.env.references, local = Object.create(null);
+    state.env.references = local;
+    let accepted;
+    try { accepted = reference(state, start, end, false); }
+    finally { state.env.references = saved; }
+    if (accepted) {
+      const token = state.tokens[state.tokens.length - 1], label = token.meta.label;
+      token.meta.mdImageDefinition = local[label];
+      const refs = state.env.references ||= Object.create(null);
+      if (!Object.hasOwn(refs, label)) refs[label] = local[label];
+    }
+    return accepted;
+  });
+  const image = md.inline.ruler.__rules__.find(row => row.name === 'image').fn;
+  md.inline.ruler.at('image', (state, silent) => {
+    const start = state.pos;
+    if (state.src[start] !== '!' || state.src[start + 1] !== '[') return false;
+    const close = state.md.helpers.parseLinkLabel(state, start + 1, false);
+    const before = state.tokens.length;
+    if (!image(state, silent)) return false;
+    if (!silent && state.tokens.length > before) {
+      const token = state.tokens[state.tokens.length - 1], source = state.src.slice(start, state.pos);
+      if (token.type === 'image') {
+        let reference = null;
+        if (close >= 0 && state.src[close + 1] !== '(') {
+          const explicit = state.src[close + 1] === '[' ? state.src.slice(close + 2, state.pos - 1) : '';
+          reference = md.utils.normalizeReference(explicit || state.src.slice(start + 2, close));
+        }
+        (token.meta ||= {}).mdImage = {source, reference};
+      }
+    }
+    return true;
+  });
+  return md;
+}
+
+function parserFor(factory = configured || globalThis.markdownit) {
+  if (factory?.block && factory?.utils) return factory;
+  if (configured && factory === globalThis.markdownit) return configured;
+  if (typeof factory !== 'function') return fail('markdown_parser_unavailable');
+  let parser = parsers.get(factory);
+  if (!parser) { parser = installMarkdownImages(factory({html: true, maxNesting: 20})); parsers.set(factory, parser); }
+  return parser;
+}
+export {parserFor as markdownParser};
+export const markdownBodyOffset = source => splitSource ? splitSource(source).bodyOffset : 0;
+
+export function dataImage(url) {
+  if (typeof url !== 'string' || url.length > IMAGE_LIMITS.sourceChars) return null;
+  const match = /^data:(image\/(?:jxl|png|jpeg|webp|svg\+xml));base64,([A-Za-z0-9+/]+={0,2})$/i.exec(url);
+  if (!match || match[2].length % 4) return null;
+  const padding = match[2].endsWith('==') ? 2 : match[2].endsWith('=') ? 1 : 0;
+  const byteLength = match[2].length / 4 * 3 - padding;
+  if (!byteLength || byteLength > IMAGE_LIMITS.bytes) return null;
+  return {codec: match[1].toLowerCase(), byteLength, payloadStart: match[0].length - match[2].length};
+}
+
+// Markdown-it owns recognition, nesting, duplicate precedence and escapes; block parse only.
+export function parseAssets(source, factory = configured || globalThis.markdownit, bodyOffset = 0) {
+  if (typeof source !== 'string') return fail('image_source_invalid');
+  if (source.length > IMAGE_LIMITS.sourceChars) return fail('image_source_limit');
+  if (!source.includes(']:')) return {assets: new Map(), blocks: [], duplicateLabels: new Set(), appendixStart: source.length, references: Object.create(null)};
+  const prior = cached.find(row => row.source === source && row.factory === factory && row.bodyOffset === bodyOffset);
+  if (prior) return prior.index;
+  const parser = parserFor(factory), env = {}, tokens = [];
+  const starts = [bodyOffset];
+  for (let at = bodyOffset; at < source.length; at++) {
+    if (source[at] === '\r') { if (source[at + 1] === '\n') at++; starts.push(at + 1); }
+    else if (source[at] === '\n') starts.push(at + 1);
+  }
+  parser.block.parse(source.slice(bodyOffset).replace(/\r\n?/g, '\n').replace(/\0/g, '\ufffd'), parser, env, tokens);
+  const references = env.references || Object.create(null), assets = new Map(), blocks = [], seen = new Set(), duplicateLabels = new Set();
+  for (const token of tokens) {
+    if (token.type !== 'reference_definition' || !token.map) continue;
+    const id = token.meta.label, definition = token.meta.mdImageDefinition, first = !seen.has(id);
+    if (!first) duplicateLabels.add(id);
+    seen.add(id);
+    const info = dataImage(definition?.href);
+    if (!info) continue;
+    const start = starts[token.map[0]], stop = starts[token.map[1]] ?? source.length;
+    let end = stop;
+    if (source[end - 1] === '\n') end--;
+    if (source[end - 1] === '\r') end--;
+    // Repeated definitions are source, not additional image owners.
+    const raw = source.slice(start, end), found = raw.indexOf(definition.href);
+    const repeated = found >= 0 ? raw.indexOf(definition.href, found + 1) : -1;
+    const labelContainsUrl = definition.href.length <= id.length && id.includes(parser.utils.normalizeReference(definition.href));
+    const urlStart = found >= 0 && repeated < 0 && !labelContainsUrl ? start + found : null;
+    const row = {id, label: id, source: raw, url: definition.href, title: definition.title || '', start, end,
+      ...info, urlStart, urlEnd: urlStart == null ? null : urlStart + definition.href.length,
+      payloadStart: urlStart == null ? null : urlStart + info.payloadStart, payloadEnd: urlStart == null ? null : urlStart + definition.href.length, status: 'unverified', active: first, topLevel: token.level === 0};
+    blocks.push(row);
+    if (first) assets.set(id, row);
+  }
+  if (assets.size > IMAGE_LIMITS.assets) for (const asset of assets.values()) asset.status = 'asset_count_limit';
+  let appendixStart = source.length;
+  for (let index = blocks.length - 1; index >= 0; index--) {
+    const block = blocks[index];
+    if (!block.active || !block.topLevel || !/^[ \t\r\n]*$/.test(source.slice(block.end, appendixStart))) break;
+    appendixStart = block.start;
+  }
+  const index = {assets, blocks, duplicateLabels, appendixStart, references};
+  cached.unshift({source, factory, bodyOffset, index});
+  if (cached.length > 3) cached.pop();
+  return index;
+}
+export function documentAssets(source, factory) { return parseAssets(source, factory, markdownBodyOffset(source)); }
+export function imageEnvironment(source, factory) { return {references: Object.assign(Object.create(null), documentAssets(source, factory).references)}; }
+
+function imageUses(source, factory, env = {}) {
+  const parser = parserFor(factory), offset = markdownBodyOffset(source), starts = [offset], normalized = [0];
+  let position = 0;
+  for (let at = offset; at < source.length; at++, position++) {
+    if (source[at] === '\r') { if (source[at + 1] === '\n') at++; }
+    else if (source[at] !== '\n') continue;
+    starts.push(at + 1); normalized.push(position + 1);
+  }
+  const originalOffset = at => {
+    let low = 0, high = normalized.length;
+    while (low + 1 < high) {
+      const mid = (low + high) >>> 1;
+      if (normalized[mid] <= at) low = mid; else high = mid;
+    }
+    return starts[low] + at - normalized[low];
+  };
+  const body = source.slice(offset).replace(/\r\n?/g, '\n').replace(/\0/g, '\ufffd');
+  const tokens = parser.parse(body, env), urls = new Set(), images = [], html = [];
+  const visit = rows => {
+    for (const token of rows || []) {
+      if (token.type === 'image') urls.add(token.attrGet('src'));
+      if (token.type === 'link_open') urls.add(token.attrGet('href'));
+      if (token.type === 'html_inline' || token.type === 'html_block') html.push(parser.utils.unescapeAll(token.content));
+      if (token.children) visit(token.children);
+    }
+  };
+  visit(tokens);
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index], map = token.map || tokens[index - 1]?.map;
+    if (token.type !== 'inline' || !map) continue;
+    const groups = new Map();
+    for (const image of token.children || []) {
+      const meta = image.type === 'image' && image.meta?.mdImage;
+      if (!meta?.source) continue;
+      if (!groups.has(meta.source)) groups.set(meta.source, []);
+      groups.get(meta.source).push({id: meta.reference, url: image.attrGet('src')});
+    }
+    const start = normalized[map[0]], end = normalized[map[1]] ?? body.length;
+    if (!Number.isSafeInteger(start) || end <= start) continue;
+    for (const [raw, rows] of groups) {
+      const found = [];
+      for (let at = body.indexOf(raw, start); at >= 0 && at + raw.length <= end; at = body.indexOf(raw, at + raw.length)) found.push(at);
+      // Repeated text in code or an unmapped container is not deletion proof.
+      if (found.length !== rows.length) continue;
+      found.forEach((at, index) => images.push({...rows[index], start: originalOffset(at), end: originalOffset(at + raw.length)}));
+    }
+  }
+  const simple = tokens.length === 3 && tokens[1].type === 'inline' && tokens[1].level === 1 &&
+    images.length === (tokens[1].children || []).filter(row => row.type === 'image').length;
+  return {urls, images, simple, html: html.join('\n').toUpperCase()};
+}
+
+// A parse failure answers true: uncertainty keeps the definition.
+export function referenceOccurs(source, id, factory) {
+  try { return imageUses(source, factory).images.some(image => image.id === id); }
+  catch (_) { return true; }
+}
+
+function occurrenceChange(image, splices) {
+  let {start, end} = image, changed = false;
+  for (const row of splices) {
+    const stop = row.pos + row.removed.length;
+    if (row.pos <= start && stop >= end && stop > row.pos) return true;
+    const shift = row.inserted.length - row.removed.length;
+    if (stop <= start) { start += shift; end += shift; continue; }
+    if (row.pos > end || row.pos === end && row.removed.length) continue;
+    if (row.pos < start || stop > end) return null;
+    changed = true; end += shift;
+  }
+  return changed ? {start, end} : null;
+}
+
+// A permissive gate keeps ordinary typing out of full-document image parsing.
+// Recognition and retirement proof still belong to Markdown-it below.
+export function mayRetireImageDefinitions(source, splices, factory) {
+  if (!/data:image\//i.test(source)) return false;
+  const original = (at, right, count) => {
+    for (let index = count - 1; index >= 0; index--) {
+      const row = splices[index], end = row.pos + row.inserted.length;
+      if (at >= end) at += row.removed.length - row.inserted.length;
+      else if (at > row.pos) at = row.pos + (right ? row.removed.length : 0);
+    }
+    return at;
+  };
+  const possible = splices.some((row, index) => {
+    if (!row.removed && !row.inserted) return false;
+    const start = original(row.pos, false, index), end = original(row.pos + row.removed.length, true, index);
+    const image = source.lastIndexOf('![', end);
+    return image >= 0 && (image >= start || Math.max(source.lastIndexOf('\n\n', start),
+      source.lastIndexOf('\r\n\r\n', start), source.lastIndexOf('\r\r', start)) < image);
+  });
+  if (!possible || splices.length !== 1) return possible;
+  const row = splices[0];
+  if (row.removed.includes('![') || /[\r\n]/.test(row.removed) || /[\r\n]/.test(row.inserted)) return true;
+  const start = row.pos ? Math.max(source.lastIndexOf('\n', row.pos - 1), source.lastIndexOf('\r', row.pos - 1)) + 1 : 0;
+  let end = source.length;
+  for (const eol of ['\r', '\n']) { const at = source.indexOf(eol, row.pos); if (at >= 0) end = Math.min(end, at); }
+  if (end - start > 8192 || row.pos + row.removed.length > end ||
+      start !== markdownBodyOffset(source) && !/(?:\n\n|\r\n\r\n|\r\r)$/.test(source.slice(Math.max(0, start - 4), start)) ||
+      end !== source.length && !/^(?:\n\n|\r\n\r\n|\r\r)/.test(source.slice(end, end + 4))) return true;
+  try {
+    const local = imageUses(source.slice(start, end), factory, imageEnvironment(source, factory));
+    return !local.simple || local.images.some(image => occurrenceChange({...image,
+      start: start + image.start, end: start + image.end}, splices));
+  } catch (_) { return true; }
+}
+
+// Whole deletion or a valid replacement at the rebased occurrence may retire
+// bytes. Unfinished source edits and pre-existing unused definitions do not.
+export function retireDeletedImageDefinitions(before, after, splices, factory) {
+  if (before === after || !mayRetireImageDefinitions(before, splices, factory)) return [];
+  try {
+    const prior = documentAssets(before, factory), current = documentAssets(after, factory);
+    if (!prior.assets.size || !current.assets.size) return [];
+    const changes = imageUses(before, factory).images.filter(image => image.id)
+      .map(image => ({image, change: occurrenceChange(image, splices)})).filter(row => row.change);
+    if (!changes.length) return [];
+    const now = imageUses(after, factory);
+    const deleted = new Set(changes.filter(({image, change}) => change === true || now.images.some(row =>
+      row.start === change.start && row.end === change.end && row.url !== image.url)).map(row => row.image.id));
+    if (!deleted.size) return [];
+    let remaining = '', at = 0;
+    for (const row of current.blocks) { remaining += after.slice(at, row.start); at = row.end; }
+    remaining = normalizeLabel(remaining + after.slice(at)).replace(/\[\s+/g, '[');
+    return current.blocks.filter(row => {
+      const old = prior.assets.get(row.id);
+      return deleted.has(row.id) && row.active && row.topLevel && old?.topLevel &&
+        row.status === 'unverified' && old.source === row.source && !now.urls.has(row.url) &&
+        !prior.duplicateLabels.has(row.id) && !current.duplicateLabels.has(row.id) &&
+        !remaining.includes('[' + row.id) && !now.html.includes(row.id) && !now.html.includes(row.url.toUpperCase());
+    }).sort((a, b) => b.start - a.start).map(row => ({pos: row.start, removed: row.source, inserted: ''}));
+  } catch (_) { return []; }
+}
+
+// Disclosure stays conservative even for code examples and malformed definitions.
+// Keep labels and readable prose; omit only the binary destination.
+export function assetOmissions(source) {
+  if (typeof source !== 'string') return [];
+  const pattern = /data:(image\/[a-z0-9.+-]+);base64,[A-Za-z0-9+/=\\;&%#._~-]*/ig, spans = [];
+  for (let match; (match = pattern.exec(source));) {
+    const value = match[0], payload = value.slice(value.indexOf(',') + 1);
+    const bytes = payload.length % 4 === 0 && /^[A-Za-z0-9+/]+={0,2}$/.test(payload)
+      ? payload.length / 4 * 3 - (payload.endsWith('==') ? 2 : payload.endsWith('=') ? 1 : 0) : null;
+    spans.push({start: match.index, end: pattern.lastIndex, chars: value.length,
+      domain: 'image_bytes', reason: 'embedded_asset', profile: 'embedded', type: match[1].toLowerCase(), bytes});
+  }
+  return spans;
+}
+export function isAssetBlock(raw) {
+  if (typeof raw !== 'string' || !/data:image\//i.test(raw)) return false;
+  const parsed = parseAssets(raw);
+  if (!parsed.blocks.length) return false;
+  let at = 0;
+  for (const block of parsed.blocks) {
+    if (!block.active || !block.topLevel || !/^[ \t\r\n]*$/.test(raw.slice(at, block.start))) return false;
+    at = block.end;
+  }
+  return /^[ \t\r\n]*$/.test(raw.slice(at));
+}
+
+// Mirrors engine.js _rapierEscapeImageAlt without importing the editor bundle.
+export function escapeImageAlt(value) {
+  return String(value ?? '').replace(/[\r\n]+/g, ' ')
+    .replace(/[\\[\]*_`~^+$=<&]/g, '\\$&').replace(/\|(?=[1-9]\d{1,3}$)/, '\\|');
+}
+export function serializeAsset(asset) {
+  if (!asset || !/^[a-z0-9-]+$/i.test(asset.label) || !dataImage(asset.url)) return fail('image_metadata_invalid');
+  const value = assetTitle(asset.title), title = value ? ' "' + value.replace(/&/g, '&amp;').replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"' : '';
+  return '[' + asset.label + ']: ' + asset.url + title;
+}
+// Pure: re-derived at commit against the moved document; appends only at the text's end (docs/kernel.md).
+export function appendAssetText(source, asset) {
+  if (typeof source !== 'string' || !asset || normalizeLabel(asset.label) !== asset.id) return fail('image_source_invalid');
+  const parsed = documentAssets(source), title = assetTitle(asset.title);
+  const existing = [...parsed.assets.values()].find(row => row.url === asset.url && row.title === title);
+  if (existing) return {source, id: existing.id, reference: existing.label, added: false, suffix: ''};
+  const previous = parsed.references[asset.id];
+  const block = serializeAsset(asset);
+  if (previous) {
+    if (previous.href !== asset.url || (previous.title || '') !== title) return fail('image_label_conflict');
+    return {source, id: asset.id, reference: asset.label, added: false, suffix: ''};
+  }
+  if (parsed.assets.size >= IMAGE_LIMITS.assets) return fail('image_asset_count_limit');
+  const eol = /\r\n|\n|\r/.exec(source)?.[0] || '\n', tail = /(?:\r\n?|\n)[ \t]*$/.exec(source);
+  const separator = !source || tail && /[\r\n][ \t]*$/.test(source.slice(0, tail.index)) ? '' : tail ? eol : eol + eol;
+  const suffix = separator + block + eol, nextSource = source + suffix;
+  if (nextSource.length > IMAGE_LIMITS.sourceChars) return fail('image_source_limit');
+  if (documentAssets(nextSource).references[asset.id]?.href !== asset.url) return fail('image_appendix_not_available');
+  return {source: nextSource, id: asset.id, reference: asset.label, added: true, suffix};
+}
+export async function appendAsset(source, asset) { return appendAssetText(source, asset); }

package/dist/spec/md-layout.mjs

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: MIT
+
+// `rotate`: degrees in (-180, 180], one decimal, omitted when 0; never written for a Rapier drawing (its turn lives in its SVG).
+export const fields = new Set(['align', 'width', 'wrap', 'x', 'y', 'rotate']);
+export const alignments = new Set(['left', 'center', 'right', 'justify']);
+// `behind`/`front`: out of flow; the paragraph lays out as though the picture were absent.
+export const wraps = new Set(['around', 'box', 'behind', 'front']);
+const has = (value, key) => Object.hasOwn(value, key);
+const percent = value => typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 100;
+const oneDecimalDegrees = value => typeof value === 'number' && Number.isFinite(value) &&
+  value > -180 && value <= 180 && Math.abs(value * 10 - Math.round(value * 10)) < 1e-9;
+
+/** Validate values independently of their Markdown attachment context. */
+export function validLayout(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value) ||
+      Object.keys(value).some(key => !fields.has(key))) return false;
+  return (!has(value, 'align') || alignments.has(value.align)) &&
+    (!has(value, 'width') || percent(value.width) && value.width > 0) &&
+    (!has(value, 'wrap') || wraps.has(value.wrap)) &&
+    (!has(value, 'x') || percent(value.x) && (has(value, 'wrap') || has(value, 'width'))) &&
+    (!has(value, 'y') || typeof value.y === 'number' && Number.isFinite(value.y) && value.y >= -50 && has(value, 'wrap')) &&
+    (!has(value, 'rotate') || oneDecimalDegrees(value.rotate)) &&
+    !(has(value, 'align') && (has(value, 'wrap') || has(value, 'x')));
+}
+
+/** Parse the closed v1 grammar. Geometry values are returned as numbers. */
+export function parseLayout(comment) {
+  if (typeof comment !== 'string' || /[^\t\x20-\x7e]/.test(comment)) return null;
+  const match = /^<!--md-layout:v1[ \t]+([^\r\n]*?)[ \t]*-->$/.exec(comment);
+  if (!match) return null;
+  const pairs = match[1].replace(/^[ \t]+|[ \t]+$/g, '').split(/[ \t]+/), value = {};
+  if (pairs.length > fields.size) return null;
+  for (const pair of pairs) {
+    const field = /^([a-z]+)=(.+)$/.exec(pair);
+    if (!field || !fields.has(field[1]) || has(value, field[1])) return null;
+    const [, key, raw] = field;
+    if (key === 'width' || key === 'x') {
+      const number = /^(0|[1-9]\d*)(?:\.(\d+))?%$/.exec(raw);
+      if (!number || number[1].length > 3 || Number(number[1]) > 100 ||
+          number[1] === '100' && /[1-9]/.test(number[2] || '')) return null;
+      value[key] = Number(raw.slice(0, -1));
+    } else if (key === 'y') {
+      // Negative allowed; signed like rotate, never "-0em".
+      const number = /^(-)?(0|[1-9]\d*)(?:\.\d+)?em$/.exec(raw);
+      if (!number || (number[1] && Number(raw.slice(1, -2)) === 0)) return null;
+      value.y = Number(raw.slice(0, -2));
+    } else if (key === 'rotate') {
+      // No '+', exponent, '°' or "-0deg"; 0 is unsigned.
+      const number = /^(-)?(0|[1-9]\d*)(?:\.(\d))?deg$/.exec(raw);
+      if (!number) return null;
+      const magnitude = Number(number[2] + (number[3] ? '.' + number[3] : ''));
+      if (number[1] && magnitude === 0) return null;
+      value.rotate = number[1] ? -magnitude : magnitude;
+    } else value[key] = raw;
+  }
+  return validLayout(value) ? value : null;
+}
+
+// Comment delimiters are unsafe in sanitized attributes. Markdown stays literal;
+// rendered attributes carry encodeURIComponent(marker), including its '%' signs.
+export function decodeLayoutAttribute(value) {
+  try { return decodeURIComponent(value || ''); } catch (_) { return ''; }
+}
+
+export const parseLayoutAttribute = value => parseLayout(decodeLayoutAttribute(value));
+
+export function imageStyle(value) {
+  if (!validLayout(value) || value.width == null) return '';
+  const width = value.width;
+  const left = value.x == null ? '' : ';display:block;margin-left:' +
+    decimal(Number(Math.max(0, Math.min(100 - width, value.x - width / 2)).toFixed(6))) + '%;margin-right:0';
+  return 'width:' + decimal(width) + '%;height:auto' + left;
+}
+
+// The one wrap-owner rule (layout/browser.js, layout/interchange.js, editor/share.js): prose after, else before, skipping pictures,
+// metadata and empty paragraphs; any other block is a barrier in that direction.
+export function wrapNeighbour(node, classify) {
+  for (const step of [n => n && n.nextElementSibling, n => n && n.previousElementSibling]) {
+    for (let sibling = step(node); sibling; sibling = step(sibling)) {
+      const kind = classify(sibling);
+      if (kind && typeof kind === 'object') return kind.stop;
+      if (kind === 'metadata') continue;
+      if (kind === 'prose') return sibling;
+      if (kind !== 'picture') break;
+    }
+  }
+  return null;
+}
+
+// Narrower than this, a line breaker splits words letter by letter.
+export function wrapColumnFloor(fontSize) {
+  return Math.max(40, 3.5 * (fontSize || 16));
+}
+
+function decimal(value) {
+  if (value < 0) return '-' + decimal(-value);
+  const text = String(value);
+  if (!text.includes('e')) return text;
+  const [mantissa, exponent] = text.split('e');
+  const digits = mantissa.replace('.', '');
+  const point = (mantissa.includes('.') ? mantissa.indexOf('.') : mantissa.length) + Number(exponent);
+  if (point <= 0) return '0.' + '0'.repeat(-point) + digits;
+  if (point >= digits.length) return digits + '0'.repeat(point - digits.length);
+  return digits.slice(0, point) + '.' + digits.slice(point);
+}
+
+/** Write only the supplied facts; no alignment is implied by absence. */
+export function formatLayout(value) {
+  if (!validLayout(value)) throw new TypeError('invalid_markdown_layout');
+  const pairs = [];
+  for (const key of fields) {
+    if (has(value, key) && !(key === 'y' && value.y === 0) && !(key === 'rotate' && value.rotate === 0)) pairs.push(key + '=' +
+      (key === 'width' || key === 'x' ? decimal(value[key]) + '%' : key === 'y' ? decimal(value.y) + 'em' :
+        key === 'rotate' ? decimal(value.rotate) + 'deg' : value[key]));
+  }
+  return pairs.length ? '<!--md-layout:v1 ' + pairs.join(' ') + '-->' : '';
+}

package/dist/spec/md-marks.mjs

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: MIT
+// The one place these literal grammars are written (docs/markdown-standard.md, "Text colour", "Page break").
+
+const TEXT_COLOR_NAMES = Object.freeze({ green: '#1c7547', red: '#b32034', blue: '#175dc4', gold: '#865818', purple: '#7924d7' });
+const TEXT_COLOR_HEX_TO_NAME = Object.freeze(
+	Object.fromEntries(Object.entries(TEXT_COLOR_NAMES).map(([name, hex]) => [hex, name]))
+);
+const COLOR_NAME_ALT = Object.keys(TEXT_COLOR_NAMES).join('|');
+const COLOR_VALUE = '(?:#[0-9a-f]{6}|' + COLOR_NAME_ALT + ')';
+const COLOR_CLOSE = '<!--/c-->';
+const PAGE_BREAK_MARKER = '<!--md-break:v1 page-->';
+
+export { TEXT_COLOR_NAMES, TEXT_COLOR_HEX_TO_NAME, COLOR_CLOSE, PAGE_BREAK_MARKER };
+
+export function formatColorOpen(hex) {
+	return '<!--c ' + (TEXT_COLOR_HEX_TO_NAME[hex] || hex) + '-->';
+}
+
+export function formatColorRun(hex, content) {
+	return formatColorOpen(hex) + content + COLOR_CLOSE;
+}
+
+// Relocated into the parse Worker by .toString() (engine.js _buildParseWorkerSource): read only parameters, TEXT_COLOR_NAMES and COLOR_CLOSE.
+
+// Returns {hex, length in UTF-16 units} or null; not end-anchored.
+export function matchColorOpen(text) {
+	if (typeof text !== 'string') return null;
+	const match = new RegExp('^<!--c (#[0-9a-f]{6}|' + Object.keys(TEXT_COLOR_NAMES).join('|') + ')-->').exec(text);
+	if (!match) return null;
+	const value = match[1];
+	return { hex: value.charCodeAt(0) === 0x23 /* '#' */ ? value : TEXT_COLOR_NAMES[value], length: match[0].length };
+}
+
+export function parseColorOpen(comment) {
+	if (typeof comment !== 'string') return null;
+	const match = new RegExp('^<!--c (#[0-9a-f]{6}|' + Object.keys(TEXT_COLOR_NAMES).join('|') + ')-->$').exec(comment);
+	if (!match) return null;
+	const value = match[1];
+	return value.charCodeAt(0) === 0x23 /* '#' */ ? value : TEXT_COLOR_NAMES[value];
+}
+
+export function isColorClose(comment) {
+	return comment === COLOR_CLOSE;
+}
+
+export function scanColorMarkers(source) {
+	const text = String(source == null ? '' : source);
+	const scan = new RegExp('<!--c (?:(#[0-9a-f]{6})|(' + COLOR_NAME_ALT + '))-->|<!--/c-->', 'g');
+	const markers = [];
+	let match;
+	while ((match = scan.exec(text))) {
+		const hex = match[1] || (match[2] ? TEXT_COLOR_NAMES[match[2]] : null) || null;
+		markers.push({ start: match.index, end: match.index + match[0].length, hex });
+	}
+	return markers;
+}
+
+export function stripColorMarkers(text) {
+	return String(text == null ? '' : text).replace(new RegExp('<!--(?:c ' + COLOR_VALUE + '|/c)-->', 'g'), '');
+}
+
+export function hasColorMarker(text) {
+	return new RegExp('<!--(?:c ' + COLOR_VALUE + '|/c)-->').test(String(text == null ? '' : text));
+}
+
+// The only spelling.
+export function formatPageBreak() {
+	return PAGE_BREAK_MARKER;
+}
+
+export function isPageBreakLine(text) {
+	return typeof text === 'string' && /^<!--md-break:v1 page-->\r?$/.test(text);
+}
+
+// Also relocated by .toString(); reads only its own regex.
+export function isPageBreakBlock(text) {
+	return typeof text === 'string' && /^<!--md-break:v1 page-->\r?\n?$/.test(text);
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "rapier-markdown-kit",
+  "version": "1.1.0",
+  "description": "The Rapier Markdown standard's layout grammar, occupancy model, line planner, Will grammar and picture appendix -- MIT, no Rapier required.",
+  "author": "Jack Skipworth",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "sideEffects": false,
+  "dependencies": {},
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "./dist/kit/index.mjs",
+  "exports": {
+    ".": "./dist/kit/index.mjs",
+    "./layout": "./dist/kit/layout.mjs",
+    "./marks": "./dist/kit/marks.mjs",
+    "./model": "./dist/kit/model.mjs",
+    "./will": "./dist/kit/will.mjs",
+    "./assets": "./dist/kit/assets.mjs",
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jackskip22/rapier-plugins.git",
+    "directory": "npm/rapier-markdown-kit"
+  }
+}