@jwilleke/ngdpbase-types 0.0.0 → 5.18.0

package/lib/src/converters/IContentConverter.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Content Converter Interface
+ *
+ * Defines the contract that all content converters must implement.
+ * This allows importing content from various wiki formats (JSPWiki, MediaWiki, etc.)
+ * and converting them to Markdown format for ngdpbase.
+ *
+ * @module IContentConverter
+ *
+ * @example
+ * class MyWikiConverter implements IContentConverter {
+ *   readonly formatId = 'mywiki';
+ *   readonly formatName = 'MyWiki';
+ *   readonly fileExtensions = ['.mw'];
+ *
+ *   convert(content: string): ConversionResult {
+ *     // Convert content to Markdown
+ *     return { content: convertedMarkdown, metadata: {}, warnings: [] };
+ *   }
+ *
+ *   canHandle(content: string, filename: string): boolean {
+ *     return filename.endsWith('.mw') || content.includes('{{MyWikiSyntax}}');
+ *   }
+ * }
+ */
+/**
+ * A structured conversion warning (#728 S3). `kind` is a stable, aggregatable
+ * code (the prerequisite for the #738 conversion-metrics work); `detail` is
+ * the human-readable specifics. `kind` is `string` (not an enum) because
+ * converters and NCM each contribute their own codes — `NcmWarning` is an
+ * assignable subset.
+ */
+export interface ConversionWarning {
+    kind: string;
+    detail: string;
+}
+/**
+ * Result of a content conversion operation
+ */
+export interface ConversionResult {
+    /** The converted Markdown content */
+    content: string;
+    /** Extracted metadata (e.g., from JSPWiki [{SET name=value}] attributes) */
+    metadata: Record<string, unknown>;
+    /** Structured warnings generated during conversion (non-fatal issues). */
+    warnings: ConversionWarning[];
+}
+/**
+ * Content converter interface
+ * All format converters must implement these methods
+ */
+export interface IContentConverter {
+    /**
+     * Unique identifier for this converter format
+     * Used for format selection in import options (e.g., 'jspwiki', 'mediawiki')
+     */
+    readonly formatId: string;
+    /**
+     * Human-readable name for this format
+     * Displayed in UI format selection (e.g., 'JSPWiki', 'MediaWiki')
+     */
+    readonly formatName: string;
+    /**
+     * File extensions this converter handles
+     * Used for auto-detection (e.g., ['.txt', '.wiki'])
+     */
+    readonly fileExtensions: string[];
+    /**
+     * Convert content from source format to Markdown
+     *
+     * @param content - The source content to convert
+     * @returns Conversion result with Markdown content, metadata, and warnings
+     */
+    convert(content: string): ConversionResult;
+    /**
+     * Check if this converter can handle the given content
+     * Used for format auto-detection when multiple converters exist
+     *
+     * @param content - The file content to check
+     * @param filename - The filename (for extension checking)
+     * @returns True if this converter can handle the content
+     */
+    canHandle(content: string, filename: string): boolean;
+    /**
+     * #1131: convert a BINARY source (e.g. .docx) — optional; its presence
+     * tells ImportManager to read the file as a Buffer instead of UTF-8 and
+     * call this instead of {@link convert}. The result's `content` may be an
+     * intermediate format (DocxConverter returns HTML) that ImportManager
+     * routes through the NCM normalizer like any other registered source.
+     * Async because binary converters (mammoth) are.
+     */
+    convertBuffer?(buffer: Buffer): Promise<ConversionResult>;
+}
+export default IContentConverter;

package/lib/src/converters/JSPWikiConverter.d.ts

