@schemd/core 0.1.0

package/dist/marked-extension.js

@@ -0,0 +1,75 @@
+import { MAX_SCHEMATIC_COMPONENTS, MAX_SCHEMATIC_CONNECTIONS, MAX_SCHEMATIC_SOURCE_CHARACTERS, MAX_SCHEMATIC_SVG_OUTPUT_BYTES, utf8ByteLength } from './limits.js';
+import { parseSchematic, parseSchematicFence } from './parser.js';
+import { renderSchematic } from './renderer.js';
+import { SchematicSyntaxError } from './types.js';
+class SchematicDocumentBudgetError extends SchematicSyntaxError {
+}
+function emptyDocumentBudget() {
+    return { sourceCharacters: 0, components: 0, connections: 0, svgOutputBytes: 0 };
+}
+function consumeBudget(used, amount, limit, unit) {
+    if (amount > limit - used) {
+        throw new SchematicDocumentBudgetError(`Schematic document exceeds the cumulative ${limit.toLocaleString('en-US')} ${unit} limit.`);
+    }
+    return used + amount;
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;');
+}
+function defaultErrorRenderer(error, source) {
+    return `<figure class="schematic-error" role="group" aria-label="Schematic compilation error"><figcaption>${escapeHtml(error.message)}</figcaption><pre><code class="language-schemd">${escapeHtml(source)}</code></pre></figure>`;
+}
+export function schematicMarkedExtension(options = {}) {
+    let diagramIndex = 0;
+    let budget = emptyDocumentBudget();
+    let budgetError;
+    return {
+        hooks: {
+            preprocess(source) {
+                diagramIndex = 0;
+                budget = emptyDocumentBudget();
+                budgetError = undefined;
+                return source;
+            }
+        },
+        renderer: {
+            code(token) {
+                if (!token.lang || !/^schemd(?:\s|$)/i.test(token.lang.trim())) {
+                    return false;
+                }
+                try {
+                    if (budgetError)
+                        throw budgetError;
+                    budget.sourceCharacters = consumeBudget(budget.sourceCharacters, token.text.length, MAX_SCHEMATIC_SOURCE_CHARACTERS, 'schematic source character');
+                    const fence = parseSchematicFence(token.lang, options.defaultTitle);
+                    diagramIndex += 1;
+                    const document = parseSchematic(token.text, fence);
+                    const nextComponents = consumeBudget(budget.components, document.components.length, MAX_SCHEMATIC_COMPONENTS, 'component');
+                    const nextConnections = consumeBudget(budget.connections, document.connections.length, MAX_SCHEMATIC_CONNECTIONS, 'connection');
+                    const html = renderSchematic(document, {
+                        ...fence,
+                        idPrefix: `schematic-${diagramIndex}`,
+                        mode: options.resolveMode?.() ?? options.mode ?? 'default'
+                    });
+                    const nextSvgOutputBytes = consumeBudget(budget.svgOutputBytes, utf8ByteLength(html), MAX_SCHEMATIC_SVG_OUTPUT_BYTES, 'compiled SVG byte');
+                    budget.components = nextComponents;
+                    budget.connections = nextConnections;
+                    budget.svgOutputBytes = nextSvgOutputBytes;
+                    return html;
+                }
+                catch (error) {
+                    if (!(error instanceof SchematicSyntaxError))
+                        throw error;
+                    if (error instanceof SchematicDocumentBudgetError)
+                        budgetError = error;
+                    return (options.onError ?? defaultErrorRenderer)(error, token.text);
+                }
+            }
+        }
+    };
+}

