origam 2.2.1 → 2.5.0

package/dist/src/utils/Mask/index.cjs

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _applyMask = require("./apply-mask.util.cjs");
+Object.keys(_applyMask).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _applyMask[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _applyMask[key];
+    }
+  });
+});
+var _resolveMaskConfig = require("./resolve-mask-config.util.cjs");
+Object.keys(_resolveMaskConfig).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _resolveMaskConfig[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _resolveMaskConfig[key];
+    }
+  });
+});
+var _validatePattern = require("./validate-pattern.util.cjs");
+Object.keys(_validatePattern).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _validatePattern[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _validatePattern[key];
+    }
+  });
+});

package/dist/src/utils/Mask/index.d.ts

@@ -0,0 +1,3 @@
+export * from './apply-mask.util';
+export * from './resolve-mask-config.util';
+export * from './validate-pattern.util';

package/dist/src/utils/Mask/index.js

@@ -0,0 +1,3 @@
+export * from "./apply-mask.util.js";
+export * from "./resolve-mask-config.util.js";
+export * from "./validate-pattern.util.js";

package/dist/src/utils/Mask/resolve-mask-config.util.cjs

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveMaskConfig = resolveMaskConfig;
+var _consts = require("../../consts/index.cjs");
+function resolveMaskConfig(mask) {
+  if (mask == null || mask === "") return null;
+  if (typeof mask === "string") {
+    if (_consts.BUILT_IN_PATTERN_KEYS.has(mask)) {
+      const preset = _consts.BUILT_IN_PATTERNS[mask];
+      return {
+        pattern: preset.pattern,
+        validator: preset.validator ?? null,
+        required: preset.required ?? false
+      };
+    }
+    return {
+      pattern: mask,
+      validator: null,
+      required: false
+    };
+  }
+  const opts = mask;
+  return {
+    pattern: opts.pattern,
+    validator: opts.validator ?? null,
+    required: opts.required ?? false
+  };
+}

package/dist/src/utils/Mask/resolve-mask-config.util.d.ts

@@ -0,0 +1,15 @@
+import type { IResolvedMaskConfig } from '../../interfaces';
+import type { TMask } from '../../types';
+/**
+ * Normalise the polymorphic `mask` prop / arg into a fully
+ * resolved `{ pattern, validator, required }` object.
+ *
+ * - `null | undefined | ''` → returns `null`. Callers treat
+ *   this as "no masking".
+ * - `string`                → either a registered built-in
+ *                             key (looked up) or a raw
+ *                             pattern (used verbatim).
+ * - `IMaskOptions`          → consumed as-is, with `required`
+ *                             defaulting to `false`.
+ */
+export declare function resolveMaskConfig(mask: TMask | undefined): IResolvedMaskConfig | null;

package/dist/src/utils/Mask/resolve-mask-config.util.js

@@ -0,0 +1,21 @@
+import { BUILT_IN_PATTERN_KEYS, BUILT_IN_PATTERNS } from "../../consts/index.js";
+export function resolveMaskConfig(mask) {
+  if (mask == null || mask === "") return null;
+  if (typeof mask === "string") {
+    if (BUILT_IN_PATTERN_KEYS.has(mask)) {
+      const preset = BUILT_IN_PATTERNS[mask];
+      return {
+        pattern: preset.pattern,
+        validator: preset.validator ?? null,
+        required: preset.required ?? false
+      };
+    }
+    return { pattern: mask, validator: null, required: false };
+  }
+  const opts = mask;
+  return {
+    pattern: opts.pattern,
+    validator: opts.validator ?? null,
+    required: opts.required ?? false
+  };
+}

