@invompt/invoml 1.0.0-alpha.4

package/dist/src/html-renderer.js

@@ -0,0 +1,365 @@
+// src/html-renderer.ts — Orchestrates block rendering into a self-contained HTML document.
+import { resolveStyle } from './style.js';
+import { getCurrencyDecimals } from './rounding.js';
+import { fmtNum } from './format.js';
+import { escapeHtml, processInline, processMarkdown } from './markdown.js';
+import { BASE_CSS, TEMPLATE_CSS } from './html-css.js';
+// Alias for brevity within this module
+const esc = escapeHtml;
+// ─── Block renderers ──────────────────────────────────────────────────────────
+function renderHeader(doc, blockStyle) {
+    const { meta } = doc;
+    const type = meta.documentType.replaceAll('_', ' ').toUpperCase();
+    const styleAttr = buildInlineStyle(blockStyle);
+    const metaItems = [];
+    metaItems.push(metaItem('Date', meta.issueDate, 'meta.issueDate'));
+    if (meta.dueDate)
+        metaItems.push(metaItem('Due', meta.dueDate, 'meta.dueDate'));
+    if (meta.expiryDate)
+        metaItems.push(metaItem('Expires', meta.expiryDate, 'meta.expiryDate'));
+    metaItems.push(metaItem('Currency', meta.currency, 'meta.currency'));
+    if (meta.reference)
+        metaItems.push(metaItem('Reference', meta.reference, 'meta.reference'));
+    if (meta.creditNoteReference)
+        metaItems.push(metaItem('Ref', meta.creditNoteReference, 'meta.creditNoteReference'));
+    return `
+<header class="invoml-header" data-invoml-block="header"${styleAttr}>
+  <div class="invoml-header-title" data-invoml-field="meta.documentType" data-invoml-type="text">${esc(type)}</div>
+  <div class="invoml-header-number" data-invoml-field="meta.number" data-invoml-type="text">${esc(meta.number)}</div>
+  <div class="invoml-header-meta">
+    ${metaItems.join('\n    ')}
+  </div>
+</header>`;
+}
+function metaItem(label, value, field) {
+    return `<div class="invoml-header-meta-item"><span class="invoml-header-meta-label">${esc(label)}</span><span class="invoml-header-meta-value" data-invoml-field="${esc(field)}" data-invoml-type="text">${esc(value)}</span></div>`;
+}
+function renderParty(role, party, blockStyle) {
+    if (!party)
+        return '';
+    const label = role === 'from' ? 'From' : 'Bill To';
+    const ariaLabel = role === 'from' ? 'Issued by' : 'Billed to';
+    const styleAttr = buildInlineStyle(blockStyle);
+    let inner;
+    if (party.content) {
+        inner = `<div class="invoml-party-details" data-invoml-field="${role}.content" data-invoml-type="markdown-block">${processMarkdown(party.content)}</div>`;
+    }
+    else {
+        const rows = [];
+        if (party.name)
+            rows.push(`<div class="invoml-party-name" data-invoml-field="${role}.name" data-invoml-type="markdown">${processInline(party.name)}</div>`);
+        const details = [];
+        if (party.address)
+            details.push(`<div data-invoml-field="${role}.address" data-invoml-type="text">${esc(party.address)}</div>`);
+        if (party.attention)
+            details.push(`<div data-invoml-field="${role}.attention" data-invoml-type="text">Attn: ${esc(party.attention)}</div>`);
+        if (party.email)
+            details.push(`<div data-invoml-field="${role}.email" data-invoml-type="text">${esc(party.email)}</div>`);
+        if (party.phone)
+            details.push(`<div data-invoml-field="${role}.phone" data-invoml-type="text">${esc(party.phone)}</div>`);
+        if (party.website)
+            details.push(`<div data-invoml-field="${role}.website" data-invoml-type="text">${esc(party.website)}</div>`);
+        if (party.taxId)
+            details.push(`<div data-invoml-field="${role}.taxId" data-invoml-type="text">Tax ID: ${esc(party.taxId)}</div>`);
+        if (party.businessNumber)
+            details.push(`<div data-invoml-field="${role}.businessNumber" data-invoml-type="text">Business No: ${esc(party.businessNumber)}</div>`);
+        if (details.length > 0) {
+            rows.push(`<div class="invoml-party-details">${details.join('')}</div>`);
+        }
+        inner = rows.join('\n');
+    }
+    return `
+<div class="invoml-party invoml-party-${role}" data-invoml-block="${role}" aria-label="${ariaLabel}"${styleAttr}>
+  <div class="invoml-party-label">${esc(label)}</div>
+  ${inner}
+</div>`;
+}
+function renderItems(doc, blockStyle) {
+    const dp = getCurrencyDecimals(doc.meta.currency);
+    const fmt = (n) => fmtNum(n, dp);
+    const hasUnit = doc.items.some(i => i.unit);
+    const hasDiscount = doc.items.some(i => i.discount);
+    const hasTax = doc.items.some(i => i.taxAmount !== undefined);
+    const styleAttr = buildInlineStyle(blockStyle);
+    const thRight = (label) => `<th class="col-right">${esc(label)}</th>`;
+    const headers = [
+        `<th data-invoml-field="items.*.description">Description</th>`,
+        `<th class="col-right">Qty</th>`,
+        hasUnit ? `<th>Unit</th>` : '',
+        thRight('Unit Price'),
+        hasDiscount ? thRight('Discount') : '',
+        hasTax ? thRight('Tax') : '',
+        thRight('Amount'),
+    ].filter(Boolean).join('\n        ');
+    const rows = doc.items.map((item, idx) => {
+        const amount = item.amount ?? item.quantity * item.unitPrice;
+        const discountStr = item.discount
+            ? typeof item.discount === 'string'
+                ? item.discount
+                : item.discount.type === 'percentage'
+                    ? `${item.discount.value}%`
+                    : fmt(item.discount.value)
+            : '';
+        const cells = [
+            `<td data-invoml-field="items.${idx}.description" data-invoml-type="markdown">${processInline(item.description)}</td>`,
+            `<td class="col-right" data-invoml-field="items.${idx}.quantity" data-invoml-type="number">${esc(String(item.quantity))}</td>`,
+            hasUnit ? `<td data-invoml-field="items.${idx}.unit" data-invoml-type="text">${esc(item.unit ?? '')}</td>` : '',
+            `<td class="col-right" data-invoml-field="items.${idx}.unitPrice" data-invoml-type="currency">${esc(fmt(item.unitPrice))}</td>`,
+            hasDiscount ? `<td class="col-right" data-invoml-field="items.${idx}.discount" data-invoml-type="text">${esc(discountStr)}</td>` : '',
+            hasTax ? `<td class="col-right" data-invoml-field="items.${idx}.taxAmount" data-invoml-type="currency" data-invoml-computed>${item.taxAmount !== undefined ? esc(fmt(item.taxAmount)) : ''}</td>` : '',
+            `<td class="col-right" data-invoml-field="items.${idx}.amount" data-invoml-type="currency" data-invoml-computed>${esc(fmt(amount))}</td>`,
+        ].filter(Boolean).join('\n        ');
+        return `    <tr>\n        ${cells}\n      </tr>`;
+    }).join('\n');
+    return `
+<table class="invoml-items" data-invoml-block="items"${styleAttr}>
+  <thead>
+    <tr>
+        ${headers}
+    </tr>
+  </thead>
+  <tbody>
+${rows}
+  </tbody>
+</table>`;
+}
+function renderTotals(totals, currency, blockStyle) {
+    if (!totals)
+        return '';
+    const dp = getCurrencyDecimals(currency);
+    const fmt = (n) => fmtNum(n, dp);
+    const styleAttr = buildInlineStyle(blockStyle);
+    const rows = [];
+    const row = (label, amount, extra = '', labelBold = false) => {
+        const labelClass = `invoml-totals-label${labelBold ? ' is-bold' : ''}`;
+        return `<div class="invoml-totals-row${extra}" aria-label="${esc(label)}">
+      <span class="${labelClass}">${esc(label)}</span>
+      <span class="invoml-totals-amount" data-invoml-computed>${esc(amount)}</span>
+    </div>`;
+    };
+    rows.push(row('Subtotal', fmt(totals.subtotal)));
+    if (totals.discountDetails) {
+        for (const d of totals.discountDetails) {
+            rows.push(row(d.label ?? 'Discount', `-${fmt(d.amount)}`));
+        }
+        rows.push(row('After Discounts', fmt(totals.afterDiscounts)));
+    }
+    if (totals.taxDetails) {
+        for (const t of totals.taxDetails) {
+            const suffix = t.inclusive ? ' (included)' : '';
+            rows.push(row(`${t.label ?? t.category}${suffix}`, fmt(t.amount)));
+        }
+    }
+    if (totals.withholdingTotal && totals.withholdingTotal > 0) {
+        rows.push(row('Withholding', `-${fmt(totals.withholdingTotal)}`));
+    }
+    rows.push(row(`Total (${currency})`, fmt(totals.total), ' is-grand', true));
+    if (totals.prepaidAmount && totals.prepaidAmount > 0) {
+        rows.push(row('Prepaid', `-${fmt(totals.prepaidAmount)}`));
+        rows.push(row('Amount Due', fmt(totals.amountDue), ' is-amount-due', true));
+    }
+    return `
+<div class="invoml-totals" data-invoml-block="totals" aria-label="Invoice summary"${styleAttr}>
+  <div class="invoml-totals-inner">
+    ${rows.join('\n    ')}
+  </div>
+</div>`;
+}
+function renderPayment(payment, blockStyle) {
+    if (!payment)
+        return '';
+    const styleAttr = buildInlineStyle(blockStyle);
+    const title = payment.title ?? 'Payment';
+    let inner;
+    if (payment.content) {
+        inner = `<div class="invoml-payment-details" data-invoml-field="payment.content" data-invoml-type="markdown-block">${processMarkdown(payment.content)}</div>`;
+    }
+    else {
+        const fields = [];
+        if (payment.beneficiary)
+            fields.push(`<strong>Beneficiary:</strong> ${esc(payment.beneficiary)}`);
+        if (payment.bank)
+            fields.push(`<strong>Bank:</strong> ${esc(payment.bank)}`);
+        if (payment.iban)
+            fields.push(`<strong>IBAN:</strong> ${esc(payment.iban)}`);
+        if (payment.swift)
+            fields.push(`<strong>SWIFT/BIC:</strong> ${esc(payment.swift)}`);
+        if (payment.routingNumber)
+            fields.push(`<strong>Routing:</strong> ${esc(payment.routingNumber)}`);
+        if (payment.accountNumber)
+            fields.push(`<strong>Account:</strong> ${esc(payment.accountNumber)}`);
+        if (payment.cryptoAddress)
+            fields.push(`<strong>Address:</strong> ${esc(payment.cryptoAddress)}`);
+        if (payment.cryptoNetwork)
+            fields.push(`<strong>Network:</strong> ${esc(payment.cryptoNetwork)}`);
+        inner = `<div class="invoml-payment-details">${fields.join('<br>\n')}</div>`;
+    }
+    return `
+<section class="invoml-payment" data-invoml-block="payment">
+  <div class="invoml-payment-title" data-invoml-field="payment.title" data-invoml-type="text"${styleAttr}>${esc(title)}</div>
+  ${inner}
+</section>`;
+}
+function renderNotes(notes, blockStyle) {
+    if (!notes)
+        return '';
+    const styleAttr = buildInlineStyle(blockStyle);
+    return `
+<footer class="invoml-notes" data-invoml-block="notes"${styleAttr}>
+  <div data-invoml-field="notes" data-invoml-type="markdown-block">${processMarkdown(notes)}</div>
+</footer>`;
+}
+function renderSection(key, section, blockStyle) {
+    const styleAttr = buildInlineStyle(blockStyle);
+    return `
+<section class="invoml-section" data-invoml-block="section:${esc(key)}" data-invoml-section="${esc(key)}"${styleAttr}>
+  <div class="invoml-section-title">${esc(section.title)}</div>
+  <div class="invoml-section-content" data-invoml-field="sections.${esc(key)}.content" data-invoml-type="markdown-block">${processMarkdown(section.content)}</div>
+</section>`;
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+/**
+ * CSS properties allowed in style.blocks inline styles.
+ * Restricted to safe visual properties — layout visibility properties that could hide
+ * financial data (display: none, visibility: hidden, opacity: 0) are intentionally excluded.
+ */
+const ALLOWED_INLINE_CSS_PROPERTIES = new Set([
+    // Box model
+    'margin', 'margin-top', 'margin-right', 'margin-bottom', 'margin-left',
+    'padding', 'padding-top', 'padding-right', 'padding-bottom', 'padding-left',
+    'width', 'min-width', 'max-width',
+    // Display / layout (safe subset only — no display:none, no visibility:hidden)
+    'display', 'vertical-align', 'text-align',
+    'float', 'clear',
+    // Typography
+    'font', 'font-family', 'font-size', 'font-weight', 'font-style', 'font-variant',
+    'line-height', 'letter-spacing', 'word-spacing', 'text-decoration', 'text-transform',
+    'white-space',
+    // Color / background
+    'color', 'background', 'background-color',
+    'border', 'border-top', 'border-right', 'border-bottom', 'border-left',
+    'border-color', 'border-width', 'border-style', 'border-radius',
+    // CSS custom properties (--invoml-*)
+]);
+/**
+ * Dangerous property values for inline styles — patterns that could hide content
+ * or trigger data exfiltration even within a style="" attribute context.
+ */
+const INLINE_VALUE_FORBIDDEN_RE = /none|hidden|^0$|absolute|fixed|url\s*\(|expression\s*\(/i;
+function isSafeInlineCssProperty(name, value) {
+    const nameLower = name.toLowerCase().trim();
+    // Allow CSS custom properties (--something) always
+    if (/^--[a-zA-Z][a-zA-Z0-9-]*$/.test(name))
+        return true;
+    if (!ALLOWED_INLINE_CSS_PROPERTIES.has(nameLower))
+        return false;
+    // Block values that hide content or exfiltrate data on any property
+    if (INLINE_VALUE_FORBIDDEN_RE.test(value.trim()))
+        return false;
+    return true;
+}
+function buildInlineStyle(props) {
+    const entries = Object.entries(props);
+    if (entries.length === 0)
+        return '';
+    const css = entries
+        .filter(([k, v]) => isSafeInlineCssProperty(k, v))
+        .map(([k, v]) => `${k}: ${v}`)
+        .join('; ');
+    if (css.length === 0)
+        return '';
+    return ` style="${esc(css)}"`;
+}
+/** Allowlist pattern for CSS property names: standard kebab-case (font-family) or CSS custom properties (--accent). */
+const CSS_PROPERTY_NAME_RE = /^-{0,2}[a-zA-Z][a-zA-Z0-9-]*$/;
+/** Characters/sequences forbidden in CSS property values when written into a <style> block. */
+const CSS_VALUE_FORBIDDEN_RE = /[{}@;\n\r\\]|url\s*\(|expression\s*\(|<\//i;
+function isSafeCssPropertyName(name) {
+    return CSS_PROPERTY_NAME_RE.test(name);
+}
+function isSafeCssPropertyValue(value) {
+    return !CSS_VALUE_FORBIDDEN_RE.test(value);
+}
+function buildContainerProperties(properties) {
+    const entries = Object.entries(properties);
+    if (entries.length === 0)
+        return '';
+    const decls = entries
+        .filter(([k, v]) => isSafeCssPropertyName(k) && isSafeCssPropertyValue(v))
+        .map(([k, v]) => `  ${k}: ${v};`)
+        .join('\n');
+    if (decls.length === 0)
+        return '';
+    return `.invoml-container {\n${decls}\n}`;
+}
+// ─── Main export ──────────────────────────────────────────────────────────────
+/** Render an InvoML document (with computed totals in doc.totals) as a
+ *  self-contained HTML string suitable for browser display, iframe embedding,
+ *  or headless PDF generation. */
+export function toHTML(doc) {
+    const style = resolveStyle(doc);
+    const template = doc.style?.template ?? '';
+    const styleParts = [BASE_CSS];
+    if (template && TEMPLATE_CSS[template]) {
+        styleParts.push(TEMPLATE_CSS[template]);
+    }
+    if (Object.keys(style.properties).length > 0) {
+        styleParts.push(buildContainerProperties(style.properties));
+    }
+    const titleType = doc.meta.documentType.replaceAll('_', ' ').toUpperCase();
+    const titleStr = `${titleType} ${doc.meta.number}`;
+    const blockHtmlParts = [];
+    for (const block of style.order) {
+        const blockStyle = style.blocks[block] ?? {};
+        if (block === 'header') {
+            blockHtmlParts.push(renderHeader(doc, blockStyle));
+        }
+        else if (block === 'from') {
+            if (doc.from)
+                blockHtmlParts.push(renderParty('from', doc.from, blockStyle));
+        }
+        else if (block === 'to') {
+            if (doc.to)
+                blockHtmlParts.push(renderParty('to', doc.to, blockStyle));
+        }
+        else if (block === 'items') {
+            blockHtmlParts.push(renderItems(doc, blockStyle));
+        }
+        else if (block === 'totals') {
+            if (doc.totals)
+                blockHtmlParts.push(renderTotals(doc.totals, doc.meta.currency, blockStyle));
+        }
+        else if (block === 'payment') {
+            if (doc.payment)
+                blockHtmlParts.push(renderPayment(doc.payment, blockStyle));
+        }
+        else if (block === 'notes') {
+            if (doc.notes)
+                blockHtmlParts.push(renderNotes(doc.notes, blockStyle));
+        }
+        else if (block.startsWith('section:')) {
+            const key = block.slice('section:'.length);
+            const section = doc.sections?.[key];
+            if (section)
+                blockHtmlParts.push(renderSection(key, section, blockStyle));
+        }
+    }
+    const containerAttrs = [
+        `class="invoml-container"`,
+        template ? `data-invoml-template="${esc(template)}"` : '',
+    ].filter(Boolean).join(' ');
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${esc(titleStr)}</title>
+  <style>${styleParts.join('\n')}</style>
+</head>
+<body>
+  <div ${containerAttrs}>
+    ${blockHtmlParts.join('\n    ')}
+  </div>
+</body>
+</html>`;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,13 @@
+export { getCurrencyDecimals } from './rounding.js';
+export { parse } from './parser.js';
+export type { ParseResult } from './parser.js';
+export { validateSchema } from './schema.js';
+export type { ValidationResult } from './schema.js';
+export { calculate } from './calculator.js';
+export { toJSON, toMarkdown } from './serializer.js';
+export type { JSONOptions } from './serializer.js';
+export { toHTML } from './html-renderer.js';
+export { DEFAULT_ORDER, RESERVED_BLOCK_NAMES, validateStyle, resolveOrder, resolveStyle } from './style.js';
+export type { StyleValidationResult } from './style.js';
+export { CalculationError } from './types.js';
+export type { InvoMLDocument, InvoMLTotals, InvoMLTaxDetail, InvoMLItem, InvoMLMeta, InvoMLDiscount, InvoMLParty, InvoMLPayment, InvoMLSection, InvoMLTaxSimple, InvoMLTaxFull, InvoMLTaxCategory, InvoMLStyle, } from './types.js';

package/dist/src/index.js

@@ -0,0 +1,8 @@
+export { getCurrencyDecimals } from './rounding.js';
+export { parse } from './parser.js';
+export { validateSchema } from './schema.js';
+export { calculate } from './calculator.js';
+export { toJSON, toMarkdown } from './serializer.js';
+export { toHTML } from './html-renderer.js';
+export { DEFAULT_ORDER, RESERVED_BLOCK_NAMES, validateStyle, resolveOrder, resolveStyle } from './style.js';
+export { CalculationError } from './types.js';

package/dist/src/markdown.d.ts

@@ -0,0 +1,8 @@
+/** Escape HTML special characters in plain text. */
+export declare function escapeHtml(s: string): string;
+/** Process inline markdown: bold, italic, underline, links.
+ *  HTML is escaped first to prevent XSS — Markdown patterns are applied on safe text. */
+export declare function processInline(text: string): string;
+/** Process the supported markdown subset into HTML inline/block content.
+ *  Supports: bold, italic, underline, links, unordered lists, ordered lists. */
+export declare function processMarkdown(text: string): string;

package/dist/src/markdown.js

@@ -0,0 +1,89 @@
+/** Escape HTML special characters in plain text. */
+export function escapeHtml(s) {
+    return s
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+/** Process inline markdown: bold, italic, underline, links.
+ *  HTML is escaped first to prevent XSS — Markdown patterns are applied on safe text. */
+export function processInline(text) {
+    let result = escapeHtml(text);
+    // Links: only allow http, https, mailto schemes
+    result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_match, linkText, url) => {
+        if (/^(https?:|mailto:)/i.test(url)) {
+            return `<a href="${escapeHtml(url)}">${linkText}</a>`;
+        }
+        return linkText;
+    });
+    // Bold **text**
+    result = result.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>');
+    // Italic *text*
+    result = result.replace(/\*([^*]+)\*/g, '<em>$1</em>');
+    // Underline __text__
+    result = result.replace(/__([^_]+)__/g, '<u>$1</u>');
+    return result;
+}
+/** Process the supported markdown subset into HTML inline/block content.
+ *  Supports: bold, italic, underline, links, unordered lists, ordered lists. */
+export function processMarkdown(text) {
+    const lines = text.split('\n');
+    const output = [];
+    let inUl = false;
+    let inOl = false;
+    function closeList() {
+        if (inUl) {
+            output.push('</ul>');
+            inUl = false;
+        }
+        if (inOl) {
+            output.push('</ol>');
+            inOl = false;
+        }
+    }
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const ulMatch = /^[-*]\s+(.+)$/.exec(line);
+        const olMatch = /^\d+\.\s+(.+)$/.exec(line);
+        if (ulMatch) {
+            if (inOl) {
+                output.push('</ol>');
+                inOl = false;
+            }
+            if (!inUl) {
+                output.push('<ul>');
+                inUl = true;
+            }
+            output.push(`<li>${processInline(ulMatch[1])}</li>`);
+        }
+        else if (olMatch) {
+            if (inUl) {
+                output.push('</ul>');
+                inUl = false;
+            }
+            if (!inOl) {
+                output.push('<ol>');
+                inOl = true;
+            }
+            output.push(`<li>${processInline(olMatch[1])}</li>`);
+        }
+        else if (line.trim() === '') {
+            closeList();
+            if (i + 1 < lines.length && lines[i + 1].trim() !== '') {
+                output.push('<br>');
+            }
+        }
+        else {
+            closeList();
+            output.push(processInline(line));
+            if (i + 1 < lines.length && lines[i + 1].trim() !== '' &&
+                !/^[-*]\s/.test(lines[i + 1]) && !/^\d+\.\s/.test(lines[i + 1])) {
+                output.push('<br>');
+            }
+        }
+    }
+    closeList();
+    return output.join('\n');
+}

package/dist/src/parser.d.ts

@@ -0,0 +1,10 @@
+import type { InvoMLDocument } from './types.js';
+export type ParseResult = {
+    success: true;
+    document: InvoMLDocument;
+} | {
+    success: false;
+    errors: string[];
+};
+/** Parse a JSON string into a typed InvoML document. Validates against the JSON Schema before returning. */
+export declare function parse(input: string): ParseResult;

package/dist/src/parser.js

@@ -0,0 +1,16 @@
+import { validateSchema } from './schema.js';
+/** Parse a JSON string into a typed InvoML document. Validates against the JSON Schema before returning. */
+export function parse(input) {
+    let doc;
+    try {
+        doc = JSON.parse(input);
+    }
+    catch (e) {
+        return { success: false, errors: [`Invalid JSON: ${e.message}`] };
+    }
+    const validation = validateSchema(doc);
+    if (!validation.valid) {
+        return { success: false, errors: validation.errors };
+    }
+    return { success: true, document: doc };
+}

package/dist/src/rounding.d.ts

@@ -0,0 +1,5 @@
+import Decimal from 'decimal.js';
+export declare const InternalDecimal: typeof Decimal;
+/** Return the standard number of decimal places for a currency (ISO 4217 minor units). */
+export declare function getCurrencyDecimals(currency: string): number;
+export declare function roundHalfUp(value: number | Decimal, decimals?: number): number;

package/dist/src/rounding.js

@@ -0,0 +1,24 @@
+import Decimal from 'decimal.js';
+// Library-private Decimal clone — avoids mutating the global Decimal config
+// which would break consumers who also use decimal.js
+export const InternalDecimal = Decimal.clone({ precision: 50, rounding: Decimal.ROUND_HALF_UP });
+// ISO 4217 minor units — currencies that DON'T use 2 decimal places
+const ZERO_DECIMAL = new Set([
+    'BIF', 'CLP', 'DJF', 'GNF', 'ISK', 'JPY', 'KMF', 'KRW',
+    'PYG', 'RWF', 'UGX', 'UYI', 'VND', 'VUV', 'XAF', 'XOF', 'XPF',
+]);
+const THREE_DECIMAL = new Set([
+    'BHD', 'IQD', 'JOD', 'KWD', 'LYD', 'OMR', 'TND',
+]);
+/** Return the standard number of decimal places for a currency (ISO 4217 minor units). */
+export function getCurrencyDecimals(currency) {
+    if (ZERO_DECIMAL.has(currency))
+        return 0;
+    if (THREE_DECIMAL.has(currency))
+        return 3;
+    return 2;
+}
+export function roundHalfUp(value, decimals = 2) {
+    const d = new InternalDecimal(value.toString());
+    return d.toDecimalPlaces(decimals, InternalDecimal.ROUND_HALF_UP).toNumber();
+}

package/dist/src/schema.d.ts

@@ -0,0 +1,6 @@
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+/** Validate an arbitrary value against the InvoML v1.0 JSON Schema. Useful for pre-validating AI output before calling `parse`. */
+export declare function validateSchema(doc: unknown): ValidationResult;

package/dist/src/schema.js

@@ -0,0 +1,33 @@
+import Ajv from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import { readFileSync, existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// dist/src/ needs ../../, src/ needs ../ — try dist path first, fall back to source
+const distPath = join(__dirname, '..', '..', 'invoml-v1.0.schema.json');
+const srcPath = join(__dirname, '..', 'invoml-v1.0.schema.json');
+const schemaPath = existsSync(distPath) ? distPath : srcPath;
+let ajvInstance = null;
+let validateFn = null;
+function getValidator() {
+    if (!validateFn) {
+        const schema = JSON.parse(readFileSync(schemaPath, 'utf8'));
+        ajvInstance = new Ajv({ allErrors: true, strict: false, validateFormats: true });
+        addFormats(ajvInstance);
+        validateFn = ajvInstance.compile(schema);
+    }
+    return validateFn;
+}
+/** Validate an arbitrary value against the InvoML v1.0 JSON Schema. Useful for pre-validating AI output before calling `parse`. */
+export function validateSchema(doc) {
+    const validate = getValidator();
+    const valid = validate(doc);
+    if (valid)
+        return { valid: true, errors: [] };
+    const errors = (validate.errors ?? []).map(e => {
+        const path = e.instancePath || '/';
+        return `${path}: ${e.message}`;
+    });
+    return { valid: false, errors };
+}

package/dist/src/serializer.d.ts

@@ -0,0 +1,8 @@
+import type { InvoMLDocument } from './types.js';
+export interface JSONOptions {
+    compact?: boolean;
+}
+/** Serialize an InvoML document to a JSON string. Defaults to pretty-printed; pass `{ compact: true }` for minified output. */
+export declare function toJSON(doc: InvoMLDocument, options?: JSONOptions): string;
+/** Render an InvoML document (with computed totals in `doc.totals`) as a human-readable Markdown table. Follows the document's style.order or falls back to the default order. */
+export declare function toMarkdown(doc: InvoMLDocument): string;