@haklex/rich-litexml 0.0.94

package/dist/default-registry.d.ts

@@ -0,0 +1,3 @@
+import { LitexmlRegistry } from './registry';
+export declare function createDefaultRegistry(): LitexmlRegistry;
+//# sourceMappingURL=default-registry.d.ts.map

package/dist/default-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-registry.d.ts","sourceRoot":"","sources":["../src/default-registry.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAI7C,wBAAgB,qBAAqB,IAAI,eAAe,CAOvD"}

package/dist/deserializer.d.ts

@@ -0,0 +1,5 @@
+import { SerializedEditorState, SerializedLexicalNode } from 'lexical';
+import { LitexmlRegistry } from './registry';
+export declare function deserializeFromXml(xml: string, registry: LitexmlRegistry): SerializedEditorState;
+export declare function deserializeNodesFromXml(xml: string, registry: LitexmlRegistry): SerializedLexicalNode[];
+//# sourceMappingURL=deserializer.d.ts.map

package/dist/deserializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deserializer.d.ts","sourceRoot":"","sources":["../src/deserializer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAG5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAUlD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,GAAG,qBAAqB,CAkBhG;AAED,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,eAAe,GACxB,qBAAqB,EAAE,CAKzB"}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { createDefaultRegistry } from './default-registry';
+export { deserializeFromXml, deserializeNodesFromXml } from './deserializer';
+export { registerBuiltinReaders } from './readers/builtin';
+export { registerCustomReaders } from './readers/custom';
+export { LitexmlRegistry } from './registry';
+export type { XmlSerializerOptions } from './serializer';
+export { serializeNodesToXml, serializeToXml } from './serializer';
+export type { ReaderContext, WriterContext, XmlContent, XmlElement, XmlReaderFn, XmlWriterFn, } from './types';
+export { registerBuiltinWriters } from './writers/builtin';
+export { registerCustomWriters } from './writers/custom';
+export type { XmlRenderOptions } from './xml-utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAC7E,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,YAAY,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnE,YAAY,EACV,aAAa,EACb,aAAa,EACb,UAAU,EACV,UAAU,EACV,WAAW,EACX,WAAW,GACZ,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACzD,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.mjs