package/dist/src/utils/Mask/validate-pattern.util.cjs

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isFrDateValid = isFrDateValid;
+exports.isIbanValid = isIbanValid;
+exports.isIsoDateValid = isIsoDateValid;
+exports.isLuhnValid = isLuhnValid;
+exports.isUsDateValid = isUsDateValid;
+exports.validatePattern = validatePattern;
+var _enums = require("../../enums/index.cjs");
+function isLuhnValid(digits) {
+  if (!digits) return false;
+  if (!/^\d+$/.test(digits)) return false;
+  let sum = 0;
+  let alternate = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let n = digits.charCodeAt(i) - 48;
+    if (alternate) {
+      n *= 2;
+      if (n > 9) n -= 9;
+    }
+    sum += n;
+    alternate = !alternate;
+  }
+  return sum % 10 === 0;
+}
+function isIbanValid(raw) {
+  if (!raw) return false;
+  const clean = raw.replace(/\s+/g, "").toUpperCase();
+  if (clean.length < 4 || clean.length > 34) return false;
+  if (!/^[A-Z0-9]+$/.test(clean)) return false;
+  const rearranged = clean.slice(4) + clean.slice(0, 4);
+  let numeric = "";
+  for (const c of rearranged) {
+    if (c >= "0" && c <= "9") {
+      numeric += c;
+    } else {
+      numeric += String(c.charCodeAt(0) - 55);
+    }
+  }
+  let remainder = 0;
+  for (const ch of numeric) {
+    remainder = (remainder * 10 + (ch.charCodeAt(0) - 48)) % 97;
+  }
+  return remainder === 1;
+}
+function isRealDate(y, m, d) {
+  if (m < 1 || m > 12) return false;
+  if (d < 1 || d > 31) return false;
+  const date = new Date(Date.UTC(y, m - 1, d));
+  return date.getUTCFullYear() === y && date.getUTCMonth() === m - 1 && date.getUTCDate() === d;
+}
+function isIsoDateValid(unmasked) {
+  if (!/^\d{8}$/.test(unmasked)) return false;
+  const y = Number(unmasked.slice(0, 4));
+  const m = Number(unmasked.slice(4, 6));
+  const d = Number(unmasked.slice(6, 8));
+  return isRealDate(y, m, d);
+}
+function isFrDateValid(unmasked) {
+  if (!/^\d{8}$/.test(unmasked)) return false;
+  const d = Number(unmasked.slice(0, 2));
+  const m = Number(unmasked.slice(2, 4));
+  const y = Number(unmasked.slice(4, 8));
+  return isRealDate(y, m, d);
+}
+function isUsDateValid(unmasked) {
+  if (!/^\d{8}$/.test(unmasked)) return false;
+  const m = Number(unmasked.slice(0, 2));
+  const d = Number(unmasked.slice(2, 4));
+  const y = Number(unmasked.slice(4, 8));
+  return isRealDate(y, m, d);
+}
+const VALIDATORS = {
+  [_enums.PATTERN_VALIDATOR.LUHN]: isLuhnValid,
+  [_enums.PATTERN_VALIDATOR.IBAN]: isIbanValid,
+  [_enums.PATTERN_VALIDATOR.DATE_ISO]: isIsoDateValid,
+  [_enums.PATTERN_VALIDATOR.DATE_FR]: isFrDateValid,
+  [_enums.PATTERN_VALIDATOR.DATE_US]: isUsDateValid
+};
+function validatePattern(unmasked, validator) {
+  if (typeof validator === "function") {
+    return validator(unmasked);
+  }
+  const fn = VALIDATORS[validator];
+  if (!fn) {
+    throw new Error(`[origam:mask] unknown validator "${validator}"`);
+  }
+  return fn(unmasked);
+}

package/dist/src/utils/Mask/validate-pattern.util.d.ts

@@ -0,0 +1,41 @@
+import type { TPatternValidator } from '../../types';
+/**
+ * Standard Luhn checksum used to validate credit-card,
+ * IMEI, SIRET-like number sequences.
+ *
+ *   1. Walk digits from right to left.
+ *   2. Double every second digit; subtract 9 if > 9.
+ *   3. Sum the result. A valid number's sum mod 10 == 0.
+ */
+export declare function isLuhnValid(digits: string): boolean;
+/**
+ * Standard IBAN mod-97 check (ISO 13616).
+ *
+ *   1. Move the first 4 chars to the end.
+ *   2. Replace every letter with `letter - 'A' + 10` as a
+ *      decimal pair.
+ *   3. The resulting big integer mod 97 must equal 1.
+ *
+ * We compute the mod incrementally to avoid BigInt.
+ */
+export declare function isIbanValid(raw: string): boolean;
+/**
+ * `YYYYMMDD` — accepts the unmasked iso digits.
+ */
+export declare function isIsoDateValid(unmasked: string): boolean;
+/**
+ * `DDMMYYYY` — accepts the unmasked fr digits.
+ */
+export declare function isFrDateValid(unmasked: string): boolean;
+/**
+ * `MMDDYYYY` — accepts the unmasked us digits.
+ */
+export declare function isUsDateValid(unmasked: string): boolean;
+/**
+ * Resolve and execute a validator on an UNMASKED value.
+ *
+ * - `string`   → looked up in `VALIDATORS`. Unknown names
+ *                throw — typo-prevention.
+ * - `function` → called as-is.
+ */
+export declare function validatePattern(unmasked: string, validator: TPatternValidator): boolean;