package/dist/math-label.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Dependency-free micro-math tokenizer and inline SVG text renderer.
+ *
+ * The grammar is intentionally non-recursive and bounded by the caller's label
+ * length. It recognizes subscript/superscript shifts and a fixed engineering
+ * symbol map without evaluating TeX or allocating a browser-side math runtime.
+ *
+ * @packageDocumentation
+ */
+/** Visual baseline category assigned to one parsed label segment. */
+export type MathLabelSegmentKind = 'text' | 'subscript' | 'superscript';
+/** One normalized, Unicode-translated section of a component label. */
+export interface MathLabelSegment {
+    /** Baseline treatment used by the SVG renderer. */
+    readonly kind: MathLabelSegmentKind;
+    /** Plain Unicode content with grouping delimiters removed. */
+    readonly value: string;
+}
+/**
+ * Parse a deliberately small, linear-time math-label subset.
+ *
+ * @param value - Raw component label. Braces only group shifted content.
+ * @returns Coalesced immutable baseline segments with symbol commands expanded.
+ */
+export declare function parseMathLabel(value: string): readonly MathLabelSegment[];
+/**
+ * Return the accessible plain-text representation of a math label.
+ *
+ * @param value - Raw micro-math label.
+ * @returns Unicode text without baseline grouping markup.
+ */
+export declare function mathLabelText(value: string): string;
+/**
+ * Count rendered Unicode glyphs for deterministic SVG text fitting.
+ *
+ * @param value - Raw micro-math label.
+ * @returns Unicode code-point count after command translation.
+ */
+export declare function mathLabelGlyphLength(value: string): number;
+/**
+ * Emit escaped inline SVG text with explicit baseline restoration.
+ *
+ * Plain labels avoid `<tspan>` allocation entirely. Shifted segments use a
+ * 70% font size and an empty inverse-`dy` tspan so consecutive shifts cannot
+ * accumulate vertical drift.
+ *
+ * @param value - Raw micro-math label.
+ * @returns Trusted compiler-owned XML text suitable inside an SVG `<text>` node.
+ */
+export declare function renderMathLabelTspans(value: string): string;

package/dist/math-label.js

@@ -0,0 +1,151 @@
+const MATH_SYMBOLS = Object.freeze({
+    alpha: 'α',
+    beta: 'β',
+    Delta: 'Δ',
+    cdot: '·',
+    infty: '∞',
+    lambda: 'λ',
+    le: '≤',
+    ge: '≥',
+    mu: 'μ',
+    neq: '≠',
+    Omega: 'Ω',
+    omega: 'ω',
+    phi: 'φ',
+    pi: 'π',
+    pm: '±',
+    rightarrow: '→',
+    sigma: 'σ',
+    sqrt: '√',
+    theta: 'θ',
+    times: '×'
+});
+function validXmlCodePoint(codePoint) {
+    if (codePoint === 0x09 || codePoint === 0x0a || codePoint === 0x0d)
+        return true;
+    if (codePoint >= 0x20 && codePoint <= 0xd7ff)
+        return true;
+    if (codePoint >= 0xe000 && codePoint <= 0xfffd)
+        return true;
+    return codePoint >= 0x10000 && codePoint <= 0x10ffff;
+}
+function escapeXml(value) {
+    let normalized = '';
+    for (const character of value) {
+        const codePoint = character.codePointAt(0);
+        normalized += validXmlCodePoint(codePoint) ? character : '\ufffd';
+    }
+    return normalized
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;');
+}
+function commandAt(value, index) {
+    const match = value.slice(index + 1).match(/^[A-Za-z]+/);
+    if (!match)
+        return { text: value[index], end: index + 1 };
+    const command = match[0];
+    const replacement = MATH_SYMBOLS[command];
+    return {
+        text: replacement ?? `\\${command}`,
+        end: index + command.length + 1
+    };
+}
+function translateMathSymbols(value) {
+    let output = '';
+    let index = 0;
+    while (index < value.length) {
+        if (value[index] !== '\\') {
+            output += value[index];
+            index += 1;
+            continue;
+        }
+        const command = commandAt(value, index);
+        output += command.text;
+        index = command.end;
+    }
+    return output;
+}
+function shiftedValue(value, index) {
+    const first = value[index + 1];
+    if (first !== '{') {
+        const character = Array.from(value.slice(index + 1))[0];
+        return { value: translateMathSymbols(character), end: index + 1 + character.length };
+    }
+    const closing = value.indexOf('}', index + 2);
+    if (closing < 0)
+        return undefined;
+    return {
+        value: translateMathSymbols(value.slice(index + 2, closing)),
+        end: closing + 1
+    };
+}
+function appendSegment(segments, kind, value) {
+    if (value === '')
+        return;
+    const previous = segments.at(-1);
+    if (previous?.kind === kind) {
+        segments[segments.length - 1] = { kind, value: previous.value + value };
+        return;
+    }
+    segments.push({ kind, value });
+}
+export function parseMathLabel(value) {
+    const segments = [];
+    let text = '';
+    let index = 0;
+    const flush = () => {
+        appendSegment(segments, 'text', text);
+        text = '';
+    };
+    while (index < value.length) {
+        const character = value[index];
+        if ((character === '_' || character === '^') && index + 1 < value.length) {
+            const shifted = shiftedValue(value, index);
+            if (shifted !== undefined && shifted.value !== '') {
+                flush();
+                appendSegment(segments, character === '_' ? 'subscript' : 'superscript', shifted.value);
+                index = shifted.end;
+                continue;
+            }
+        }
+        if (character === '\\') {
+            const command = commandAt(value, index);
+            text += command.text;
+            index = command.end;
+            continue;
+        }
+        if (character !== '{' && character !== '}')
+            text += character;
+        index += 1;
+    }
+    flush();
+    return segments;
+}
+export function mathLabelText(value) {
+    return parseMathLabel(value)
+        .map((segment) => segment.value)
+        .join('');
+}
+export function mathLabelGlyphLength(value) {
+    return Array.from(mathLabelText(value)).length;
+}
+export function renderMathLabelTspans(value) {
+    const segments = parseMathLabel(value);
+    if (segments.length === 1 && segments[0]?.kind === 'text' && segments[0].value === value) {
+        return escapeXml(value);
+    }
+    return segments
+        .map((segment) => {
+        const content = escapeXml(segment.value);
+        if (segment.kind === 'text')
+            return `<tspan dy="0">${content}</tspan>`;
+        if (segment.kind === 'subscript') {
+            return `<tspan dy="0.35em" font-size="70%">${content}</tspan><tspan dy="-0.35em" font-size="100%"></tspan>`;
+        }
+        return `<tspan dy="-0.55em" font-size="70%">${content}</tspan><tspan dy="0.55em" font-size="100%"></tspan>`;
+    })
+        .join('');
+}