@@ -0,0 +1,117 @@
+/**
+ * JSPWiki to Markdown Converter
+ *
+ * Converts JSPWiki syntax to Markdown format for import into ngdpbase.
+ * Implements IContentConverter interface for use with ImportManager.
+ *
+ * Reference: https://github.com/apache/jspwiki/blob/main/jspwiki-wikipages/en/src/main/resources/TextFormattingRules.txt
+ *
+ * @module JSPWikiConverter
+ */
+import { IContentConverter, ConversionResult } from './IContentConverter.js';
+/**
+ * JSPWiki syntax to Markdown converter
+ */
+declare class JSPWikiConverter implements IContentConverter {
+    readonly formatId = "jspwiki";
+    readonly formatName = "JSPWiki";
+    readonly fileExtensions: string[];
+    /**
+     * Convert JSPWiki content to Markdown
+     *
+     * @param content - JSPWiki formatted content
+     * @returns ConversionResult with Markdown content, metadata, and warnings
+     */
+    convert(content: string): ConversionResult;
+    /**
+     * Check if this converter can handle the given content
+     * Uses filename extension and content pattern detection
+     */
+    canHandle(content: string, filename: string): boolean;
+    /**
+     * Extract [{SET name=value}] attributes and convert to metadata
+     */
+    private extractAttributes;
+    /**
+     * Extract %%category [Name]%% blocks and convert to user-keywords
+     *
+     * JSPWiki uses category blocks for page categorization:
+     *   %%category [CategoryName]%%      - single line, %% closing
+     *   %%category [CategoryName] /%     - may span lines, /% closing
+     *
+     * These are converted to ngdpbase's user-keywords metadata array.
+     */
+    private extractCategories;
+    /**
+     * Convert JSPWiki headings to Markdown
+     * !!! -> # (h1), !! -> ## (h2), ! -> ### (h3)
+     */
+    private convertHeadings;
+    /**
+     * Convert JSPWiki emphasis to Markdown
+     * __bold__ -> **bold**
+     * ''italic'' -> *italic*
+     */
+    private convertEmphasis;
+    /**
+     * JSPWiki monospace `{{text}}` → an inline code span (#1342).
+     *
+     * Here only, never in the NCM funnel: in Markdown from anywhere else
+     * `{{name}}` is template syntax, and converting it would strip the braces
+     * (operator decision, 2026-09-26). The match is balanced, so braces inside
+     * (`{{.mark {background:yellow;}}}`) stay in the span; inside it the
+     * JSPWiki escapes `[[`, `[` and `|` read as the reader saw them.
+     * In a table row a span that would hold a `|` is left as written, since
+     * the bar would split the cell. Code, and `{{{ }}}` blocks, are left alone.
+     */
+    private convertMonospace;
+    private monospaceLine;
+    /** Where the `}}` closing a monospace run starts, counting nested braces; -1 if none. */
+    private monospaceEnd;
+    /**
+     * Convert JSPWiki code blocks to Markdown
+     * {{{ code }}} -> ``` code ```
+     */
+    private convertCodeBlocks;
+    /**
+     * Convert JSPWiki lists to Markdown
+     * * item -> - item (unordered)
+     * ** nested -> - - nested (indented unordered)
+     * # item -> 1. item (ordered)
+     * ## nested -> 1. 1. nested (indented ordered)
+     */
+    private convertLists;
+    /**
+     * Convert JSPWiki definition lists to Markdown
+     * ;term:definition -> **term**: definition
+     */
+    private convertDefinitionLists;
+    /**
+     * Convert JSPWiki horizontal rules to Markdown
+     * ---- (or more dashes) -> ---
+     */
+    private convertHorizontalRules;
+    /**
+     * Convert JSPWiki links to Markdown/WikiLink format
+     * [link] -> [[link]]
+     * [display text|link] -> [[link|display text]]
+     */
+    private convertLinks;
+    /**
+     * Convert JSPWiki footnotes to Markdown footnotes
+     * [1] -> [^1]
+     * [#1] footnote text -> [^1]: footnote text
+     */
+    private convertFootnotes;
+    /**
+     * Strip page paths from Image plugin src attributes
+     *
+     * JSPWiki uses page-level attachments, so image paths include the page name:
+     *   [{Image src='Geological Timeline/Geolog_path_text.svg.png' ...}]
+     *
+     * ngdpbase uses a flat attachment structure, so we strip the path:
+     *   [{Image src='Geolog_path_text.svg.png' ...}]
+     */
+    private convertImagePaths;
+}
+export default JSPWikiConverter;