package/dist/src/utils/Mask/validate-pattern.util.js

@@ -0,0 +1,81 @@
+import { PATTERN_VALIDATOR } from "../../enums/index.js";
+export function isLuhnValid(digits) {
+  if (!digits) return false;
+  if (!/^\d+$/.test(digits)) return false;
+  let sum = 0;
+  let alternate = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let n = digits.charCodeAt(i) - 48;
+    if (alternate) {
+      n *= 2;
+      if (n > 9) n -= 9;
+    }
+    sum += n;
+    alternate = !alternate;
+  }
+  return sum % 10 === 0;
+}
+export function isIbanValid(raw) {
+  if (!raw) return false;
+  const clean = raw.replace(/\s+/g, "").toUpperCase();
+  if (clean.length < 4 || clean.length > 34) return false;
+  if (!/^[A-Z0-9]+$/.test(clean)) return false;
+  const rearranged = clean.slice(4) + clean.slice(0, 4);
+  let numeric = "";
+  for (const c of rearranged) {
+    if (c >= "0" && c <= "9") {
+      numeric += c;
+    } else {
+      numeric += String(c.charCodeAt(0) - 55);
+    }
+  }
+  let remainder = 0;
+  for (const ch of numeric) {
+    remainder = (remainder * 10 + (ch.charCodeAt(0) - 48)) % 97;
+  }
+  return remainder === 1;
+}
+function isRealDate(y, m, d) {
+  if (m < 1 || m > 12) return false;
+  if (d < 1 || d > 31) return false;
+  const date = new Date(Date.UTC(y, m - 1, d));
+  return date.getUTCFullYear() === y && date.getUTCMonth() === m - 1 && date.getUTCDate() === d;
+}
+export function isIsoDateValid(unmasked) {
+  if (!/^\d{8}$/.test(unmasked)) return false;
+  const y = Number(unmasked.slice(0, 4));
+  const m = Number(unmasked.slice(4, 6));
+  const d = Number(unmasked.slice(6, 8));
+  return isRealDate(y, m, d);
+}
+export function isFrDateValid(unmasked) {
+  if (!/^\d{8}$/.test(unmasked)) return false;
+  const d = Number(unmasked.slice(0, 2));
+  const m = Number(unmasked.slice(2, 4));
+  const y = Number(unmasked.slice(4, 8));
+  return isRealDate(y, m, d);
+}
+export function isUsDateValid(unmasked) {
+  if (!/^\d{8}$/.test(unmasked)) return false;
+  const m = Number(unmasked.slice(0, 2));
+  const d = Number(unmasked.slice(2, 4));
+  const y = Number(unmasked.slice(4, 8));
+  return isRealDate(y, m, d);
+}
+const VALIDATORS = {
+  [PATTERN_VALIDATOR.LUHN]: isLuhnValid,
+  [PATTERN_VALIDATOR.IBAN]: isIbanValid,
+  [PATTERN_VALIDATOR.DATE_ISO]: isIsoDateValid,
+  [PATTERN_VALIDATOR.DATE_FR]: isFrDateValid,
+  [PATTERN_VALIDATOR.DATE_US]: isUsDateValid
+};
+export function validatePattern(unmasked, validator) {
+  if (typeof validator === "function") {
+    return validator(unmasked);
+  }
+  const fn = VALIDATORS[validator];
+  if (!fn) {
+    throw new Error(`[origam:mask] unknown validator "${validator}"`);
+  }
+  return fn(unmasked);
+}

