@leadertechie/md2html 0.1.0-alpha.19 → 0.1.0-alpha.20

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 import { LoggerInterface } from '@leadertechie/telemetry';
-import { TemplateResult } from 'lit';
 
 /**
  * Handles 'blockquote' tokens.
@@ -328,118 +327,6 @@ export declare class ListHandler implements TokenHandler {
     };
 }
 
-export declare class LitCodeStrategy implements LitNodeRendererStrategy {
-    readonly type = "code";
-    render(node: ContentNode, _renderChild: (child: ContentNode) => TemplateResult): TemplateResult;
-}
-
-export declare class LitContainerStrategy implements LitNodeRendererStrategy {
-    readonly type = "container";
-    render(node: ContentNode, renderChild: (child: ContentNode) => TemplateResult): TemplateResult;
-}
-
-export declare class LitEmphasisStrategy implements LitNodeRendererStrategy {
-    readonly type = "emphasis";
-    render(node: ContentNode, _renderChild: (child: ContentNode) => TemplateResult): TemplateResult;
-}
-
-export declare class LitFallbackStrategy implements LitNodeRendererStrategy {
-    readonly type = "*";
-    render(_node: ContentNode, _renderChild: (child: ContentNode) => TemplateResult): TemplateResult;
-}
-
-export declare class LitHeadingStrategy implements LitNodeRendererStrategy {
-    readonly type = "heading";
-    render(node: ContentNode, _renderChild: (child: ContentNode) => TemplateResult): TemplateResult;
-}
-
-export declare class LitImageStrategy implements LitNodeRendererStrategy {
-    readonly type = "image";
-    render(node: ContentNode, _renderChild: (child: ContentNode) => TemplateResult): TemplateResult;
-}
-
-export declare class LitLinkStrategy implements LitNodeRendererStrategy {
-    readonly type = "link";
-    render(node: ContentNode, _renderChild: (child: ContentNode) => TemplateResult): TemplateResult;
-}
-
-export declare class LitListItemStrategy implements LitNodeRendererStrategy {
-    readonly type = "list-item";
-    render(node: ContentNode, _renderChild: (child: ContentNode) => TemplateResult): TemplateResult;
-}
-
-export declare class LitListStrategy implements LitNodeRendererStrategy {
-    readonly type = "list";
-    render(node: ContentNode, renderChild: (child: ContentNode) => TemplateResult): TemplateResult;
-}
-
-export declare interface LitNodeRendererStrategy {
-    /** The ContentNode type this strategy handles */
-    readonly type: string;
-    /** Render a node to a Lit TemplateResult */
-    render(node: ContentNode, renderChild: (child: ContentNode) => TemplateResult): TemplateResult;
-}
-
-export declare class LitParagraphStrategy implements LitNodeRendererStrategy {
-    readonly type = "paragraph";
-    render(node: ContentNode, renderChild: (child: ContentNode) => TemplateResult): TemplateResult;
-}
-
-export declare class LitRenderer {
-    private strategyRegistry;
-    /** Lazily created HTMLRenderer for string output, sharing the same config */
-    private htmlRenderer?;
-    constructor();
-    /** Access the strategy registry for customization. */
-    get strategies(): LitStrategyRegistry;
-    /**
-     * Render a single node to a Lit TemplateResult.
-     */
-    renderNode(node: ContentNode): TemplateResult;
-    /**
-     * Render an array of nodes to a single Lit TemplateResult.
-     */
-    renderNodes(nodes: ContentNode[]): TemplateResult;
-    /**
-     * Render nodes to a plain HTML string.
-     * Delegates to HTMLRenderer to avoid duplicating string rendering logic.
-     *
-     * Note: Uses default HTMLRenderer config (no classPrefix, scope anchors,
-     * or heading IDs). For full HTML rendering with those features,
-     * use HTMLRenderer directly.
-     */
-    renderToHTMLString(nodes: ContentNode[]): string;
-}
-
-/**
- * Registry of Lit renderer strategies.
- *
- * Two-tier lookup:
- * 1. Dedicated strategy by node type
- * 2. Fallback to a catch-all strategy (default: renders empty)
- */
-export declare class LitStrategyRegistry {
-    private strategies;
-    private fallback;
-    constructor();
-    register(strategy: LitNodeRendererStrategy): void;
-    unregister(type: string): void;
-    get(type: string): LitNodeRendererStrategy;
-    has(type: string): boolean;
-    get types(): string[];
-    setFallback(strategy: LitNodeRendererStrategy): void;
-}
-
-export declare class LitStrongStrategy implements LitNodeRendererStrategy {
-    readonly type = "strong";
-    render(node: ContentNode, _renderChild: (child: ContentNode) => TemplateResult): TemplateResult;
-}
-
-export declare class LitTextStrategy implements LitNodeRendererStrategy {
-    readonly type = "text";
-    render(node: ContentNode, _renderChild: (child: ContentNode) => TemplateResult): TemplateResult;
-}
-
 export declare interface MarkdownContent {
     title: string;
     metadata?: Record<string, unknown>;

package/dist/index.js

@@ -1,5 +1,5 @@
-import { d as defaultAllowedHTMLTags, H as HTMLRenderer } from "./lit-renderer-Bp1Q6wYL.js";
-import { L, a, b, c, e, f, g, h, i, j, k, l, m, n, R, o } from "./lit-renderer-Bp1Q6wYL.js";
+import { d as defaultAllowedHTMLTags, H as HTMLRenderer } from "./renderer-Ba-j0YEq.js";
+import { R, n } from "./renderer-Ba-j0YEq.js";
 import { marked } from "marked";
 class HeadingHandler {
   constructor() {
@@ -233,7 +233,7 @@ class ContainerBlockHandler {
     const classMatches = [...specifier.matchAll(/\.([\w-]+)/g)];
     const tag = tagMatch?.[1] || "div";
     const id = idMatch?.[1] || "";
-    const classes = classMatches.map((m2) => m2[1]);
+    const classes = classMatches.map((m) => m[1]);
     const children = ctx.parseTokens(childTokens, 0);
     return {
       type: "container",
@@ -294,7 +294,7 @@ class TokenHandlerRegistry {
     return this.catchAll;
   }
 }
-var h2 = /* @__PURE__ */ ((t) => (t[t.DEBUG = 1] = "DEBUG", t[t.INFO = 9] = "INFO", t[t.WARN = 13] = "WARN", t[t.ERROR = 17] = "ERROR", t))(h2 || {});
+var h = /* @__PURE__ */ ((t) => (t[t.DEBUG = 1] = "DEBUG", t[t.INFO = 9] = "INFO", t[t.WARN = 13] = "WARN", t[t.ERROR = 17] = "ERROR", t))(h || {});
 const S = {
   1: "DEBUG",
   9: "INFO",
@@ -306,60 +306,60 @@ const S = {
   "/telemetry/src/index.ts"
 ];
 function N() {
-  const e2 = new Error().stack;
-  if (!e2) return;
-  const s = e2.split(`
+  const e = new Error().stack;
+  if (!e) return;
+  const s = e.split(`
 `);
   for (let r = 1; r < s.length; r++) {
-    const o2 = s[r].trim(), n2 = $(o2);
+    const o = s[r].trim(), n2 = $(o);
     if (!n2) continue;
-    const { file: l2 } = n2;
-    if (!(l2 && E.some((m2) => l2.includes(m2))) && !(l2 && l2.includes("/node_modules/")) && l2)
+    const { file: l } = n2;
+    if (!(l && E.some((m) => l.includes(m))) && !(l && l.includes("/node_modules/")) && l)
       return n2;
   }
 }
 function $(t) {
-  const e2 = t.match(
+  const e = t.match(
     /at\s+(?:(?:async\s+)?(?:(.+?)\s+\()?)?(?:(.+?):(\d+):(\d+)\)?)$/
   );
-  if (!e2) return null;
-  const s = e2[1] || "<anonymous>", r = e2[2], o2 = parseInt(e2[3], 10), n2 = parseInt(e2[4], 10);
-  return r ? { file: r, line: o2, column: n2, functionName: s } : null;
+  if (!e) return null;
+  const s = e[1] || "<anonymous>", r = e[2], o = parseInt(e[3], 10), n2 = parseInt(e[4], 10);
+  return r ? { file: r, line: o, column: n2, functionName: s } : null;
 }
-class g2 {
-  constructor(e2 = [], s, r = {}) {
-    this.processors = [...e2], this.resource = s ?? { serviceName: "unknown" }, this.baseAttributes = { ...r };
+class g {
+  constructor(e = [], s, r = {}) {
+    this.processors = [...e], this.resource = s ?? { serviceName: "unknown" }, this.baseAttributes = { ...r };
   }
   // ── Public API ───────────────────────────────────────────────────────────
-  debug(e2, s) {
-    this.emit(h2.DEBUG, e2, void 0, s);
+  debug(e, s) {
+    this.emit(h.DEBUG, e, void 0, s);
   }
-  info(e2, s) {
-    this.emit(h2.INFO, e2, void 0, s);
+  info(e, s) {
+    this.emit(h.INFO, e, void 0, s);
   }
-  warn(e2, s) {
-    this.emit(h2.WARN, e2, void 0, s);
+  warn(e, s) {
+    this.emit(h.WARN, e, void 0, s);
   }
-  error(e2, s, r) {
-    this.emit(h2.ERROR, e2, s, r);
+  error(e, s, r) {
+    this.emit(h.ERROR, e, s, r);
   }
   /**
    * Create a child logger with merged base attributes.
    * Returns a NEW Logger — original is immutable.
    */
-  withContext(e2) {
-    return new g2(this.processors, this.resource, {
+  withContext(e) {
+    return new g(this.processors, this.resource, {
       ...this.baseAttributes,
-      ...e2
+      ...e
     });
   }
   /**
    * Append a processor to the pipeline.
    * Returns a NEW Logger — original is immutable.
    */
-  withProcessor(e2) {
-    return new g2(
-      [...this.processors, e2],
+  withProcessor(e) {
+    return new g(
+      [...this.processors, e],
       this.resource,
       this.baseAttributes
     );
@@ -369,45 +369,45 @@ class g2 {
    * Await before the end of a CF Worker request (inside ctx.waitUntil).
    */
   async flush() {
-    await Promise.all(this.processors.map((e2) => e2.forceFlush()));
+    await Promise.all(this.processors.map((e) => e.forceFlush()));
   }
   /**
    * Shutdown: flush + release resources. No logging after shutdown.
    */
   async shutdown() {
-    await this.flush(), await Promise.all(this.processors.map((e2) => e2.shutdown()));
+    await this.flush(), await Promise.all(this.processors.map((e) => e.shutdown()));
   }
   // ── Internal ────────────────────────────────────────────────────────────
-  emit(e2, s, r, o2) {
+  emit(e, s, r, o) {
     if (this.processors.length === 0) return;
-    const n2 = (/* @__PURE__ */ new Date()).toISOString(), l2 = {
-      severityNumber: e2,
-      severityText: S[e2],
+    const n2 = (/* @__PURE__ */ new Date()).toISOString(), l = {
+      severityNumber: e,
+      severityText: S[e],
       body: s,
       timestamp: n2,
       observedTimestamp: n2,
-      attributes: { ...this.baseAttributes, ...o2 },
+      attributes: { ...this.baseAttributes, ...o },
       caller: N(),
       ...r ? { error: r } : {},
       resource: { ...this.resource }
     };
-    for (const m2 of this.processors)
+    for (const m of this.processors)
       try {
-        m2.onEmit(l2);
-      } catch (f2) {
+        m.onEmit(l);
+      } catch (f) {
         console.error(
           "[telemetry] Processor threw in onEmit:",
-          f2
+          f
         );
       }
   }
 }
 class T {
-  constructor(e2) {
-    this.shutdownFlag = false, this.pendingExport = Promise.resolve(), this.adapter = e2;
+  constructor(e) {
+    this.shutdownFlag = false, this.pendingExport = Promise.resolve(), this.adapter = e;
   }
-  onEmit(e2) {
-    this.shutdownFlag || (this.pendingExport = this.pendingExport.then(() => this.adapter.export([e2])).catch((s) => {
+  onEmit(e) {
+    this.shutdownFlag || (this.pendingExport = this.pendingExport.then(() => this.adapter.export([e])).catch((s) => {
       console.error(
         `[telemetry] SimpleLogProcessor: adapter "${this.adapter.name}" export failed:`,
         s
@@ -422,73 +422,73 @@ class T {
   }
 }
 class M {
-  constructor(e2) {
+  constructor(e) {
     this.processors = [], this.resource = {
-      serviceName: e2?.serviceName ?? "unknown",
-      environment: e2?.environment,
-      version: e2?.version,
-      processName: e2?.processName
+      serviceName: e?.serviceName ?? "unknown",
+      environment: e?.environment,
+      version: e?.version,
+      processName: e?.processName
     };
   }
   /**
    * Register an adapter via a SimpleLogProcessor (immediate export).
    * For batching, use addProcessor(new BatchLogProcessor(adapter, opts)).
    */
-  addAdapter(e2) {
-    return this.addProcessor(new T(e2));
+  addAdapter(e) {
+    return this.addProcessor(new T(e));
   }
   /**
    * Register a custom processor (SimpleLogProcessor, BatchLogProcessor,
    * or your own implementation).
    */
-  addProcessor(e2) {
-    return this.processors.push(e2), this;
+  addProcessor(e) {
+    return this.processors.push(e), this;
   }
   /**
    * Get a named Logger instance.
    * The logger inherits the provider's resource and processors.
    * Optionally provide initial context attributes.
    */
-  getLogger(e2, s) {
+  getLogger(e, s) {
     const r = {
       ...this.resource,
-      ...e2 ? { processName: e2 } : {}
+      ...e ? { processName: e } : {}
     };
-    return new g2(this.processors, r, s);
+    return new g(this.processors, r, s);
   }
   /**
    * Force-flush all registered processors.
    */
   async flush() {
-    await Promise.all(this.processors.map((e2) => e2.forceFlush()));
+    await Promise.all(this.processors.map((e) => e.forceFlush()));
   }
   /**
    * Shutdown: flush + release all processor resources.
    */
   async shutdown() {
-    await this.flush(), await Promise.all(this.processors.map((e2) => e2.shutdown()));
+    await this.flush(), await Promise.all(this.processors.map((e) => e.shutdown()));
   }
 }
 function U(t) {
-  const e2 = t?.level ?? h2.DEBUG, s = t?.json ?? false;
+  const e = t?.level ?? h.DEBUG, s = t?.json ?? false;
   return {
     name: "console",
     async export(r) {
-      for (const o2 of r)
-        o2.severityNumber < e2 || (s ? I(o2) : R2(o2));
+      for (const o of r)
+        o.severityNumber < e || (s ? I(o) : R2(o));
     }
   };
 }
 function R2(t) {
-  const e2 = F(t.severityNumber), s = t.timestamp, r = t.severityText, o2 = t.caller ? ` (${t.caller.file}:${t.caller.line})` : "", n2 = Object.keys(t.attributes).length > 0;
-  !!t.error ? e2(
-    `[${s}] [${r}]${o2} ${t.body}`,
+  const e = F(t.severityNumber), s = t.timestamp, r = t.severityText, o = t.caller ? ` (${t.caller.file}:${t.caller.line})` : "", n2 = Object.keys(t.attributes).length > 0;
+  !!t.error ? e(
+    `[${s}] [${r}]${o} ${t.body}`,
     t.attributes,
     t.error
-  ) : n2 ? e2(`[${s}] [${r}]${o2} ${t.body}`, t.attributes) : e2(`[${s}] [${r}]${o2} ${t.body}`);
+  ) : n2 ? e(`[${s}] [${r}]${o} ${t.body}`, t.attributes) : e(`[${s}] [${r}]${o} ${t.body}`);
 }
 function I(t) {
-  const e2 = {
+  const e = {
     timestamp: t.timestamp,
     level: t.severityText,
     message: t.body,
@@ -497,21 +497,21 @@ function I(t) {
     attributes: t.attributes,
     caller: t.caller
   };
-  t.error && (e2.error = {
+  t.error && (e.error = {
     name: t.error.name,
     message: t.error.message,
     stack: t.error.stack
-  }), console.log(JSON.stringify(e2));
+  }), console.log(JSON.stringify(e));
 }
 function F(t) {
   switch (t) {
-    case h2.ERROR:
+    case h.ERROR:
       return console.error.bind(console);
-    case h2.WARN:
+    case h.WARN:
       return console.warn.bind(console);
-    case h2.INFO:
+    case h.INFO:
       return console.log.bind(console);
-    case h2.DEBUG:
+    case h.DEBUG:
     default:
       return console.debug.bind(console);
   }
@@ -521,7 +521,7 @@ function getDefaultLogger(serviceName) {
   let log = defaultLoggers.get(serviceName);
   if (!log) {
     const provider = new M({ serviceName });
-    provider.addAdapter(U({ level: h2.WARN }));
+    provider.addAdapter(U({ level: h.WARN }));
     log = provider.getLogger();
     defaultLoggers.set(serviceName, log);
   }
@@ -1096,20 +1096,6 @@ export {
   ImageHandler,
   LinkHandler,
   ListHandler,
-  L as LitCodeStrategy,
-  a as LitContainerStrategy,
-  b as LitEmphasisStrategy,
-  c as LitFallbackStrategy,
-  e as LitHeadingStrategy,
-  f as LitImageStrategy,
-  g as LitLinkStrategy,
-  h as LitListItemStrategy,
-  i as LitListStrategy,
-  j as LitParagraphStrategy,
-  k as LitRenderer,
-  l as LitStrategyRegistry,
-  m as LitStrongStrategy,
-  n as LitTextStrategy,
   MarkdownParser,
   MarkdownPipeline,
   NodeFactory,
@@ -1124,7 +1110,7 @@ export {
   createDefaultPreprocessor,
   createParseContext,
   defaultAllowedHTMLTags,
-  o as nodeTypeToScope,
+  n as nodeTypeToScope,
   walkTree
 };
 //# sourceMappingURL=index.js.map