package/lib/src/converters/conversionWarning.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Classify legacy free-text converter warnings into structured
+ * {@link ConversionWarning} (#728 S3).
+ *
+ * The 3 converters build their warnings as prose `string[]` internally; this
+ * maps them to a stable `kind` at the single `convert()` return site, so the
+ * ~12 push call-sites don't each need touching. `detail` preserves the
+ * original message verbatim (lossless). `kind` is coarse but stable and
+ * aggregatable — finer taxonomy can come later without breaking the contract.
+ *
+ * @module converters/conversionWarning
+ */
+import type { ConversionWarning } from './IContentConverter.js';
+/** Map a prose `string[]` to structured `ConversionWarning[]`. */
+export declare function classifyWarnings(messages: string[]): ConversionWarning[];

package/lib/src/converters/ncm/bridge.d.ts

@@ -0,0 +1,22 @@
+/**
+ * NCM → ConversionResult bridge (#728 Phase 2 Slice 5b)
+ *
+ * Adapts an `NcmResult` to the shared `ConversionResult` shape so the import
+ * path can route through `normalizeToNcm`. Since #728 S3 made
+ * `ConversionResult.warnings` structured (`ConversionWarning {kind,detail}`),
+ * this bridge is now **lossless** — `NcmWarning` is an assignable subset:
+ *
+ * - the NCM document's frontmatter → `metadata`
+ * - the NCM body                  → `content`
+ * - `NcmWarning[]`                → `warnings` (structured, unchanged)
+ *
+ * @module converters/ncm/bridge
+ */
+import type { ConversionResult } from '../IContentConverter.js';
+import type { NcmResult } from './types.js';
+/**
+ * Adapt an {@link NcmResult} to the legacy {@link ConversionResult} shape.
+ * Frontmatter (including the stamped `ncmVersion`) is split into `metadata`
+ * so existing ImportManager/MCP pipelines consume it unchanged.
+ */
+export declare function ncmToConversionResult(ncm: NcmResult): ConversionResult;

package/lib/src/converters/ncm/existing.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Convert an existing page to NCM (#728 Phase 2 Slice 5a)
+ *
+ * "Convert existing page" is distinct from importing a Markdown file (which
+ * stays on `MarkdownConverter`). An existing wiki page is loose Markdown that
+ * should become NCM — so unlike the S1 `'markdown'` fixed point (which only
+ * stamps/sorts), this also applies the §2.4 link normalization to the body,
+ * then runs the S1 fixed point so determinism / `ncmVersion` stay
+ * single-sourced. Idempotent: a page already in NCM round-trips byte-identical.
+ *
+ * Image localization is intentionally NOT done here — it needs real
+ * fetch/AttachmentManager wiring and is the immediate follow-up micro-slice
+ * (S5a-ii). Embedded images survive as Markdown image syntax until then.
+ *
+ * @module converters/ncm/existing
+ */
+import type { NcmResult } from './types.js';
+/**
+ * Normalize an existing page's raw content (frontmatter + body) to NCM.
+ *
+ * @param raw Full stored page content (YAML frontmatter + Markdown body)
+ */
+export declare function normalizeExistingPageToNcm(raw: string): NcmResult;

package/lib/src/converters/ncm/fix/blocks.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Block map of a page body, read from markdown-it's parser (#1332).
+ *
+ * Every fix step asks the same questions of a page — is this line code? is it
+ * inside an HTML block? which lines start a list item, of which list, at what
+ * depth? — and each used to answer them with its own line regexes. Those
+ * regexes were approximations of CommonMark, and each approximation was wrong
+ * in its own way (#1335, the no-break-space `*`, the lazy line that ended a
+ * list early). This module answers them once, from the parser that will
+ * render the page after the converter swap (#1273), using the source line
+ * range markdown-it records on every block token.
+ *
+ * Code lines are the union of what markdown-it calls code (fences, indented
+ * code) and what MarkupParser's Step 0 extracts as a fenced block before any
+ * converter runs (#1335: an optionally indented run of three or more
+ * backticks, closed by the same run indented no further than the opener or
+ * 3 spaces). A step never edits a line either of them treats as code.
+ *
+ * Lines are split on `\n`; a trailing `\r` is kept out of the text the steps
+ * see and put back by {@link joinLines}, so CRLF pages stay CRLF.
+ *
+ * @module converters/ncm/fix/blocks
+ */
+/** A direct child block of a list item. */
+export interface ItemBlock {
+    /** Token type of the block's opening token (`paragraph_open`, `fence`, `bullet_list_open`, ...). */
+    type: string;
+    /** First line (0-based). */
+    start: number;
+    /** Line after the last (0-based, exclusive). */
+    end: number;
+}
+export interface ListItem {
+    /** Line the item's marker is on (0-based). */
+    line: number;
+    /** Line after the item's last line (0-based, exclusive). May include trailing empty lines. */
+    end: number;
+    /** The marker character: `-`, `*`, `+`, `.` or `)`. */
+    markup: string;
+    /** Nesting depth: 0 for an item of a top-level list. */
+    depth: number;
+    /** Position among the list items that start on the same line, outermost first (`- * a` has two). */
+    orderOnLine: number;
+    /** Direct child blocks, in order. */
+    blocks: ItemBlock[];
+    list: ListInfo;
+}
+export interface ListInfo {
+    ordered: boolean;
+    /** First line (0-based). */
+    start: number;
+    /** Line after the last (0-based, exclusive). */
+    end: number;
+    /** CommonMark tight list: no empty line between its items or their blocks. */
+    tight: boolean;
+    depth: number;
+    items: ListItem[];
+    /** The outermost list this one sits in (itself when top-level). */
+    outer: ListInfo;
+}
+export interface BlockMap {
+    /** Page lines without their `\r`. */
+    lines: string[];
+    /** `\r` where the line had one, else ''. */
+    eols: string[];
+    /** true for a line inside fenced or indented code (markdown-it or Step 0). */
+    code: boolean[];
+    /** true for a line inside an HTML block. */
+    html: boolean[];
+    /** Every list, outer lists before the lists nested in them. */
+    lists: ListInfo[];
+    /** Every list item, in source order. */
+    items: ListItem[];
+    /** The paragraph blocks' line ranges, in source order. */
+    paragraphs: ItemBlock[];
+}
+export declare function splitLines(body: string): {
+    lines: string[];
+    eols: string[];
+};
+export declare function joinLines(lines: string[], eols: string[]): string;
+export declare function isBlank(line: string): boolean;
+export declare function buildBlockMap(body: string): BlockMap;
+/**
+ * Column of each list marker at the start of a line, outermost first:
+ * `> - * a` gives the columns of `-` and `*`. Block-quote `>` markers are
+ * skipped, not returned. Pair the result with {@link ListItem.orderOnLine}.
+ */
+export declare function markerColumns(line: string): number[];

package/lib/src/converters/ncm/fix/bulletMarkers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Bullet markers → the house style, `- ` (#1271 decision S1).
+ *
+ * CommonMark accepts `*`, `+` and `-` as bullet markers, and starts a NEW list
+ * whenever the marker changes. Imported JSPWiki pages use `* item`; pages
+ * written here use `- item`; mixing them on one page reads inconsistently in
+ * the source and splits lists that were meant to be one. This rewrites every
+ * bullet marker the parser sees to `-`, keeping its indent and spacing, so
+ * nothing moves.
+ *
+ * Because the parser decides what is a list item, a thematic break (`* * *`),
+ * emphasis (`*italic*`), indented code and fenced code are never touched, and
+ * a bullet inside a block quote (`> * item`) is. The result is parsed again:
+ * a new marker merges lists that differed only by marker, but must never add,
+ * drop or re-nest an item (`* - -` would become a thematic break), and if it
+ * does, nothing is changed.
+ *
+ * @module converters/ncm/fix/bulletMarkers
+ */
+import type { FixStep } from './types.js';
+export declare const bulletMarkers: FixStep;

package/lib/src/converters/ncm/fix/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Markdown fix module (#1332): every conversion of page text in one place.
+ *
+ * Each step is small, pure and idempotent, reads the page through the
+ * markdown-it block map ({@link buildBlockMap}) and edits only the source lines
+ * it must. Steps run in registry order, each on the previous step's output.
+ *
+ * In the app only managers call this — PageManager through
+ * `normalizePageContent` — so Convert to NCM, ingest and import all apply the
+ * same rules. An ordinary save never runs them. The offline migration (scripts/fix-page-markdown.ts)
+ * calls {@link runFixes} directly: the same steps, without booting the engine
+ * for a dry run. It works on the page body; frontmatter is the caller's.
+ *
+ * @module converters/ncm/fix
+ */
+import type { FixResult, FixStep } from './types.js';
+export type { FixResult, FixStep, FixChange, FixStepResult } from './types.js';
+export { buildBlockMap } from './blocks.js';
+export type { BlockMap, ListInfo, ListItem, ItemBlock } from './blocks.js';
+/**
+ * Every step, in the order they run. Order matters: `{{{ }}}` blocks become
+ * code first, so the steps after never edit the examples inside them (a
+ * `%%` in an example stays as written); `!` headings become `#` before the
+ * footer step looks for a "More Information" heading; `**`
+ * bullets become list items before the marker and spacing steps look at the
+ * lists.
+ */
+export declare const FIX_STEPS: readonly FixStep[];
+export interface RunFixesOptions {
+    /** Run exactly these step ids, in registry order. Default: every step. */
+    steps?: readonly string[];
+}
+/** The steps an id list selects (default every step), in registry order. */
+export declare function selectFixSteps(options?: RunFixesOptions): FixStep[];
+/** Run the selected steps over a page body. */
+export declare function runFixes(body: string, options?: RunFixesOptions): FixResult;

package/lib/src/converters/ncm/fix/jspwikiBullets.d.ts

@@ -0,0 +1,20 @@
+/**
+ * JSPWiki nested bullets → Markdown nested bullets (#1325).
+ *
+ * JSPWiki writes a second-level bullet as `** item` and a third as `*** item`.
+ * That is not Markdown: CommonMark reads `** item` as a paragraph starting
+ * with two asterisks, so imported pages show literal stars. Each is rewritten
+ * to a hyphen bullet indented 2 spaces per level below the first — the house
+ * style — so `** item` becomes `  - item` and sits under the `* parent` above it.
+ *
+ * Deliberately narrow:
+ *   - only lines that START with two or more `*` followed by whitespace;
+ *     `**bold** text` has no space after the stars and is left alone;
+ *   - single-star `* item` is a valid CommonMark bullet (the bullet-markers
+ *     step's business, not this one's);
+ *   - never a line the renderer treats as code or HTML.
+ *
+ * @module converters/ncm/fix/jspwikiBullets
+ */
+import type { FixStep } from './types.js';
+export declare const jspwikiBullets: FixStep;

package/lib/src/converters/ncm/fix/jspwikiCodeMarkers.d.ts

@@ -0,0 +1,38 @@
+/**
+ * JSPWiki `{{{ }}}` code markers → Markdown code (#1332).
+ *
+ * JSPWiki marks preformatted text with `{{{` and `}}}`. That is not Markdown:
+ * the renderer shows the braces and reads the text inside as page markup, so
+ * `** item` in an example becomes a bullet and `[{Plugin}]` runs. Rewritten:
+ *
+ *   - a `{{{` at the start of a line (up to 3 spaces in) opens a block, closed
+ *     by the first `}}}` after it — or by a ``` line, where an author mixed
+ *     the two. Both become ``` fences at the opener's indent; text after the
+ *     `{{{`, and text before or after the `}}}` (`}}} /%`), moves onto a line
+ *     of its own. Lines in between are code and are not changed;
+ *   - `{{{text}}}` on one line becomes an inline code span. A `[[{` inside
+ *     becomes `[{`: outside code that escape shows as `[{`, which is what the
+ *     reader saw between the braces, but inside a code span it would show;
+ *   - a ``` block opened right under a `%%` style line (`%%prettify`) and
+ *     ended by `}}}` with `/%` after it, on the same line or the next, is
+ *     closed there: `}}}` becomes ``` and the `/%` goes on its own line. An
+ *     old import turned the lone `{{{` into ``` but left `}}} /%`, so the
+ *     code ran on through the rest of the page.
+ *
+ * Deliberately narrow:
+ *   - never a `{{{` inside code, an inline code span or an HTML block;
+ *   - a `}}}` with no `{{{` before it is left alone (`{\boldsymbol {\tau }}}`);
+ *   - a `{{{` that opens mid-line and closes on a later line is left alone:
+ *     it is inline text across a line break, and a fence there would split
+ *     the sentence (or list item) it sits in;
+ *   - any other `}}}` inside a ``` block is code, and is left alone;
+ *   - if any `{{{` block is never closed, nothing is changed.
+ *
+ * Runs first, so the steps after it see the example text as code.
+ *
+ * @module converters/ncm/fix/jspwikiCodeMarkers
+ */
+import type { FixStep } from './types.js';
+/** An inline code span holding `code`, with a backtick run longer than any inside it. */
+export declare function codeSpan(code: string): string;
+export declare const jspwikiCodeMarkers: FixStep;

package/lib/src/converters/ncm/fix/jspwikiHeadings.d.ts

@@ -0,0 +1,25 @@
+/**
+ * JSPWiki `!` headings → Markdown ATX headings (#1342).
+ *
+ * JSPWiki marks a heading with `!` at the start of a line, and more marks
+ * mean a LARGER heading: `!!!` is the largest, `!` the smallest. So `!!!`
+ * becomes `#`, `!!` becomes `##` and `!` becomes `###`. Markdown shows a `!`
+ * line as literal text.
+ *
+ * The one place this mapping lives: the JSPWiki file converter calls this
+ * step too, so a JSPWiki import and the NCM funnel read a `!` line the same
+ * way.
+ *
+ * Deliberately narrow:
+ *   - the `!` must be the first character of the line, as in JSPWiki;
+ *   - a Markdown image, `![alt](src)`, is not a heading; `![Main]` (a
+ *     heading whose text starts with a link) still is;
+ *   - a line with nothing after the marks is left alone;
+ *   - never a line the renderer treats as code or HTML.
+ *
+ * @module converters/ncm/fix/jspwikiHeadings
+ */
+import type { FixStep } from './types.js';
+/** The ATX heading for a JSPWiki `!` line, or null when the line is not one. */
+export declare function jspwikiHeadingLine(line: string): string | null;
+export declare const jspwikiHeadings: FixStep;

package/lib/src/converters/ncm/fix/jspwikiIndent.d.ts

@@ -0,0 +1,24 @@
+/**
+ * JSPWiki `;:text` → a plain paragraph (#1342).
+ *
+ * `;term:definition` is a JSPWiki definition list; with the term left empty,
+ * `;:text`, it is the indentation idiom — a continuation line, not a term,
+ * a quotation or a list. Markdown shows the `;:` as text. The marker goes and
+ * the text stands as its own paragraph (operator decision, 2026-09-26): a
+ * blockquote or a bullet would invent structure the author did not write.
+ *
+ * `;:` is never Markdown, so this runs on every NCM path. A definition with a
+ * term (`;term:def`) is not this step's: the JSPWiki converter maps it.
+ *
+ * Deliberately narrow:
+ *   - only a line that starts with `;:`;
+ *   - the text keeps what follows the marker (`**img** = …`, `*Comment*`);
+ *   - a converted line gets a blank line on each side, so consecutive ones
+ *     stay separate paragraphs, as the JSPWiki lines were separate;
+ *   - a `;:` with nothing after it is dropped;
+ *   - never a line the renderer treats as code or HTML.
+ *
+ * @module converters/ncm/fix/jspwikiIndent
+ */
+import type { FixStep } from './types.js';
+export declare const jspwikiIndent: FixStep;

package/lib/src/converters/ncm/fix/jspwikiInsert.d.ts

@@ -0,0 +1,21 @@
+/**
+ * JSPWiki's long plugin form → the short one (#1342).
+ *
+ * JSPWiki accepts `[{INSERT Name WHERE a=1}]`, with `INSERT` and `WHERE`
+ * optional, and a plugin named by its class in the default package,
+ * `org.apache.wiki.plugin.Name`. Ours reads the first word as the plugin
+ * name, so `[{INSERT CurrentTimePlugin …}]` renders nothing (a plugin called
+ * INSERT) and `[{org.apache.wiki.plugin.RecentChangesPlugin}]` is "not
+ * found". Both become `[{Name a=1}]`. Only the call's head changes; its
+ * parameters are left as written.
+ *
+ * Deliberately narrow:
+ *   - only the `org.apache.wiki.plugin.` package, the one JSPWiki searches by
+ *     default; any other package names a plugin we do not have;
+ *   - an escaped call, `[[{INSERT …}]`, is an example and stays;
+ *   - never in code, an HTML block or an inline code span.
+ *
+ * @module converters/ncm/fix/jspwikiInsert
+ */
+import type { FixStep } from './types.js';
+export declare const jspwikiInsert: FixStep;

package/lib/src/converters/ncm/fix/jspwikiItalic.d.ts

@@ -0,0 +1,29 @@
+/**
+ * JSPWiki `''italic''` → Markdown `*italic*` (#1342).
+ *
+ * Each `''` toggles italic, as in Apache's parser (`handleApostrophe`). An
+ * italic run does not stop at a paragraph break: `startBlockLevel` closes it
+ * at the end of the block and reopens it at the start of the next, so a
+ * quotation of several paragraphs (or with a list inside) is italic
+ * throughout. Markdown emphasis cannot cross a block, so the run is closed
+ * with `*` on the last line of each block and reopened on the first line of
+ * the next — after its list marker, heading marks or quote marker.
+ *
+ * A `''` that is the whole line (a closer written on its own line) is
+ * dropped and its `*` goes on the neighbouring text line instead: a line
+ * that is only `*` would be read as an empty list item.
+ *
+ * Deliberately narrow:
+ *   - never inside code, an HTML block, an inline code span or a
+ *     `[{Plugin …}]` call (`caption=''` is an empty argument, not italic);
+ *   - a page whose `''` count is odd is left alone, for review: which one is
+ *     stray cannot be told;
+ *   - the `*` goes before a line's closing `\` or `\\` break, never after it.
+ *
+ * The JSPWiki file converter calls this step too, so import and the NCM
+ * funnel read `''` one way.
+ *
+ * @module converters/ncm/fix/jspwikiItalic
+ */
+import type { FixStep } from './types.js';
+export declare const jspwikiItalic: FixStep;

package/lib/src/converters/ncm/fix/jspwikiLinkLeftovers.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Links the JSPWiki import left half-converted (#1492).
+ *
+ * The import turned `[text|url|target='_blank']` into Markdown by pieces, and
+ * on some pages the pieces were left glued together. Today they show as
+ * harmless text; once bare web addresses become links (`linkify`, #1492),
+ * each would become one long broken link. Three shapes, each unambiguous:
+ *
+ *   - `url(url)`, the same address twice, becomes `url`;
+ *   - `url(url|target='_blank')`, the same address twice, becomes `url`;
+ *   - `](url|target='_blank')`, a Markdown link whose destination kept the
+ *     JSPWiki attribute, becomes `](url)` — every external link opens in a new
+ *     tab anyway (#1492).
+ *
+ * Deliberately narrow:
+ *   - two different addresses in `url(other)` are left alone;
+ *   - a wiki link split over two lines (`[Long title` then
+ *     `|url|target='_blank']`) is left alone: which line it belongs to needs a
+ *     reader;
+ *   - never inside code, an HTML block or an inline code span.
+ *
+ * @module converters/ncm/fix/jspwikiLinkLeftovers
+ */
+import type { FixStep } from './types.js';
+/** Apply {@link fixText} to a line, leaving its code spans as written. */
+export declare function fixLinkLeftoversInLine(line: string): string;
+export declare const jspwikiLinkLeftovers: FixStep;

package/lib/src/converters/ncm/fix/moreInformationFooter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The JSPWiki "More Information" footer is removed (#1348).
+ *
+ * A convention from the JSPWiki years, for want of a Referring Pages tab:
+ *
+ *     ## More Information
+ *     There might be more information for this subject on one of the following:
+ *     [{ReferringPagesPlugin before='*' after='\n' }]
+ *
+ * The page's Referring Pages tab now shows the same list, so the section goes
+ * (operator, 2026-09-12). The section is the heading and everything up to
+ * the next heading of the same or a higher level, or the end of the page.
+ *
+ * Deliberately narrow: the section is removed only when every line in it is
+ * one of the footer's own lines, in the variants stored pages carry — the
+ * sentence (also cut short, or with the plugin on the same line), "Pages
+ * that reference this topic:", and the plugin call (also missing its closing
+ * `]`). A section with anything else under the heading ("See also: …") is
+ * left for review. A ReferringPagesPlugin call without the heading is valid
+ * NCM and is left alone. Never a heading the renderer treats as code or HTML.
+ *
+ * @module converters/ncm/fix/moreInformationFooter
+ */
+import type { FixStep } from './types.js';
+export declare const moreInformationFooter: FixStep;