nizel 0.1.13 → 0.1.15

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -19,27 +19,34 @@ const processor = useNizel({
19
19
  // optional configuration
20
20
  });
21
21
 
22
- const result = processor.process('# Hello {{ name }}', {
22
+ const result = await processor('# Hello {{ name }}', {
23
23
  data: { name: 'World' }
24
24
  });
25
25
  ```
26
26
 
27
27
  ## Result
28
28
 
29
- `process()` returns:
29
+ The processor returns:
30
30
 
31
- - `files` — output files (HTML by default)
32
- - `pages` — page metadata from frontmatter
33
- - `project` — project-level data
34
- - `languages` — language info
31
+ - `result`, `html`, `text`, and `ast`
32
+ - `meta` and `frontmatter`
33
+ - `title`, `description`, and `excerpt`
34
+ - `toc`, `headings`, `links`, and `images`
35
+ - `readingTime`
35
36
 
36
37
  ## Convenience Methods
37
38
 
38
39
  ```js
39
- processor.parse(markdown); // AST only, no rendering
40
- processor.render(markdown); // HTML string
40
+ await processor.parse(markdown); // AST only
41
+ processor.render(ast); // AST to HTML
42
+ processor.markdown(ast); // AST to Markdown
43
+ await processor.document(markdown); // portable document
41
44
  ```
42
45
 
46
+ Portable documents use the versioned `nizel/document` schema and can be passed
47
+ through `serializeNizelDocument()` and `deserializeNizelDocument()`. Use
48
+ `completeStreamingMarkdown()` before parsing incomplete streamed content.
49
+
43
50
  ## Features
44
51
 
45
52
  - **CommonMark 0.31** — full spec compliance (652/652 tests)
package/cli/nizel.mjs CHANGED
File without changes
@@ -21,15 +21,25 @@ var Nizel = (() => {
21
21
  // src/browser.ts
22
22
  var browser_exports = {};
23
23
  __export(browser_exports, {
24
+ NIZEL_DOCUMENT_SCHEMA: () => NIZEL_DOCUMENT_SCHEMA,
25
+ NIZEL_DOCUMENT_VERSION: () => NIZEL_DOCUMENT_VERSION,
26
+ assertNizelDocument: () => assertNizelDocument,
27
+ completeStreamingMarkdown: () => completeStreamingMarkdown,
28
+ createNizelDocument: () => createNizelDocument,
24
29
  defineBlock: () => defineBlock,
25
30
  defineNizelPlugin: () => defineNizelPlugin,
31
+ deserializeNizelDocument: () => deserializeNizelDocument,
26
32
  htmlToMarkdown: () => htmlToMarkdown2,
27
33
  markdownToHtml: () => markdownToHtml,
28
34
  mountMarkdown: () => mountMarkdown,
29
35
  nodeToMarkdown: () => nodeToMarkdown,
36
+ renderMarkdown: () => renderMarkdown,
37
+ renderNizelTree: () => renderNizelTree,
30
38
  selectionToMarkdown: () => selectionToMarkdown,
39
+ serializeNizelDocument: () => serializeNizelDocument,
31
40
  useBrowserNizel: () => useBrowserNizel,
32
- useNizel: () => useNizel
41
+ useNizel: () => useNizel,
42
+ visitNizel: () => visitNizel
33
43
  });
34
44
 
35
45
  // src/html-to-markdown.ts
@@ -4380,6 +4390,166 @@ ${body}
4380
4390
  ].includes(node.type);
4381
4391
  }
4382
4392
 
4393
+ // src/markdown.ts
4394
+ function renderMarkdown(value, options = {}) {
4395
+ const document2 = "schema" in value ? value : void 0;
4396
+ const body = renderBlocks((document2?.ast ?? value).children, options).trim();
4397
+ if (!document2 || options.frontmatter === false || Object.keys(document2.meta).length === 0) return body;
4398
+ return `---
4399
+ ${renderYaml(document2.meta)}
4400
+ ---${body ? `
4401
+
4402
+ ${body}` : ""}`;
4403
+ }
4404
+ function renderBlocks(nodes, options) {
4405
+ return nodes.map((node) => renderBlock2(node, options)).filter(Boolean).join("\n\n");
4406
+ }
4407
+ function renderBlock2(node, options) {
4408
+ if (node.type === "paragraph") return renderInline2(node.children);
4409
+ if (node.type === "heading") return `${"#".repeat(node.depth)} ${renderInline2(node.children)}`;
4410
+ if (node.type === "thematicBreak") return "---";
4411
+ if (node.type === "html") return node.value;
4412
+ if (node.type === "code") {
4413
+ const marker = options.fence ?? "`";
4414
+ const length = Math.max(3, longestRun2(node.code, marker) + 1);
4415
+ const fence = marker.repeat(length);
4416
+ const meta = node.meta === node.lang ? void 0 : node.meta;
4417
+ const info = [node.lang, meta].filter(Boolean).join(" ");
4418
+ return `${fence}${info}
4419
+ ${node.code.replace(/\n$/, "")}
4420
+ ${fence}`;
4421
+ }
4422
+ if (node.type === "blockquote") return prefixLines2(renderBlocks(node.children, options), "> ");
4423
+ if (node.type === "list") {
4424
+ return node.children.map((item, index) => renderListItem(item, node.ordered ? `${(node.start ?? 1) + index}.` : options.bullet ?? "-", options)).join("\n");
4425
+ }
4426
+ if (node.type === "table") return renderTable2(node.children, node.align);
4427
+ if (node.type === "customBlock") {
4428
+ const custom = options.customBlocks?.[node.name];
4429
+ if (custom) return custom(node, { render: (children2) => renderBlocks(children2, options) });
4430
+ const args = node.args?.length ? ` ${node.args.join(" ")}` : "";
4431
+ const props = node.props && Object.keys(node.props).length ? `
4432
+ ${renderYaml(node.props)}
4433
+ ::` : "";
4434
+ const children = node.children?.length ? `
4435
+ ${renderBlocks(node.children, options)}` : "";
4436
+ return `::${node.name}${args}${props}${children}
4437
+ ::`;
4438
+ }
4439
+ return "";
4440
+ }
4441
+ function renderInline2(nodes) {
4442
+ return nodes.map((node) => {
4443
+ if (node.type === "text") return escapeText(node.value);
4444
+ if (node.type === "lineBreak") return node.hard ? " \n" : "\n";
4445
+ if (node.type === "strong") return `**${renderInline2(node.children)}**`;
4446
+ if (node.type === "emphasis") return `*${renderInline2(node.children)}*`;
4447
+ if (node.type === "delete") return `~~${renderInline2(node.children)}~~`;
4448
+ if (node.type === "inlineCode") return renderCodeSpan(node.code);
4449
+ if (node.type === "link") return `[${renderInline2(node.children)}](${escapeDestination(node.href)}${node.title ? ` "${node.title.replaceAll('"', '\\"')}"` : ""})`;
4450
+ if (node.type === "image") return `![${escapeLabel(node.alt ?? "")}](${escapeDestination(node.src)}${node.title ? ` "${node.title.replaceAll('"', '\\"')}"` : ""})`;
4451
+ if (node.type === "inlineHtml") return node.value;
4452
+ return "";
4453
+ }).join("");
4454
+ }
4455
+ function renderListItem(item, marker, options) {
4456
+ const checkbox = item.checked === void 0 ? "" : `[${item.checked ? "x" : " "}] `;
4457
+ const body = renderBlocks(item.children, options);
4458
+ const lines = body.split("\n");
4459
+ return `${marker} ${checkbox}${lines[0] ?? ""}${lines.slice(1).map((line) => `
4460
+ ${" ".repeat(marker.length + 1)}${line}`).join("")}`;
4461
+ }
4462
+ function renderTable2(rows, align = []) {
4463
+ if (!rows.length) return "";
4464
+ const width = Math.max(...rows.map((row) => row.children.length));
4465
+ const line = (cells) => `| ${Array.from({ length: width }, (_, index) => escapeTable(renderInline2(cells[index]?.children ?? []))).join(" | ")} |`;
4466
+ const divider = `| ${Array.from({ length: width }, (_, index) => align[index] === "center" ? ":---:" : align[index] === "right" ? "---:" : align[index] === "left" ? ":---" : "---").join(" | ")} |`;
4467
+ return [line(rows[0].children), divider, ...rows.slice(1).map((row) => line(row.children))].join("\n");
4468
+ }
4469
+ function renderYaml(value) {
4470
+ return Object.entries(value).flatMap(([key, item]) => {
4471
+ if (Array.isArray(item)) return [`${key}:`, ...item.map((entry) => ` - ${yamlScalar(entry)}`)];
4472
+ return [`${key}: ${yamlScalar(item)}`];
4473
+ }).join("\n");
4474
+ }
4475
+ function yamlScalar(value) {
4476
+ if (value === null) return "null";
4477
+ if (typeof value === "boolean" || typeof value === "number") return String(value);
4478
+ const text = String(value);
4479
+ return text === "" || /^[-?:,[\]{}#&*!|>'"%@`]|[:#]\s|\s$|^(true|false|null|-?\d+(\.\d+)?)$/i.test(text) ? JSON.stringify(text) : text;
4480
+ }
4481
+ function renderCodeSpan(code) {
4482
+ const fence = "`".repeat(Math.max(1, longestRun2(code, "`") + 1));
4483
+ const padding = code.startsWith("`") || code.endsWith("`") ? " " : "";
4484
+ return `${fence}${padding}${code}${padding}${fence}`;
4485
+ }
4486
+ function longestRun2(value, character) {
4487
+ return Math.max(0, ...Array.from(value.matchAll(new RegExp(`\\${character}+`, "g")), (match) => match[0].length));
4488
+ }
4489
+ function prefixLines2(value, prefix) {
4490
+ return value.split("\n").map((line) => line ? `${prefix}${line}` : prefix.trimEnd()).join("\n");
4491
+ }
4492
+ function escapeText(value) {
4493
+ return value.replace(/([\\`*_[\]<>])/g, "\\$1");
4494
+ }
4495
+ function escapeLabel(value) {
4496
+ return value.replace(/([\\\]])/g, "\\$1");
4497
+ }
4498
+ function escapeDestination(value) {
4499
+ return value.replaceAll(" ", "%20").replaceAll(")", "%29");
4500
+ }
4501
+ function escapeTable(value) {
4502
+ return value.replaceAll("|", "\\|").replaceAll("\n", "<br>");
4503
+ }
4504
+
4505
+ // src/document.ts
4506
+ var NIZEL_DOCUMENT_SCHEMA = "nizel/document";
4507
+ var NIZEL_DOCUMENT_VERSION = 1;
4508
+ function createNizelDocument(value, meta) {
4509
+ const ast = isRoot(value) ? value : value.ast;
4510
+ const documentMeta = (isRoot(value) ? meta : value.meta) ?? {};
4511
+ assertJsonValue(ast, "ast");
4512
+ assertJsonValue(documentMeta, "meta");
4513
+ return { schema: NIZEL_DOCUMENT_SCHEMA, version: NIZEL_DOCUMENT_VERSION, ast, meta: documentMeta };
4514
+ }
4515
+ function serializeNizelDocument(document2, space) {
4516
+ assertNizelDocument(document2);
4517
+ return JSON.stringify(document2, void 0, space);
4518
+ }
4519
+ function deserializeNizelDocument(source) {
4520
+ let value;
4521
+ try {
4522
+ value = JSON.parse(source);
4523
+ } catch (error) {
4524
+ throw new TypeError(`Invalid Nizel document JSON: ${error instanceof Error ? error.message : String(error)}`);
4525
+ }
4526
+ assertNizelDocument(value);
4527
+ return value;
4528
+ }
4529
+ function assertNizelDocument(value) {
4530
+ if (!value || typeof value !== "object") throw new TypeError("Nizel document must be an object.");
4531
+ const candidate = value;
4532
+ if (candidate.schema !== NIZEL_DOCUMENT_SCHEMA) throw new TypeError("Unsupported Nizel document schema.");
4533
+ if (candidate.version !== NIZEL_DOCUMENT_VERSION) throw new TypeError(`Unsupported Nizel document version: ${String(candidate.version)}.`);
4534
+ if (!isRoot(candidate.ast)) throw new TypeError("Nizel document ast must be a root node.");
4535
+ if (!candidate.meta || typeof candidate.meta !== "object" || Array.isArray(candidate.meta)) {
4536
+ throw new TypeError("Nizel document meta must be an object.");
4537
+ }
4538
+ assertJsonValue(candidate, "document");
4539
+ }
4540
+ function isRoot(value) {
4541
+ return Boolean(value && typeof value === "object" && value.type === "root" && Array.isArray(value.children));
4542
+ }
4543
+ function assertJsonValue(value, path, seen = /* @__PURE__ */ new Set()) {
4544
+ if (value === null || typeof value === "string" || typeof value === "boolean") return;
4545
+ if (typeof value === "number" && Number.isFinite(value)) return;
4546
+ if (typeof value !== "object") throw new TypeError(`Nizel ${path} is not JSON-serializable.`);
4547
+ if (seen.has(value)) throw new TypeError(`Nizel ${path} contains a circular reference.`);
4548
+ seen.add(value);
4549
+ for (const [key, child] of Object.entries(value)) assertJsonValue(child, `${path}.${key}`, seen);
4550
+ seen.delete(value);
4551
+ }
4552
+
4383
4553
  // src/template.ts
4384
4554
  var renderTemplate = (markdown, data, options) => {
4385
4555
  const filters = options.filters ?? {};
@@ -4515,6 +4685,11 @@ ${body}
4515
4685
  unwrapStandaloneImages: resolved.unwrapStandaloneImages === true
4516
4686
  });
4517
4687
  };
4688
+ nizel.markdown = (value, markdownOptions) => renderMarkdown(value, markdownOptions);
4689
+ nizel.document = async (markdown, runtimeOptions) => {
4690
+ const result = await process(markdown, runtimeOptions);
4691
+ return createNizelDocument(result);
4692
+ };
4518
4693
  return nizel;
4519
4694
  function prepareMarkdown(markdown, runtimeOptions = {}) {
4520
4695
  const preparedMeta = prepareMeta(markdown, runtimeOptions);
@@ -4693,6 +4868,137 @@ ${body}
4693
4868
  return block;
4694
4869
  };
4695
4870
 
4871
+ // src/streaming.ts
4872
+ function completeStreamingMarkdown(source, options = {}) {
4873
+ if (!source) return source;
4874
+ let completed = source;
4875
+ if (options.frontmatter !== false && completed.startsWith("---\n") && !/^---\n[\s\S]*?\n---(?:\n|$)/.test(completed)) {
4876
+ return `${completed.replace(/\n*$/, "")}
4877
+ ---`;
4878
+ }
4879
+ const openFence = findOpenCodeFence(completed);
4880
+ if (openFence) return `${completed.replace(/\n*$/, "")}
4881
+ ${openFence}`;
4882
+ if (options.customBlocks !== false) {
4883
+ const customClosers = openCustomBlockClosers(completed);
4884
+ if (customClosers.length) completed = `${completed.replace(/\n*$/, "")}
4885
+ ${customClosers.join("\n")}`;
4886
+ }
4887
+ completed += inlineClosers(completed);
4888
+ return completed;
4889
+ }
4890
+ function findOpenCodeFence(source) {
4891
+ let open;
4892
+ for (const line of source.split("\n")) {
4893
+ const match = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
4894
+ if (!match) continue;
4895
+ const marker = match[1][0];
4896
+ if (!open) open = { marker, length: match[1].length };
4897
+ else if (marker === open.marker && match[1].length >= open.length && match[2].trim() === "") open = void 0;
4898
+ }
4899
+ return open?.marker.repeat(open.length);
4900
+ }
4901
+ function openCustomBlockClosers(source) {
4902
+ const stack = [];
4903
+ for (const line of source.split("\n")) {
4904
+ const match = /^(:{2,})(?:([A-Za-z][\w-]*)(?:\s|\{|$))?/.exec(line.trim());
4905
+ if (!match) continue;
4906
+ if (match[2]) stack.push(match[1]);
4907
+ else if (stack.length && match[1].length >= stack.at(-1).length) stack.pop();
4908
+ }
4909
+ return stack.reverse();
4910
+ }
4911
+ function inlineClosers(source) {
4912
+ const lastLine = source.split("\n").at(-1) ?? "";
4913
+ if (/^ {0,3}(?:#{1,6}|>|[-+*]\s|\d+\.\s)/.test(lastLine)) return "";
4914
+ const escaped = (index) => index > 0 && lastLine[index - 1] === "\\";
4915
+ let ticks = 0;
4916
+ let strong = 0;
4917
+ let strike = 0;
4918
+ for (let index = 0; index < lastLine.length; index += 1) {
4919
+ if (escaped(index)) continue;
4920
+ if (lastLine[index] === "`") ticks ^= 1;
4921
+ if (!ticks && lastLine.slice(index, index + 2) === "**") {
4922
+ strong ^= 1;
4923
+ index += 1;
4924
+ } else if (!ticks && lastLine.slice(index, index + 2) === "~~") {
4925
+ strike ^= 1;
4926
+ index += 1;
4927
+ }
4928
+ }
4929
+ const link = !ticks && /!?\[[^\]]*\]\([^)]*$/.test(lastLine);
4930
+ return `${link ? ")" : ""}${strike ? "~~" : ""}${strong ? "**" : ""}${ticks ? "`" : ""}`;
4931
+ }
4932
+
4933
+ // src/visit.ts
4934
+ function visitNizel(node, visitor) {
4935
+ let stopped = false;
4936
+ const walk = (current, parent) => {
4937
+ if (stopped) return;
4938
+ const control = visitor(current, parent);
4939
+ if (control === "stop") {
4940
+ stopped = true;
4941
+ return;
4942
+ }
4943
+ if (control === "skip") return;
4944
+ const children = "children" in current && Array.isArray(current.children) ? current.children : [];
4945
+ for (const child of children) walk(child, current);
4946
+ };
4947
+ walk(node);
4948
+ }
4949
+
4950
+ // src/renderer.ts
4951
+ function renderNizelTree(value, options) {
4952
+ const root = "schema" in value ? value.ast : value;
4953
+ const lastText = options.streaming && options.caret ? findLastText(root) : void 0;
4954
+ const render = (node) => {
4955
+ if (node.type === "text") {
4956
+ const output = options.adapter.text(node.value, node);
4957
+ if (node !== lastText || !options.adapter.caret) return output;
4958
+ return options.adapter.element("fragment", {}, [output, options.adapter.caret(caretProps(options.caret))], node);
4959
+ }
4960
+ const descriptor = describeNode(node);
4961
+ const name = options.components?.[descriptor.name] ?? descriptor.name;
4962
+ const children = descriptor.children.map(render);
4963
+ return options.adapter.element(name, descriptor.props, children, node);
4964
+ };
4965
+ return render(root);
4966
+ }
4967
+ function describeNode(node) {
4968
+ if (node.type === "root") return { name: "root", props: {}, children: node.children };
4969
+ if (node.type === "paragraph") return { name: "p", props: {}, children: node.children };
4970
+ if (node.type === "heading") return { name: `h${node.depth}`, props: { id: node.id }, children: node.children };
4971
+ if (node.type === "emphasis") return { name: "em", props: {}, children: node.children };
4972
+ if (node.type === "strong") return { name: "strong", props: {}, children: node.children };
4973
+ if (node.type === "delete") return { name: "del", props: {}, children: node.children };
4974
+ if (node.type === "lineBreak") return { name: "br", props: { hard: node.hard }, children: [] };
4975
+ if (node.type === "inlineCode") return { name: "code", props: { inline: true, code: node.code }, children: [] };
4976
+ if (node.type === "code") return { name: "pre", props: { code: node.code, language: node.lang, meta: node.meta, filename: node.filename, highlightLines: node.highlightLines }, children: [] };
4977
+ if (node.type === "link") return { name: "a", props: { href: node.href, title: node.title, external: node.external }, children: node.children };
4978
+ if (node.type === "image") return { name: "img", props: { src: node.src, alt: node.alt, title: node.title }, children: [] };
4979
+ if (node.type === "inlineHtml" || node.type === "html") return { name: "rawHtml", props: { value: node.value }, children: [] };
4980
+ if (node.type === "list") return { name: node.ordered ? "ol" : "ul", props: { start: node.start, tight: node.tight }, children: node.children };
4981
+ if (node.type === "listItem") return { name: "li", props: { checked: node.checked }, children: node.children };
4982
+ if (node.type === "blockquote") return { name: "blockquote", props: {}, children: node.children };
4983
+ if (node.type === "thematicBreak") return { name: "hr", props: {}, children: [] };
4984
+ if (node.type === "table") return { name: "table", props: { align: node.align }, children: node.children };
4985
+ if (node.type === "tableRow") return { name: "tr", props: {}, children: node.children };
4986
+ if (node.type === "tableCell") return { name: "td", props: {}, children: node.children };
4987
+ return { name: node.name, props: { args: node.args, ...node.props, value: node.value }, children: node.children ?? [] };
4988
+ }
4989
+ function findLastText(root) {
4990
+ let found;
4991
+ const walk = (node) => {
4992
+ if (node.type === "text") found = node;
4993
+ if ("children" in node && Array.isArray(node.children)) node.children.forEach((child) => walk(child));
4994
+ };
4995
+ walk(root);
4996
+ return found;
4997
+ }
4998
+ function caretProps(value) {
4999
+ return value && typeof value === "object" ? value : {};
5000
+ }
5001
+
4696
5002
  // src/browser.ts
4697
5003
  function useBrowserNizel(options = {}) {
4698
5004
  const processor = useNizel(options);