@pretextbook/remark-pretext 0.0.1 → 0.0.3

package/dist/lib/context.d.ts

@@ -0,0 +1,22 @@
+import { BlockContent, DefinitionContent, PhrasingContent } from 'mdast';
+export interface VisitContext {
+    /** Parent node, if any. */
+    parent?: BlockContent | DefinitionContent | PhrasingContent;
+    /** All ancestor nodes in traversal order. */
+    ancestors: (BlockContent | DefinitionContent | PhrasingContent)[];
+    /** Nesting depth. */
+    depth: number;
+    /** Accumulated error/warning messages. */
+    messages?: ConversionMessage[];
+    /** Raw source markdown (optional, used for delimiter detection). */
+    source?: string;
+}
+export interface ConversionMessage {
+    type: 'warning' | 'error';
+    reason: string;
+    category: string;
+    position?: {
+        line?: number;
+        column?: number;
+    };
+}

package/dist/lib/directive-factory.d.ts

@@ -0,0 +1,24 @@
+import { BlockContent, DefinitionContent } from 'mdast';
+import { ContainerDirective } from 'mdast-util-directive';
+import { Element } from 'xast';
+import { DirectiveSpec } from './directive-map.js';
+import { VisitContext } from './context.js';
+/**
+ * Generic factory function: applies semantic rules from spec.
+ *
+ * Handles:
+ * - Statement wrapping for theorem-like elements
+ * - Task nesting with introduction wrapping (exercise/project/task)
+ * - Proof/solution sibling extraction
+ *
+ * @param spec Semantic specification for this directive type
+ * @param attrs HTML/XML attributes for the element
+ * @param titleEl Optional <title> element (extracted from first paragraph if present)
+ * @param children Body content of the directive
+ * @param ctx Visitor context
+ * @param convertBlock Callback to recursively convert block children
+ * @param convertDirective Callback to recursively convert nested directives
+ *
+ * @returns XAST element for this directive
+ */
+export declare function buildDirectiveWithSpec(spec: DirectiveSpec, attrs: Record<string, string> | undefined, titleEl: Element | null, children: Array<BlockContent | DefinitionContent>, ctx: VisitContext, convertBlock: (child: BlockContent | DefinitionContent, ctx: VisitContext) => Element | null, convertDirective: (node: ContainerDirective, ctx: VisitContext) => Element | null): Element;