package/dist/src/utils/Media/format-time.util.cjs

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatMediaTime = formatMediaTime;
+function formatMediaTime(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) return "--:--";
+  const total = Math.floor(seconds);
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  const s = total % 60;
+  const pad = value => value.toString().padStart(2, "0");
+  if (h > 0) return `${h}:${pad(m)}:${pad(s)}`;
+  return `${pad(m)}:${pad(s)}`;
+}

package/dist/src/utils/Media/format-time.util.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Format a duration (seconds) into a media-toolbar-friendly string.
+ *
+ *   • short medias        → `mm:ss`     (e.g. `01:05`)
+ *   • medias  ≥ 1 hour    → `h:mm:ss`   (e.g. `1:02:05`)
+ *   • unknown / negative  → `--:--`     (em-dash placeholder while
+ *                                       metadata is still loading,
+ *                                       so the toolbar doesn't flash
+ *                                       `NaN:NaN`)
+ *
+ * Extracted from `<OrigamMediaController>` so both the time label
+ * sub-component AND the scrubber's `format-hover-tooltip` callback
+ * share a single source of truth — keeping `OrigamAudio` consistent
+ * with `OrigamVideo` byte-for-byte.
+ */
+export declare function formatMediaTime(seconds: number): string;

package/dist/src/utils/Media/format-time.util.js

@@ -0,0 +1,10 @@
+export function formatMediaTime(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) return "--:--";
+  const total = Math.floor(seconds);
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  const s = total % 60;
+  const pad = (value) => value.toString().padStart(2, "0");
+  if (h > 0) return `${h}:${pad(m)}:${pad(s)}`;
+  return `${pad(m)}:${pad(s)}`;
+}

package/dist/src/utils/QrCode/qr-code-adapters.util.cjs

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveQrColor = resolveQrColor;
+exports.resolveQrCornerRadius = resolveQrCornerRadius;
+var _color = require("../Commons/color.util.cjs");
+const ROUNDED_TO_CORNER = {
+  "x-small": 0.1,
+  "small": 0.18,
+  "default": 0.25,
+  "medium": 0.3,
+  "large": 0.4,
+  "x-large": 0.5,
+  "shaped": 0.25,
+  "shaped-invert": 0.25
+};
+function resolveQrColor(value, role, fallback) {
+  if (value === null || value === void 0 || value === "") return fallback;
+  if ((0, _color.isIntent)(value)) {
+    return role === "foreground" ? (0, _color.tokenForegroundForIntent)(value) : (0, _color.intentBgExpr)(value, "default");
+  }
+  return String(value);
+}
+function resolveQrCornerRadius(value) {
+  if (value === void 0 || value === null || value === false || value === "") return 0;
+  if (value === true) return 0.5;
+  if (typeof value === "number") return Math.max(0, Math.min(0.5, value));
+  if (typeof value === "string" && value in ROUNDED_TO_CORNER) {
+    return ROUNDED_TO_CORNER[value];
+  }
+  return 0;
+}

package/dist/src/utils/QrCode/qr-code-adapters.util.d.ts