package/dist/parser.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Bounded lexer, parser, and semantic validator for the `schemd` DSL.
+ *
+ * Parsing is synchronous and deterministic. This module accepts no DOM or
+ * browser globals, validates all author-controlled strings before they reach
+ * the SVG renderer, and records successful documents in a private provenance
+ * registry so arbitrary object graphs cannot bypass the parser boundary.
+ *
+ * @packageDocumentation
+ */
+import { type SchematicColor, type SchematicDocument, type SchematicFence } from './types.js';
+/**
+ * Assert that a document originated from {@link parseSchematic} in this module.
+ *
+ * @param document - Candidate AST supplied to the renderer.
+ * @throws {TypeError} When the object was forged, cloned, or parsed by another
+ *   loaded copy of the package rather than this module instance.
+ * @internal
+ */
+export declare function assertParsedSchematicDocument(document: SchematicDocument): void;
+/**
+ * Parse a theme token, safe CSS literal, or custom theme alias.
+ *
+ * Raw aliases never become literal color declarations; the renderer maps them
+ * through bounded `--schematic-color-*` custom properties. Functional colors
+ * are canonicalized and unsafe CSS expressions are rejected.
+ *
+ * @param input - Author-supplied color token or expression.
+ * @param line - One-based source line used in diagnostics.
+ * @returns Sanitized discriminated color representation.
+ * @throws {SchematicSyntaxError} For malformed, out-of-range, or unsafe colors.
+ */
+export declare function parseSchematicColor(input: string, line?: number): SchematicColor;
+/**
+ * Parse and validate a schemd fenced-code information string.
+ *
+ * @param info - The complete Markdown fence information string beginning with
+ *   the canonical `schemd` language identifier.
+ * @param defaultTitle - Accessible SVG title used when `title` is omitted.
+ * @returns Validated intrinsic bounds and title, or `undefined` when the fence
+ *   belongs to another language.
+ * @throws {SchematicSyntaxError} When a recognized fence has malformed
+ *   metadata, out-of-range bounds, or a title longer than 512 characters.
+ */
+export declare function parseSchematicFence(info: string | undefined, defaultTitle?: string): SchematicFence | undefined;
+/**
+ * Compile validated schemd DSL source into an immutable schematic AST.
+ *
+ * @param source - Diagram declarations excluding the surrounding Markdown fence.
+ * @param fence - Intrinsic dimensions and accessible title returned by
+ *   {@link parseSchematicFence}.
+ * @returns A deeply frozen, renderer-authorized schematic document.
+ * @throws {SchematicSyntaxError} When syntax, resource budgets, port references,
+ *   color values, component geometry, or connection geometry are invalid.
+ */
+export declare function parseSchematic(source: string, fence: SchematicFence): SchematicDocument;