package/dist/lib/directive-map.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Maps directive names (from remark-directive's `:::name`) to their
+ * corresponding xast element names and semantic specifications.
+ *
+ * Architecture (Phase 2 refactor):
+ * - Separated semantic specs (requiresStatement) from routing logic
+ * - Factories apply spec-driven semantic rules uniformly
+ * - Adding new directives requires only configuration change, not new functions
+ */
+export type DirectiveCategory = 'theorem-like' | 'proof-like' | 'definition-like' | 'axiom-like' | 'remark-like' | 'example-like' | 'project-like' | 'exercise-like' | 'solution-like';
+/**
+ * Semantic specification for how a directive type should be converted.
+ * This pattern mirrors unified-latex-to-pretext's factory specifications.
+ */
+export interface DirectiveSpec {
+    /** The PreTeXt XML element name (= xast `name` field). */
+    type: string;
+    /** Routing category for handler selection. */
+    category: DirectiveCategory;
+    /**
+     * If true, the directive's body content is wrapped in a <statement> element,
+     * and proof/solution siblings are extracted as siblings of the statement
+     * (not children of it). This matches PreTeXt semantics where theorems have:
+     *   <theorem><title/><statement>...</statement><proof/></theorem>
+     *
+     * If false, content is added directly without statement wrapping.
+     */
+    requiresStatement: boolean;
+    /**
+     * If true, this directive can have nested task children.
+     * Content before the first task becomes an <introduction> wrapper.
+     * Example:
+     *   <exercise><introduction>...</introduction><task>...</task><task>...</task></exercise>
+     *
+     * Only applies if nested tasks are actually present in the body.
+     * If no tasks are found, requiresStatement still applies.
+     */
+    hasNestedTasks?: boolean;
+}
+/**
+ * Backwards-compatible type for code that only needs type+category.
+ * @deprecated Use DirectiveSpec instead for new code.
+ */
+export interface DirectiveInfo {
+    type: string;
+    category: DirectiveCategory;
+}
+/**
+ * Semantic specification table: directive name → spec.
+ *
+ * Pattern mirrors unified-latex-to-pretext's environment specification approach:
+ * Declarative table + factory functions apply rules uniformly.
+ * To add a new directive: just add an entry here.
+ */
+export declare const DIRECTIVE_SPEC_TABLE: Readonly<Record<string, DirectiveSpec>>;
+/**
+ * @deprecated Use DIRECTIVE_SPEC_TABLE directly or via getDirectiveSpec().
+ * Kept for backwards compatibility. Returns spec as old DirectiveInfo type.
+ */
+export declare const DIRECTIVE_MAP: Readonly<Record<string, DirectiveInfo>>;
+/** Get directive spec, or undefined if not found. */
+export declare function getDirectiveSpec(name: string): DirectiveSpec | undefined;
+/** Set of directive names that are proof/solution-like (used when separating statement siblings). */
+export declare const PROOF_SOLUTION_NAMES: Set<string>;

package/dist/lib/directive-normalizer.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Directive Normalizer (Two-Pass Algorithm)
+ *
+ * Transforms user-friendly flexible colon syntax into standard remark-directive format.
+ *
+ * INPUT (flexible):
+ *   :::exercise
+ *   Intro
+ *   :::task
+ *   Content
+ *   :::
+ *   :::task
+ *   More
+ *   :::
+ *   :::
+ *
+ * OUTPUT (normalized for remark-directive):
+ *   ::::exercise
+ *   Intro
+ *   :::task
+ *   Content
+ *   :::
+ *   :::task
+ *   More
+ *   :::
+ *   ::::
+ *
+ * Algorithm (Two-Pass):
+ * - Pass 1: Parse markers, build nesting tree with parent references
+ * - Pass 2: Traverse tree bottom-up, compute final colon counts
+ *   (each parent = max(children) + 1, ensuring proper nesting)
+ * - Pass 3: Re-emit with adjusted markers
+ */
+/**
+ * Main normalization function
+ */
+export declare function normalizeDirectiveColons(markdown: string): string;

package/dist/lib/indentation-normalizer.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Indentation-Based Directive Normalizer
+ *
+ * Transforms Python-like indentation-based directive syntax into colon syntax.
+ *
+ * INPUT (indentation-based):
+ *   Theorem[Pythagorean]{#thm}:
+ *     Statement text here.
+ *
+ *     Proof:
+ *       Proof content.
+ *
+ *   Plain text (outdented).
+ *
+ * OUTPUT (colon-based):
+ *   :::theorem[Pythagorean]{#thm}
+ *   Statement text here.
+ *
+ *   ::::proof
+ *   Proof content.
+ *   ::::
+ *   :::
+ *
+ *   Plain text (outdented).
+ *
+ * Algorithm:
+ * 1. Track fenced code blocks (``` and ~~~) and skip directive detection inside them
+ * 2. Parse each line to detect directive markers (Keyword[...]{...}:)
+ * 3. Track indentation stack: when indent increases, open a block; when decreases, close block(s)
+ * 4. Convert to colon syntax with proper nesting depth (validated against DIRECTIVE_SPEC_TABLE)
+ * 5. Preserve all non-directive content and indentation outside directives and code fences
+ */
+/**
+ * Normalize indentation-based syntax to colon-based syntax
+ */
+export declare function normalizeIndentationDirectives(markdown: string): string;

package/dist/lib/markdown-to-pretext.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Convert a markdown string (with PreTeXt directive extensions) to a PreTeXt
+ * XML string.
+ *
+ * The output contains the converted XML fragment — the children of the root
+ * node serialized as a string — suitable for embedding in a PreTeXt document.
+ *
+ * @param markdown - The markdown source to convert.
+ * @returns A PreTeXt XML string.
+ *
+ * @example
+ * ```ts
+ * import { markdownToPretext } from '@pretextbook/remark-pretext';
+ *
+ * const xml = markdownToPretext('# Hello\n\nThis is a paragraph.');
+ * // → '<section>\n  <title>Hello</title>\n  <p>This is a paragraph.</p>\n</section>'
+ * ```
+ */
+export declare function markdownToPretext(markdown: string): string;

package/dist/lib/math-parser.d.ts

@@ -0,0 +1,31 @@
+import { Plugin } from 'unified';
+import { Root, Text } from 'mdast';
+export interface Math {
+    type: 'math';
+    value: string;
+    meta?: string;
+}
+declare module 'mdast' {
+    interface PhrasingContentMap {
+        math: Math;
+    }
+}
+export interface MathTokenizationResult {
+    markdown: string;
+    tokens: Map<string, Math>;
+}
+export declare function tokenizeMathInMarkdown(markdown: string): MathTokenizationResult;
+/**
+ * Find math in a string and split into text and math nodes.
+ * Returns array of alternating Text and Math nodes.
+ *
+ * Order matters: we check longer/more specific delimiters first.
+ */
+export declare function splitTextWithMath(text: string): (Text | Math)[];
+/**
+ * Remark plugin that detects and parses math delimiters in text nodes.
+ */
+export declare function applyMathDelimiters(tree: Root): void;
+export declare function applyMathTokens(tree: Root, tokens: Map<string, Math>): void;
+declare const remarkMath: Plugin<[], Root>;
+export default remarkMath;

package/dist/lib/mdast-to-ptxast.d.ts

@@ -0,0 +1,13 @@
+import { Root as MdastRoot } from 'mdast';
+import { Root } from 'xast';
+import { ConversionMessage } from './context.js';
+/** Result type for conversion: tree + diagnostic messages. */
+export interface ConversionResult {
+    tree: Root;
+    messages: ConversionMessage[];
+}
+/** Transform an mdast Root node into an xast Root node (backwards compatible). */
+export declare function mdastToPtxast(tree: MdastRoot, source?: string): Root;
+export { mdastToPtxast as mdastToXast };
+/** Transform an mdast Root node, returning tree + diagnostic messages. */
+export declare function mdastToPtxastWithDiagnostics(tree: MdastRoot, source?: string): ConversionResult;

package/dist/lib/remark-pretext.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from 'unified';
+import { Root as MdastRoot } from 'mdast';
+import { Root } from 'xast';
+/** Options for the remark-pretext plugin (currently none, reserved for future use). */
+export interface RemarkPretextOptions {
+}
+declare const remarkPretext: Plugin<[RemarkPretextOptions?], MdastRoot, Root>;
+export default remarkPretext;
+export { mdastToPtxast } from './mdast-to-ptxast.js';
+export { DIRECTIVE_MAP, PROOF_SOLUTION_NAMES } from './directive-map.js';
+export type { DirectiveInfo, DirectiveCategory } from './directive-map.js';

package/index.cjs

@@ -1 +1 @@
-module.exports = require('../../dist/packages/remark-pretext/index.cjs');
+module.exports = require('./dist/index.cjs');

package/index.d.ts

@@ -1 +1 @@
-export * from '../../dist/packages/remark-pretext/index.d.ts';
+export * from "./dist/index.d.ts";

package/index.js

@@ -1 +1 @@
-export * from '../../dist/packages/remark-pretext/index.js';
+export * from './dist/index.js';

package/package.json

@@ -1,53 +1,54 @@
-{
-  "name": "@pretextbook/remark-pretext",
-  "version": "0.0.1",
-  "description": "remark plugin to transform markdown-style PreTeXt directives into ptxast",
-  "author": "Oscar Levin",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/pretextbook/pretext-tools.git"
-  },
-  "bugs": {
-    "url": "https://github.com/pretextbook/pretext-tools/issues"
-  },
-  "homepage": "https://github.com/pretextbook/pretext-tools/packages/remark-pretext#readme",
-  "private": false,
-  "type": "module",
-  "main": "./index.cjs",
-  "module": "./index.js",
-  "types": "./index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./index.d.ts",
-      "import": "./index.js",
-      "require": "./index.cjs",
-      "default": "./index.js"
-    }
-  },
-  "sideEffects": false,
-  "files": [
-    "*.js",
-    "*.cjs",
-    "*.d.ts",
-    "*.d.cts",
-    "lib",
-    "types"
-  ],
-  "scripts": {
-    "build": "vite build",
-    "test": "vitest run"
-  },
-  "dependencies": {
-    "@pretextbook/ptxast": "^0.0.1",
-    "@types/mdast": "^4.0.0",
-    "mdast-util-directive": "^3.0.0",
-    "remark-directive": "^4.0.0",
-    "remark-parse": "^11.0.0",
-    "unified": "^11.0.0",
-    "unist-util-visit": "^5.0.0"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{
+  "name": "@pretextbook/remark-pretext",
+  "version": "0.0.3",
+  "description": "remark plugin to transform markdown-style PreTeXt directives into ptxast",
+  "author": "Oscar Levin",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/PreTeXtBook/pretext-tools.git"
+  },
+  "bugs": {
+    "url": "https://github.com/PreTeXtBook/pretext-tools/issues"
+  },
+  "homepage": "https://github.com/PreTeXtBook/pretext-tools/packages/remark-pretext#readme",
+  "private": false,
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./index.cjs",
+      "default": "./index.js"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "*.js",
+    "*.cjs",
+    "*.d.ts",
+    "*.d.cts",
+    "dist",
+    "types"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@pretextbook/ptxast": "^0.0.3",
+    "@types/mdast": "^4.0.0",
+    "mdast-util-directive": "^3.0.0",
+    "remark-directive": "^4.0.0",
+    "remark-parse": "^11.0.0",
+    "unified": "^11.0.0",
+    "unist-util-visit": "^5.0.0",
+    "xast-util-to-xml": "^4.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}