@@ -0,0 +1,49 @@
+import type { TColor, TRounded } from '../../types';
+/**
+ * Transform a DS-shaped colour (intent, raw CSS, `currentColor`,
+ * `transparent`, undefined) into a literal CSS string ready to drop
+ * inside an SVG `fill=""` attribute.
+ *
+ *   • `TIntent` (e.g. `'primary'`, `'success'`) → CSS variable
+ *     reference (`var(--origam-color__action--primary---fg)`) so the
+ *     module colour follows the active theme automatically.
+ *   • Raw CSS (`'#abc123'`, `'rgb(0,0,0)'`, `'currentColor'`) → passed
+ *     through verbatim.
+ *   • `undefined` / `null` / empty → falls back to `fallback`.
+ *
+ * `role` decides which token slot of the intent is read — and the
+ * mapping matches the rest of the DS semantics for `color="primary"`
+ * / `bgColor="primary"` on text + surface elements:
+ *
+ *   • `'foreground'` → the intent's OWN paint (via
+ *     `tokenForegroundForIntent`, i.e. `fgSubtle` for primary /
+ *     feedback intents, `secondary.fg` for neutral / secondary).
+ *     Matches how `useColor` resolves `color="primary"` on any text
+ *     element: the text is painted primary itself, NOT its
+ *     white-on-dark contrast.
+ *   • `'background'` → the intent's `bg` slot (the actual surface
+ *     paint, e.g. primary's main violet) — same channel
+ *     `bgColor="primary"` uses on Card / Btn / Chip.
+ *
+ * This means `qrCodeProps.color="primary"` paints PURPLE modules,
+ * exactly as a consumer reading "make the modules primary" would
+ * expect — not the contrast white-on-primary pairing that
+ * `intentFgExpr` returns.
+ */
+export declare function resolveQrColor(value: TColor | undefined | null, role: 'foreground' | 'background', fallback: string): string;
+/**
+ * Transform a DS-shaped rounded value (`TRounded` named rung, raw
+ * number, boolean, or string) into the per-module corner radius the
+ * QR encoder expects — a number in **module units** ([0, 0.5]).
+ *
+ *   • `'x-small'` … `'x-large'` → looked up in `ROUNDED_TO_CORNER`
+ *     (0.10 … 0.50 module units, picked so each rung paints a
+ *     visibly distinct module shape).
+ *   • `true` → 0.50 (legacy "fully rounded" alias).
+ *   • `false` / `''` / `null` / `undefined` → 0 (strict squares).
+ *   • `number` → clamped to `[0, 0.5]`.
+ *   • CSS dimension (`'4px'`, `'0.25rem'`, …) → 0 (modules speak
+ *     module units, not pixels — pixel input falls back to
+ *     squares instead of silently misbehaving).
+ */
+export declare function resolveQrCornerRadius(value: TRounded | number | boolean | string | null | undefined): number;

package/dist/src/utils/QrCode/qr-code-adapters.util.js

@@ -0,0 +1,27 @@
+import { intentBgExpr, isIntent, tokenForegroundForIntent } from "../Commons/color.util.js";
+const ROUNDED_TO_CORNER = {
+  "x-small": 0.1,
+  "small": 0.18,
+  "default": 0.25,
+  "medium": 0.3,
+  "large": 0.4,
+  "x-large": 0.5,
+  "shaped": 0.25,
+  "shaped-invert": 0.25
+};
+export function resolveQrColor(value, role, fallback) {
+  if (value === null || value === void 0 || value === "") return fallback;
+  if (isIntent(value)) {
+    return role === "foreground" ? tokenForegroundForIntent(value) : intentBgExpr(value, "default");
+  }
+  return String(value);
+}
+export function resolveQrCornerRadius(value) {
+  if (value === void 0 || value === null || value === false || value === "") return 0;
+  if (value === true) return 0.5;
+  if (typeof value === "number") return Math.max(0, Math.min(0.5, value));
+  if (typeof value === "string" && value in ROUNDED_TO_CORNER) {
+    return ROUNDED_TO_CORNER[value];
+  }
+  return 0;
+}

package/dist/src/utils/Textarea/html-to-markdown.util.cjs

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.htmlToMarkdown = htmlToMarkdown;
+function htmlToMarkdown(input) {
+  if (input == null || input === "") return "";
+  if (typeof input !== "string") return "";
+  if (typeof DOMParser === "undefined") return input;
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(`<div id="__origam_md_root__">${input}</div>`, "text/html");
+  const root = doc.getElementById("__origam_md_root__");
+  if (!root) return "";
+  return collapseBlankLines(walk(root).trim());
+}
+function walk(node) {
+  if (node.nodeType === 3) return node.data;
+  if (node.nodeType !== 1) return "";
+  const el = node;
+  const tag = el.tagName.toLowerCase();
+  const inner = Array.from(el.childNodes).map(walk).join("");
+  switch (tag) {
+    case "strong":
+    case "b":
+      return inner ? `**${inner}**` : "";
+    case "em":
+    case "i":
+      return inner ? `*${inner}*` : "";
+    case "u":
+      return inner ? `<u>${inner}</u>` : "";
+    case "code":
+      return inner ? `\`${inner}\`` : "";
+    case "a":
+      {
+        const href = el.getAttribute("href") ?? "";
+        if (!inner) return "";
+        if (!href) return inner;
+        return `[${inner}](${href})`;
+      }
+    case "br":
+      return "\n";
+    case "p":
+      return inner ? `
+
+${inner}
+
+` : "";
+    case "h1":
+      return inner ? `
+
+# ${inner}
+
+` : "";
+    case "h2":
+      return inner ? `
+
+## ${inner}
+
+` : "";
+    case "h3":
+      return inner ? `
+
+### ${inner}
+
+` : "";
+    case "ul":
+      return "\n" + listItems(el, "- ") + "\n";
+    case "ol":
+      return "\n" + listItems(el, idx => `${idx + 1}. `) + "\n";
+    case "li":
+      return inner;
+    default:
+      return inner;
+  }
+}
+function listItems(parent, prefix) {
+  return Array.from(parent.children).filter(c => c.tagName.toLowerCase() === "li").map((li, idx) => {
+    const head = typeof prefix === "string" ? prefix : prefix(idx);
+    return head + Array.from(li.childNodes).map(walk).join("");
+  }).join("\n");
+}
+function collapseBlankLines(s) {
+  return s.replace(/\n{3,}/g, "\n\n");
+}