@@ -0,0 +1,1096 @@
+import { parseHTML } from "linkedom";
+function extractBlockId$1(el) {
+  const id = el.getAttribute("id");
+  return id ? { $: { blockId: id } } : {};
+}
+const ELEMENT_DEFAULTS = {
+  direction: "ltr",
+  format: "",
+  indent: 0,
+  textFormat: 0,
+  textStyle: "",
+  version: 1
+};
+function registerBuiltinReaders(registry) {
+  registry.registerReader(
+    "p",
+    (el, ctx) => ({
+      type: "paragraph",
+      ...extractBlockId$1(el),
+      children: ctx.parseChildren(el),
+      ...ELEMENT_DEFAULTS
+    })
+  );
+  for (let level = 1; level <= 6; level++) {
+    registry.registerReader(
+      `h${level}`,
+      (el, ctx) => ({
+        type: "heading",
+        tag: `h${level}`,
+        ...extractBlockId$1(el),
+        children: ctx.parseChildren(el),
+        ...ELEMENT_DEFAULTS
+      })
+    );
+  }
+  registry.registerReader(
+    "blockquote",
+    (el, ctx) => ({
+      type: "quote",
+      ...extractBlockId$1(el),
+      children: ctx.parseChildren(el),
+      ...ELEMENT_DEFAULTS
+    })
+  );
+  registry.registerReader(
+    "hr",
+    (el) => ({
+      type: "horizontalrule",
+      ...extractBlockId$1(el),
+      version: 1
+    })
+  );
+  registry.registerReader("ul", (el, ctx) => {
+    const isCheck = el.getAttribute("type") === "check";
+    return {
+      type: "list",
+      listType: isCheck ? "check" : "bullet",
+      tag: "ul",
+      start: 1,
+      ...extractBlockId$1(el),
+      children: ctx.parseChildren(el),
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      version: 1
+    };
+  });
+  registry.registerReader(
+    "ol",
+    (el, ctx) => ({
+      type: "list",
+      listType: "number",
+      tag: "ol",
+      start: Number(el.getAttribute("start") ?? 1),
+      ...extractBlockId$1(el),
+      children: ctx.parseChildren(el),
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      version: 1
+    })
+  );
+  registry.registerReader("li", (el, ctx) => {
+    const checked = el.getAttribute("checked");
+    return {
+      type: "listitem",
+      ...extractBlockId$1(el),
+      ...checked !== null ? { checked: checked === "true" } : {},
+      children: ctx.parseChildren(el),
+      ...ELEMENT_DEFAULTS,
+      value: 1
+    };
+  });
+  registry.registerReader(
+    "a",
+    (el, ctx) => ({
+      type: "link",
+      url: el.getAttribute("href") ?? "",
+      target: el.getAttribute("target") ?? null,
+      title: el.getAttribute("title") ?? null,
+      rel: null,
+      children: ctx.parseChildren(el),
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      version: 1
+    })
+  );
+  registry.registerReader(
+    "table",
+    (el, ctx) => ({
+      type: "table",
+      ...extractBlockId$1(el),
+      children: ctx.parseChildren(el),
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      version: 1
+    })
+  );
+  registry.registerReader(
+    "tr",
+    (el, ctx) => ({
+      type: "tablerow",
+      children: ctx.parseChildren(el),
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      version: 1
+    })
+  );
+  registry.registerReader(
+    "th",
+    (el, ctx) => ({
+      type: "tablecell",
+      headerState: 1,
+      children: ctx.parseChildren(el),
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      version: 1
+    })
+  );
+  registry.registerReader(
+    "td",
+    (el, ctx) => ({
+      type: "tablecell",
+      headerState: 0,
+      children: ctx.parseChildren(el),
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      version: 1
+    })
+  );
+}
+function extractBlockId(el) {
+  const id = el.getAttribute("id");
+  return id ? { $: { blockId: id } } : {};
+}
+function numAttr(el, name) {
+  const v = el.getAttribute(name);
+  return v !== null ? Number(v) : void 0;
+}
+function registerCustomReaders(registry) {
+  registry.registerReader("img", (el) => {
+    if (el.parentElement?.tagName.toLowerCase() === "gallery") return false;
+    return {
+      type: "image",
+      ...extractBlockId(el),
+      src: el.getAttribute("src") ?? "",
+      altText: el.getAttribute("alt") ?? "",
+      width: numAttr(el, "width"),
+      height: numAttr(el, "height"),
+      caption: el.getAttribute("caption") ?? void 0,
+      thumbhash: el.getAttribute("thumbhash") ?? void 0,
+      accent: el.getAttribute("accent") ?? void 0,
+      version: 1
+    };
+  });
+  registry.registerReader(
+    "video",
+    (el) => ({
+      type: "video",
+      ...extractBlockId(el),
+      src: el.getAttribute("src") ?? "",
+      poster: el.getAttribute("poster") ?? void 0,
+      width: numAttr(el, "width"),
+      height: numAttr(el, "height"),
+      version: 1
+    })
+  );
+  registry.registerReader(
+    "linkcard",
+    (el) => ({
+      type: "link-card",
+      ...extractBlockId(el),
+      url: el.getAttribute("url") ?? "",
+      source: el.getAttribute("source") ?? void 0,
+      title: el.getAttribute("title") ?? void 0,
+      description: el.getAttribute("description") ?? void 0,
+      favicon: el.getAttribute("favicon") ?? void 0,
+      image: el.getAttribute("image") ?? void 0,
+      version: 1
+    })
+  );
+  registry.registerReader(
+    "embed",
+    (el) => ({
+      type: "embed",
+      ...extractBlockId(el),
+      url: el.getAttribute("url") ?? "",
+      source: el.getAttribute("source") ?? null,
+      version: 1
+    })
+  );
+  registry.registerReader(
+    "codeblock",
+    (el) => ({
+      type: "code-block",
+      ...extractBlockId(el),
+      code: el.textContent ?? "",
+      language: el.getAttribute("lang") ?? "",
+      version: 1
+    })
+  );
+  registry.registerReader(
+    "mermaid",
+    (el) => ({
+      type: "mermaid",
+      ...extractBlockId(el),
+      diagram: el.textContent ?? "",
+      version: 1
+    })
+  );
+  registry.registerReader("math", (el) => {
+    const display = el.getAttribute("display");
+    if (display === "block") {
+      return {
+        type: "katex-block",
+        ...extractBlockId(el),
+        equation: el.textContent ?? "",
+        version: 1
+      };
+    }
+    return {
+      type: "katex-inline",
+      equation: el.textContent ?? "",
+      version: 1
+    };
+  });
+  registry.registerReader("alert", (el, ctx) => {
+    const children = ctx.parseChildren(el);
+    const content = {
+      root: {
+        type: "root",
+        children,
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        version: 1
+      }
+    };
+    return {
+      type: "alert-quote",
+      ...extractBlockId(el),
+      alertType: el.getAttribute("type") ?? "note",
+      content,
+      version: 1
+    };
+  });
+  registry.registerReader("banner", (el, ctx) => {
+    const children = ctx.parseChildren(el);
+    const content = {
+      root: {
+        type: "root",
+        children,
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        version: 1
+      }
+    };
+    return {
+      type: "banner",
+      ...extractBlockId(el),
+      bannerType: el.getAttribute("type") ?? "note",
+      content,
+      version: 1
+    };
+  });
+  registry.registerReader("nesteddoc", (el, ctx) => {
+    const children = ctx.parseChildren(el);
+    const content = {
+      root: {
+        type: "root",
+        children,
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        version: 1
+      }
+    };
+    return {
+      type: "nested-doc",
+      ...extractBlockId(el),
+      content,
+      version: 1
+    };
+  });
+  registry.registerReader(
+    "details",
+    (el, ctx) => ({
+      type: "details",
+      ...extractBlockId(el),
+      summary: el.getAttribute("summary") ?? "",
+      open: el.getAttribute("open") === "true",
+      children: ctx.parseChildren(el),
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      version: 1
+    })
+  );
+  registry.registerReader(
+    "spoiler",
+    (el, ctx) => ({
+      type: "spoiler",
+      children: ctx.parseChildren(el),
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      textFormat: 0,
+      textStyle: "",
+      version: 1
+    })
+  );
+  registry.registerReader(
+    "ruby",
+    (el, ctx) => ({
+      type: "ruby",
+      reading: el.getAttribute("rt") ?? "",
+      children: ctx.parseChildren(el),
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      textFormat: 0,
+      textStyle: "",
+      version: 1
+    })
+  );
+  registry.registerReader(
+    "mention",
+    (el) => ({
+      type: "mention",
+      platform: el.getAttribute("platform") ?? "",
+      handle: el.getAttribute("handle") ?? "",
+      displayName: el.textContent || void 0,
+      version: 1
+    })
+  );
+  registry.registerReader(
+    "tag",
+    (el) => ({
+      type: "tag",
+      text: el.textContent ?? "",
+      format: 0,
+      detail: 0,
+      mode: "normal",
+      style: "",
+      version: 1
+    })
+  );
+  registry.registerReader(
+    "comment",
+    (el) => ({
+      type: "comment",
+      text: el.textContent ?? "",
+      format: 0,
+      detail: 0,
+      mode: "normal",
+      style: "",
+      version: 1
+    })
+  );
+  registry.registerReader(
+    "footnote",
+    (el) => ({
+      type: "footnote",
+      identifier: el.getAttribute("ref") ?? "",
+      version: 1
+    })
+  );
+  registry.registerReader("footnotesection", (el) => {
+    const definitions = {};
+    for (const child of el.children) {
+      if (child.tagName.toLowerCase() === "def") {
+        const ref = child.getAttribute("ref") ?? "";
+        definitions[ref] = child.textContent ?? "";
+      }
+    }
+    return {
+      type: "footnote-section",
+      ...extractBlockId(el),
+      definitions,
+      version: 1
+    };
+  });
+  registry.registerReader("gallery", (el) => {
+    const images = [];
+    for (const child of el.children) {
+      if (child.tagName.toLowerCase() === "img") {
+        images.push({
+          src: child.getAttribute("src") ?? "",
+          alt: child.getAttribute("alt") ?? void 0
+        });
+      }
+    }
+    return {
+      type: "gallery",
+      ...extractBlockId(el),
+      images,
+      layout: el.getAttribute("layout") ?? "grid",
+      version: 1
+    };
+  });
+  registry.registerReader("codesnippet", (el) => {
+    const files = [];
+    for (const child of el.children) {
+      if (child.tagName.toLowerCase() === "file") {
+        files.push({
+          filename: child.getAttribute("name") ?? "",
+          code: child.textContent ?? "",
+          language: child.getAttribute("lang") ?? ""
+        });
+      }
+    }
+    return {
+      type: "code-snippet",
+      ...extractBlockId(el),
+      files,
+      version: 1
+    };
+  });
+}
+class LitexmlRegistry {
+  constructor() {
+    this.writers = /* @__PURE__ */ new Map();
+    this.readers = /* @__PURE__ */ new Map();
+  }
+  registerWriter(nodeType, writer) {
+    this.writers.set(nodeType, writer);
+  }
+  registerReader(tagName, reader) {
+    this.readers.set(tagName.toLowerCase(), reader);
+  }
+  getWriter(nodeType) {
+    return this.writers.get(nodeType);
+  }
+  getReader(tagName) {
+    return this.readers.get(tagName.toLowerCase());
+  }
+}
+function blockId$1(node) {
+  return node.$?.blockId ? { id: node.$.blockId } : {};
+}
+function registerBuiltinWriters(registry) {
+  registry.registerWriter("paragraph", (node, ctx) => {
+    const n = node;
+    return {
+      tag: "p",
+      attrs: blockId$1(n),
+      children: ctx.serializeChildren(n.children ?? [])
+    };
+  });
+  registry.registerWriter("heading", (node, ctx) => {
+    const n = node;
+    const tag = n.tag ?? "h1";
+    return {
+      tag,
+      attrs: blockId$1(n),
+      children: ctx.serializeChildren(n.children ?? [])
+    };
+  });
+  registry.registerWriter("quote", (node, ctx) => {
+    const n = node;
+    return {
+      tag: "blockquote",
+      attrs: blockId$1(n),
+      children: ctx.serializeChildren(n.children ?? [])
+    };
+  });
+  registry.registerWriter("horizontalrule", (node) => {
+    const n = node;
+    return { tag: "hr", attrs: blockId$1(n), selfClosing: true };
+  });
+  registry.registerWriter("list", (node, ctx) => {
+    const n = node;
+    const tag = n.listType === "number" ? "ol" : "ul";
+    const attrs = { ...blockId$1(n) };
+    if (n.listType === "check") attrs.type = "check";
+    return {
+      tag,
+      attrs,
+      children: ctx.serializeChildren(n.children ?? [])
+    };
+  });
+  registry.registerWriter("listitem", (node, ctx) => {
+    const n = node;
+    const attrs = { ...blockId$1(n) };
+    if (n.checked !== void 0) attrs.checked = String(n.checked);
+    return {
+      tag: "li",
+      attrs,
+      children: ctx.serializeChildren(n.children ?? [])
+    };
+  });
+  registry.registerWriter("link", (node, ctx) => {
+    const n = node;
+    const attrs = { href: n.url ?? "" };
+    if (n.target) attrs.target = n.target;
+    if (n.title) attrs.title = n.title;
+    return {
+      tag: "a",
+      attrs,
+      children: ctx.serializeChildren(n.children ?? [])
+    };
+  });
+  registry.registerWriter("autolink", (node, ctx) => {
+    const n = node;
+    return {
+      tag: "a",
+      attrs: { href: n.url ?? "" },
+      children: ctx.serializeChildren(n.children ?? [])
+    };
+  });
+  registry.registerWriter("table", (node, ctx) => {
+    const n = node;
+    return {
+      tag: "table",
+      attrs: blockId$1(n),
+      children: ctx.serializeChildren(n.children ?? [])
+    };
+  });
+  registry.registerWriter("tablerow", (node, ctx) => {
+    const n = node;
+    return {
+      tag: "tr",
+      children: ctx.serializeChildren(n.children ?? [])
+    };
+  });
+  registry.registerWriter("tablecell", (node, ctx) => {
+    const n = node;
+    const tag = n.headerState === 1 ? "th" : "td";
+    return {
+      tag,
+      children: ctx.serializeChildren(n.children ?? [])
+    };
+  });
+}
+function blockId(node) {
+  return node.$?.blockId ? { id: node.$.blockId } : {};
+}
+function optAttr(attrs) {
+  const result = {};
+  for (const [k, v] of Object.entries(attrs)) {
+    if (v !== void 0 && v !== null && v !== "") result[k] = String(v);
+  }
+  return result;
+}
+function registerCustomWriters(registry) {
+  registry.registerWriter("image", (node) => {
+    const n = node;
+    return {
+      tag: "img",
+      attrs: optAttr({
+        ...blockId(n),
+        src: n.src,
+        alt: n.altText,
+        width: n.width != null ? String(n.width) : void 0,
+        height: n.height != null ? String(n.height) : void 0,
+        caption: n.caption,
+        thumbhash: n.thumbhash,
+        accent: n.accent
+      }),
+      selfClosing: true
+    };
+  });
+  registry.registerWriter("video", (node) => {
+    const n = node;
+    return {
+      tag: "video",
+      attrs: optAttr({ ...blockId(n), src: n.src, poster: n.poster }),
+      selfClosing: true
+    };
+  });
+  registry.registerWriter("link-card", (node) => {
+    const n = node;
+    return {
+      tag: "linkcard",
+      attrs: optAttr({
+        ...blockId(n),
+        url: n.url,
+        source: n.source,
+        title: n.title,
+        description: n.description,
+        favicon: n.favicon,
+        image: n.image
+      }),
+      selfClosing: true
+    };
+  });
+  registry.registerWriter("embed", (node) => {
+    const n = node;
+    return {
+      tag: "embed",
+      attrs: optAttr({ ...blockId(n), url: n.url, source: n.source }),
+      selfClosing: true
+    };
+  });
+  registry.registerWriter("code-block", (node) => {
+    const n = node;
+    return {
+      tag: "codeblock",
+      attrs: optAttr({ ...blockId(n), lang: n.language }),
+      children: [n.code ?? ""]
+    };
+  });
+  registry.registerWriter("mermaid", (node) => {
+    const n = node;
+    return {
+      tag: "mermaid",
+      attrs: blockId(n),
+      children: [n.diagram ?? ""]
+    };
+  });
+  registry.registerWriter("katex-block", (node) => {
+    const n = node;
+    return {
+      tag: "math",
+      attrs: { ...blockId(n), display: "block" },
+      children: [n.equation ?? ""]
+    };
+  });
+  registry.registerWriter("katex-inline", (node) => {
+    const n = node;
+    return {
+      tag: "math",
+      children: [n.equation ?? ""]
+    };
+  });
+  registry.registerWriter("alert-quote", (node, ctx) => {
+    const n = node;
+    return {
+      tag: "alert",
+      attrs: optAttr({ ...blockId(n), type: n.alertType }),
+      children: ctx.serializeNestedState(n.content)
+    };
+  });
+  registry.registerWriter("banner", (node, ctx) => {
+    const n = node;
+    return {
+      tag: "banner",
+      attrs: optAttr({ ...blockId(n), type: n.bannerType }),
+      children: ctx.serializeNestedState(n.content)
+    };
+  });
+  registry.registerWriter("nested-doc", (node, ctx) => {
+    const n = node;
+    return {
+      tag: "nesteddoc",
+      attrs: blockId(n),
+      children: ctx.serializeNestedState(n.content ?? n.contentState)
+    };
+  });
+  registry.registerWriter("details", (node, ctx) => {
+    const n = node;
+    return {
+      tag: "details",
+      attrs: optAttr({
+        ...blockId(n),
+        summary: n.summary,
+        open: n.open != null ? String(n.open) : void 0
+      }),
+      children: ctx.serializeChildren(n.children ?? [])
+    };
+  });
+  registry.registerWriter("spoiler", (node, ctx) => {
+    const n = node;
+    return {
+      tag: "spoiler",
+      children: ctx.serializeChildren(n.children ?? [])
+    };
+  });
+  registry.registerWriter("ruby", (node, ctx) => {
+    const n = node;
+    return {
+      tag: "ruby",
+      attrs: optAttr({ rt: n.reading }),
+      children: ctx.serializeChildren(n.children ?? [])
+    };
+  });
+  registry.registerWriter("mention", (node) => {
+    const n = node;
+    return {
+      tag: "mention",
+      attrs: optAttr({ platform: n.platform, handle: n.handle }),
+      children: [n.displayName ?? n.handle ?? ""]
+    };
+  });
+  registry.registerWriter("tag", (node) => {
+    const n = node;
+    return { tag: "tag", children: [n.text ?? ""] };
+  });
+  registry.registerWriter("comment", (node) => {
+    const n = node;
+    return { tag: "comment", children: [n.text ?? ""] };
+  });
+  registry.registerWriter("footnote", (node) => {
+    const n = node;
+    return { tag: "footnote", attrs: { ref: n.identifier ?? "" }, selfClosing: true };
+  });
+  registry.registerWriter("footnote-section", (node) => {
+    const n = node;
+    const defs = n.definitions ?? {};
+    const children = Object.entries(defs).map(([ref, text]) => ({
+      tag: "def",
+      attrs: { ref },
+      children: [text]
+    }));
+    return { tag: "footnotesection", attrs: blockId(n), children };
+  });
+  registry.registerWriter("gallery", (node) => {
+    const n = node;
+    const images = (n.images ?? []).map((img) => ({
+      tag: "img",
+      attrs: optAttr({ src: img.src, alt: img.alt }),
+      selfClosing: true
+    }));
+    return {
+      tag: "gallery",
+      attrs: optAttr({ ...blockId(n), layout: n.layout }),
+      children: images
+    };
+  });
+  registry.registerWriter("code-snippet", (node) => {
+    const n = node;
+    const files = (n.files ?? []).map((f) => ({
+      tag: "file",
+      attrs: optAttr({ name: f.filename, lang: f.language }),
+      children: [f.code ?? ""]
+    }));
+    return { tag: "codesnippet", attrs: blockId(n), children: files };
+  });
+}
+function createDefaultRegistry() {
+  const registry = new LitexmlRegistry();
+  registerBuiltinWriters(registry);
+  registerBuiltinReaders(registry);
+  registerCustomWriters(registry);
+  registerCustomReaders(registry);
+  return registry;
+}
+const FORMAT_BIT_TO_TAG = [
+  [1, "b"],
+  [2, "i"],
+  [4, "s"],
+  [8, "u"],
+  [16, "code"],
+  [32, "sub"],
+  [64, "sup"],
+  [128, "mark"]
+];
+const FORMAT_TAG_TO_BIT = {
+  b: 1,
+  strong: 1,
+  i: 2,
+  em: 2,
+  s: 4,
+  del: 4,
+  strike: 4,
+  u: 8,
+  code: 16,
+  sub: 32,
+  sup: 64,
+  mark: 128
+};
+function wrapWithFormatTags(text, format) {
+  if (format === 0) return [text];
+  let content = [text];
+  for (let idx = FORMAT_BIT_TO_TAG.length - 1; idx >= 0; idx--) {
+    const [bit, tag] = FORMAT_BIT_TO_TAG[idx];
+    if (format & bit) {
+      content = [{ tag, children: content }];
+    }
+  }
+  return content;
+}
+function isFormatTag(tagName) {
+  return tagName.toLowerCase() in FORMAT_TAG_TO_BIT;
+}
+function getFormatBit(tagName) {
+  return FORMAT_TAG_TO_BIT[tagName.toLowerCase()] ?? 0;
+}
+function parseXml(xml) {
+  const { document } = parseHTML(`<!DOCTYPE html><html><body>${xml}</body></html>`);
+  return document;
+}
+function deserializeFromXml(xml, registry) {
+  const doc = parseXml(xml);
+  const docEl = doc.querySelector("doc") ?? doc.body;
+  const ctx = createReaderContext(registry);
+  const children = ctx.parseChildren(docEl);
+  return {
+    root: {
+      type: "root",
+      children,
+      direction: "ltr",
+      format: "",
+      indent: 0,
+      version: 1
+    }
+  };
+}
+function deserializeNodesFromXml(xml, registry) {
+  const doc = parseXml(`<fragment>${xml}</fragment>`);
+  const fragment = doc.querySelector("fragment") ?? doc.body;
+  const ctx = createReaderContext(registry);
+  return ctx.parseChildren(fragment);
+}
+const BLOCK_TAGS = /* @__PURE__ */ new Set([
+  "doc",
+  "fragment",
+  "root",
+  "ul",
+  "ol",
+  "table",
+  "tr",
+  "alert",
+  "banner",
+  "details",
+  "nesteddoc",
+  "gallery",
+  "codesnippet",
+  "footnotesection"
+]);
+function isBlockContainer(element) {
+  return BLOCK_TAGS.has(element.tagName.toLowerCase());
+}
+function createReaderContext(registry) {
+  const ctx = {
+    parseChildren(element) {
+      const blockLevel = isBlockContainer(element);
+      const nodes = [];
+      for (const child of element.childNodes) {
+        if (child.nodeType === 3) {
+          const text = child.textContent ?? "";
+          if (blockLevel && text.trim() === "") continue;
+          if (text === "") continue;
+          nodes.push(makeTextNode(text, 0));
+        } else if (child.nodeType === 1) {
+          const el = child;
+          const parsed = parseElement(el, registry, ctx, 0);
+          if (parsed) {
+            if (Array.isArray(parsed)) nodes.push(...parsed);
+            else nodes.push(parsed);
+          }
+        }
+      }
+      return nodes;
+    },
+    parseNestedState(xml) {
+      return deserializeFromXml(xml, registry);
+    }
+  };
+  return ctx;
+}
+function parseElement(element, registry, ctx, inheritedFormat) {
+  const tag = element.tagName.toLowerCase();
+  if (isFormatTag(tag)) {
+    const format = inheritedFormat | getFormatBit(tag);
+    return parseInlineChildren(element, registry, ctx, format);
+  }
+  if (tag === "br") {
+    return { type: "linebreak", version: 1 };
+  }
+  if (tag === "node") {
+    return parseFallbackNode(element);
+  }
+  const reader = registry.getReader(tag);
+  if (reader) {
+    const result = reader(element, ctx);
+    if (result !== false) return result;
+  }
+  return ctx.parseChildren(element);
+}
+function parseInlineChildren(element, registry, ctx, format) {
+  const nodes = [];
+  for (const child of element.childNodes) {
+    if (child.nodeType === 3) {
+      const text = child.textContent ?? "";
+      if (text === "") continue;
+      nodes.push(makeTextNode(text, format));
+    } else if (child.nodeType === 1) {
+      const el = child;
+      const parsed = parseElement(el, registry, ctx, format);
+      if (parsed) {
+        if (Array.isArray(parsed)) nodes.push(...parsed);
+        else nodes.push(parsed);
+      }
+    }
+  }
+  return nodes;
+}
+function parseFallbackNode(element) {
+  const type = element.getAttribute("type") ?? "unknown";
+  const id = element.getAttribute("id");
+  const dataStr = element.getAttribute("data");
+  const data = dataStr ? JSON.parse(dataStr) : {};
+  return {
+    type,
+    ...id ? { $: { blockId: id } } : {},
+    ...data,
+    version: 1
+  };
+}
+function makeTextNode(text, format) {
+  return {
+    type: "text",
+    text,
+    format,
+    detail: 0,
+    mode: "normal",
+    style: "",
+    version: 1
+  };
+}
+const ESCAPE_MAP = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&apos;"
+};
+function escapeXml(text) {
+  return text.replaceAll(/["&'<>]/g, (ch) => ESCAPE_MAP[ch]);
+}
+function buildAttrs(attrs) {
+  const parts = Object.entries(attrs).filter(([, v]) => v !== void 0 && v !== "").map(([k, v]) => ` ${k}="${escapeXml(v)}"`);
+  return parts.join("");
+}
+function renderXml(content, indent = 0, options = {}) {
+  const lines = [];
+  for (const item of content) {
+    if (typeof item === "string") {
+      lines.push(escapeXml(item));
+    } else {
+      lines.push(renderElement(item, indent, options));
+    }
+  }
+  return lines.join("");
+}
+function renderElement(el, indent, options) {
+  const attrs = el.attrs ? buildAttrs(el.attrs) : "";
+  const compact = options.compact === true;
+  if (el.selfClosing) {
+    return compact ? `<${el.tag}${attrs} />` : `${pad(indent)}<${el.tag}${attrs} />
+`;
+  }
+  if (!el.children || el.children.length === 0) {
+    return compact ? `<${el.tag}${attrs} />` : `${pad(indent)}<${el.tag}${attrs} />
+`;
+  }
+  const allInline = el.children.every((c) => typeof c === "string" || isInlineElement(c));
+  if (allInline) {
+    const inner2 = el.children.map((c) => typeof c === "string" ? escapeXml(c) : renderInline(c)).join("");
+    return compact ? `<${el.tag}${attrs}>${inner2}</${el.tag}>` : `${pad(indent)}<${el.tag}${attrs}>${inner2}</${el.tag}>
+`;
+  }
+  if (compact) {
+    const inner2 = el.children.map((c) => typeof c === "string" ? escapeXml(c) : renderElement(c, indent + 1, options)).join("");
+    return `<${el.tag}${attrs}>${inner2}</${el.tag}>`;
+  }
+  const inner = el.children.map((c) => {
+    if (typeof c === "string") return `${pad(indent + 1)}${escapeXml(c)}
+`;
+    return renderElement(c, indent + 1, options);
+  }).join("");
+  return `${pad(indent)}<${el.tag}${attrs}>
+${inner}${pad(indent)}</${el.tag}>
+`;
+}
+function renderInline(el) {
+  const attrs = el.attrs ? buildAttrs(el.attrs) : "";
+  if (el.selfClosing || !el.children || el.children.length === 0) {
+    return `<${el.tag}${attrs} />`;
+  }
+  const inner = el.children.map((c) => typeof c === "string" ? escapeXml(c) : renderInline(c)).join("");
+  return `<${el.tag}${attrs}>${inner}</${el.tag}>`;
+}
+function isInlineElement(el) {
+  const inlineTags = /* @__PURE__ */ new Set([
+    "b",
+    "i",
+    "u",
+    "s",
+    "code",
+    "sub",
+    "sup",
+    "mark",
+    "strong",
+    "em",
+    "del",
+    "a",
+    "mention",
+    "tag",
+    "spoiler",
+    "ruby",
+    "math",
+    "footnote",
+    "comment"
+  ]);
+  return inlineTags.has(el.tag);
+}
+function pad(indent) {
+  return "  ".repeat(indent);
+}
+function serializeToXml(state, registry, options = {}) {
+  const root = state.root;
+  const children = root.children ?? [];
+  const ctx = createWriterContext(registry);
+  const content = children.flatMap((child) => ctx.serializeNode(child));
+  if (options.compact) {
+    return `<doc>${renderXml(content, 0, options)}</doc>`;
+  }
+  return `<doc>
+${renderXml(content, 1, options)}</doc>
+`;
+}
+function serializeNodesToXml(nodes, registry, options = {}) {
+  const ctx = createWriterContext(registry);
+  const content = nodes.flatMap((node) => ctx.serializeNode(node));
+  return renderXml(content, 0, options);
+}
+function createWriterContext(registry) {
+  const ctx = {
+    serializeChildren(children) {
+      return children.flatMap((child) => ctx.serializeNode(child));
+    },
+    serializeNode(node) {
+      const n = node;
+      if (n.type === "text") {
+        return wrapWithFormatTags(n.text ?? "", n.format ?? 0);
+      }
+      if (n.type === "linebreak") {
+        return { tag: "br", selfClosing: true };
+      }
+      const writer = registry.getWriter(n.type);
+      if (writer) {
+        const result = writer(node, ctx);
+        if (result !== false) return result;
+      }
+      return serializeFallback(node);
+    },
+    serializeNestedState(state) {
+      const root = state.root;
+      const children = root.children ?? [];
+      return children.flatMap((child) => ctx.serializeNode(child));
+    }
+  };
+  return ctx;
+}
+function serializeFallback(node) {
+  const n = node;
+  const blockId2 = n.$?.blockId;
+  const { type, $: _meta, version: _v, ...rest } = n;
+  const attrs = { type };
+  if (blockId2) attrs.id = blockId2;
+  const dataKeys = Object.keys(rest);
+  if (dataKeys.length > 0) {
+    attrs.data = JSON.stringify(rest);
+  }
+  return { tag: "node", attrs, selfClosing: true };
+}
+export {
+  LitexmlRegistry,
+  createDefaultRegistry,
+  deserializeFromXml,
+  deserializeNodesFromXml,
+  registerBuiltinReaders,
+  registerBuiltinWriters,
+  registerCustomReaders,
+  registerCustomWriters,
+  serializeNodesToXml,
+  serializeToXml
+};

package/dist/readers/builtin.d.ts

@@ -0,0 +1,3 @@
+import { LitexmlRegistry } from '../registry';
+export declare function registerBuiltinReaders(registry: LitexmlRegistry): void;
+//# sourceMappingURL=builtin.d.ts.map

package/dist/readers/builtin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin.d.ts","sourceRoot":"","sources":["../../src/readers/builtin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAgBnD,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI,CA+KtE"}

package/dist/readers/custom.d.ts

@@ -0,0 +1,3 @@
+import { LitexmlRegistry } from '../registry';
+export declare function registerCustomReaders(registry: LitexmlRegistry): void;
+//# sourceMappingURL=custom.d.ts.map

package/dist/readers/custom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom.d.ts","sourceRoot":"","sources":["../../src/readers/custom.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAYnD,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI,CAmUrE"}

package/dist/registry.d.ts

@@ -0,0 +1,10 @@
+import { XmlReaderFn, XmlWriterFn } from './types';
+export declare class LitexmlRegistry {
+    private writers;
+    private readers;
+    registerWriter(nodeType: string, writer: XmlWriterFn): void;
+    registerReader(tagName: string, reader: XmlReaderFn): void;
+    getWriter(nodeType: string): XmlWriterFn | undefined;
+    getReader(tagName: string): XmlReaderFn | undefined;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAExD,qBAAa,eAAe;IAC1B,OAAO,CAAC,OAAO,CAAkC;IACjD,OAAO,CAAC,OAAO,CAAkC;IAEjD,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI;IAI3D,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI;IAI1D,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAIpD,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;CAGpD"}

package/dist/serializer.d.ts

@@ -0,0 +1,7 @@
+import { SerializedEditorState, SerializedLexicalNode } from 'lexical';
+import { LitexmlRegistry } from './registry';
+import { XmlRenderOptions } from './xml-utils';
+export type XmlSerializerOptions = XmlRenderOptions;
+export declare function serializeToXml(state: SerializedEditorState, registry: LitexmlRegistry, options?: XmlSerializerOptions): string;
+export declare function serializeNodesToXml(nodes: SerializedLexicalNode[], registry: LitexmlRegistry, options?: XmlSerializerOptions): string;
+//# sourceMappingURL=serializer.d.ts.map

package/dist/serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../src/serializer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAE5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlD,OAAO,EAAa,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/D,MAAM,MAAM,oBAAoB,GAAG,gBAAgB,CAAC;AAEpD,wBAAgB,cAAc,CAC5B,KAAK,EAAE,qBAAqB,EAC5B,QAAQ,EAAE,eAAe,EACzB,OAAO,GAAE,oBAAyB,GACjC,MAAM,CAYR;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,qBAAqB,EAAE,EAC9B,QAAQ,EAAE,eAAe,EACzB,OAAO,GAAE,oBAAyB,GACjC,MAAM,CAIR"}

package/dist/text-format.d.ts

@@ -0,0 +1,21 @@
+import { XmlContent } from './types';
+/** Lexical text format bitmask values */
+export declare const FORMAT_BITS: {
+    readonly bold: 1;
+    readonly italic: 2;
+    readonly strikethrough: 4;
+    readonly underline: 8;
+    readonly code: 16;
+    readonly subscript: 32;
+    readonly superscript: 64;
+    readonly highlight: 128;
+};
+/** Reverse map: XML tag name → bit value (includes aliases) */
+export declare const FORMAT_TAG_TO_BIT: Record<string, number>;
+/** Wrap text content with nested format tags based on bitmask. */
+export declare function wrapWithFormatTags(text: string, format: number): XmlContent[];
+/** Check if a tag name is a known text format tag. */
+export declare function isFormatTag(tagName: string): boolean;
+/** Get the format bit for a tag name. Returns 0 if not a format tag. */
+export declare function getFormatBit(tagName: string): number;
+//# sourceMappingURL=text-format.d.ts.map

package/dist/text-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-format.d.ts","sourceRoot":"","sources":["../src/text-format.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,SAAS,CAAC;AAEtD,yCAAyC;AACzC,eAAO,MAAM,WAAW;;;;;;;;;CASd,CAAC;AAcX,+DAA+D;AAC/D,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAapD,CAAC;AAEF,kEAAkE;AAClE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,EAAE,CAa7E;AAED,sDAAsD;AACtD,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEpD"}

package/dist/types.d.ts

@@ -0,0 +1,37 @@
+import { SerializedEditorState, SerializedLexicalNode } from 'lexical';
+/** Structured XML element for serializer output */
+export interface XmlElement {
+    attrs?: Record<string, string>;
+    children?: XmlContent[];
+    selfClosing?: boolean;
+    tag: string;
+}
+/** XML content: either a structured element or raw text (will be escaped) */
+export type XmlContent = XmlElement | string;
+/** Context provided to writer functions */
+export interface WriterContext {
+    /** Serialize an array of child nodes into XML content */
+    serializeChildren: (children: SerializedLexicalNode[]) => XmlContent[];
+    /** Serialize a nested SerializedEditorState's root children into XmlContent[] (for container nodes like alert-quote, banner) */
+    serializeNestedState: (state: SerializedEditorState) => XmlContent[];
+    /** Serialize a single node into XML content */
+    serializeNode: (node: SerializedLexicalNode) => XmlContent | XmlContent[];
+}
+/** Context provided to reader functions */
+export interface ReaderContext {
+    /** Parse all child elements of a DOM element into serialized nodes */
+    parseChildren: (element: Element) => SerializedLexicalNode[];
+    /** Parse a nested XML string into SerializedEditorState (for container nodes) */
+    parseNestedState: (xml: string) => SerializedEditorState;
+}
+/**
+ * Writer: converts a SerializedLexicalNode to XML representation.
+ * Return `false` to indicate this writer does not handle the node.
+ */
+export type XmlWriterFn = (node: SerializedLexicalNode, ctx: WriterContext) => XmlContent | XmlContent[] | false;
+/**
+ * Reader: converts a DOM Element to SerializedLexicalNode(s).
+ * Return `false` to indicate this reader does not handle the element.
+ */
+export type XmlReaderFn = (element: Element, ctx: ReaderContext) => SerializedLexicalNode | SerializedLexicalNode[] | false;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAE5E,mDAAmD;AACnD,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,QAAQ,CAAC,EAAE,UAAU,EAAE,CAAC;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,6EAA6E;AAC7E,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,MAAM,CAAC;AAE7C,2CAA2C;AAC3C,MAAM,WAAW,aAAa;IAC5B,yDAAyD;IACzD,iBAAiB,EAAE,CAAC,QAAQ,EAAE,qBAAqB,EAAE,KAAK,UAAU,EAAE,CAAC;IACvE,gIAAgI;IAChI,oBAAoB,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,UAAU,EAAE,CAAC;IACrE,+CAA+C;IAC/C,aAAa,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,UAAU,GAAG,UAAU,EAAE,CAAC;CAC3E;AAED,2CAA2C;AAC3C,MAAM,WAAW,aAAa;IAC5B,sEAAsE;IACtE,aAAa,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,qBAAqB,EAAE,CAAC;IAC7D,iFAAiF;IACjF,gBAAgB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,qBAAqB,CAAC;CAC1D;AAED;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,CACxB,IAAI,EAAE,qBAAqB,EAC3B,GAAG,EAAE,aAAa,KACf,UAAU,GAAG,UAAU,EAAE,GAAG,KAAK,CAAC;AAEvC;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,CACxB,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,aAAa,KACf,qBAAqB,GAAG,qBAAqB,EAAE,GAAG,KAAK,CAAC"}

package/dist/writers/builtin.d.ts

@@ -0,0 +1,3 @@
+import { LitexmlRegistry } from '../registry';
+export declare function registerBuiltinWriters(registry: LitexmlRegistry): void;
+//# sourceMappingURL=builtin.d.ts.map

package/dist/writers/builtin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin.d.ts","sourceRoot":"","sources":["../../src/writers/builtin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAMnD,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI,CAkHtE"}

package/dist/writers/custom.d.ts

@@ -0,0 +1,3 @@
+import { LitexmlRegistry } from '../registry';
+export declare function registerCustomWriters(registry: LitexmlRegistry): void;
+//# sourceMappingURL=custom.d.ts.map

package/dist/writers/custom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom.d.ts","sourceRoot":"","sources":["../../src/writers/custom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAenD,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI,CAyNrE"}

package/dist/xml-utils.d.ts

@@ -0,0 +1,9 @@
+import { XmlContent } from './types';
+export interface XmlRenderOptions {
+    compact?: boolean;
+}
+export declare function escapeXml(text: string): string;
+export declare function buildAttrs(attrs: Record<string, string>): string;
+/** Render XmlContent tree to XML string. */
+export declare function renderXml(content: XmlContent[], indent?: number, options?: XmlRenderOptions): string;
+//# sourceMappingURL=xml-utils.d.ts.map

package/dist/xml-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xml-utils.d.ts","sourceRoot":"","sources":["../src/xml-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,SAAS,CAAC;AAEtD,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAUD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAKhE;AAED,4CAA4C;AAC5C,wBAAgB,SAAS,CACvB,OAAO,EAAE,UAAU,EAAE,EACrB,MAAM,GAAE,MAAU,EAClB,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CAUR"}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@haklex/rich-litexml",
+  "version": "0.0.94",
+  "description": "Bidirectional Lexical SerializedNode <-> XML conversion with plugin registry",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Innei/haklex.git",
+    "directory": "packages/rich-litexml"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "lexical": "^0.42.0",
+    "linkedom": "^0.18.9"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vite build",
+    "dev:build": "vite build --watch"
+  },
+  "types": "./dist/index.d.ts"
+}