package/dist/src/utils/Textarea/html-to-markdown.util.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Lightweight HTML → Markdown converter used by `OrigamTextareaField`
+ * when `output="markdown"`. The input is expected to be pre-sanitised
+ * HTML (see `sanitizeHtml`).
+ *
+ * The conversion is intentionally conservative — only the tags emitted
+ * by the rich-toolbar are translated:
+ *   <strong>/<b>          → **text**
+ *   <em>/<i>              → *text*
+ *   <u>                   → <u>text</u>   (no canonical Markdown for underline)
+ *   <a href="X">Y</a>     → [Y](X)
+ *   <ul><li>…</li></ul>   → - …
+ *   <ol><li>…</li></ol>   → 1. …
+ *   <h1>/<h2>/<h3>        → # / ## / ###
+ *   <code>                → `text`
+ *   <p>                   → paragraph (double newline)
+ *   <br>                  → single newline
+ *
+ * Anything else is unwrapped (text content kept).
+ */
+export declare function htmlToMarkdown(input: string): string;

package/dist/src/utils/Textarea/html-to-markdown.util.js

@@ -0,0 +1,78 @@
+export function htmlToMarkdown(input) {
+  if (input == null || input === "") return "";
+  if (typeof input !== "string") return "";
+  if (typeof DOMParser === "undefined") return input;
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(`<div id="__origam_md_root__">${input}</div>`, "text/html");
+  const root = doc.getElementById("__origam_md_root__");
+  if (!root) return "";
+  return collapseBlankLines(walk(root).trim());
+}
+function walk(node) {
+  if (node.nodeType === 3) return node.data;
+  if (node.nodeType !== 1) return "";
+  const el = node;
+  const tag = el.tagName.toLowerCase();
+  const inner = Array.from(el.childNodes).map(walk).join("");
+  switch (tag) {
+    case "strong":
+    case "b":
+      return inner ? `**${inner}**` : "";
+    case "em":
+    case "i":
+      return inner ? `*${inner}*` : "";
+    case "u":
+      return inner ? `<u>${inner}</u>` : "";
+    case "code":
+      return inner ? `\`${inner}\`` : "";
+    case "a": {
+      const href = el.getAttribute("href") ?? "";
+      if (!inner) return "";
+      if (!href) return inner;
+      return `[${inner}](${href})`;
+    }
+    case "br":
+      return "\n";
+    case "p":
+      return inner ? `
+
+${inner}
+
+` : "";
+    case "h1":
+      return inner ? `
+
+# ${inner}
+
+` : "";
+    case "h2":
+      return inner ? `
+
+## ${inner}
+
+` : "";
+    case "h3":
+      return inner ? `
+
+### ${inner}
+
+` : "";
+    case "ul":
+      return "\n" + listItems(el, "- ") + "\n";
+    case "ol":
+      return "\n" + listItems(el, (idx) => `${idx + 1}. `) + "\n";
+    case "li":
+      return inner;
+    default:
+      return inner;
+  }
+}
+function listItems(parent, prefix) {
+  return Array.from(parent.children).filter((c) => c.tagName.toLowerCase() === "li").map((li, idx) => {
+    const head = typeof prefix === "string" ? prefix : prefix(idx);
+    return head + Array.from(li.childNodes).map(walk).join("");
+  }).join("\n");
+}
+function collapseBlankLines(s) {
+  return s.replace(/\n{3,}/g, "\n\n");
+}