@podlite/markdown 0.0.26 → 0.0.28

package/lib/index.esm.js

@@ -1716,9 +1716,9 @@ var require_iterate = __commonJS({
       }
     }
     function checkKeywordTypes(it, ts) {
-      const rules2 = it.self.RULES.all;
-      for (const keyword in rules2) {
-        const rule = rules2[keyword];
+      const rules3 = it.self.RULES.all;
+      for (const keyword in rules3) {
+        const rule = rules3[keyword];
         if (typeof rule == "object" && applicability_1.shouldUseRule(it.schema, rule)) {
           const { type } = rule.definition;
           if (type.length && !type.some((t) => hasApplicableType(ts, t))) {
@@ -3248,18 +3248,18 @@ var require_util = __commonJS({
         return;
       if (typeof schema === "boolean")
         return;
-      const rules2 = self.RULES.keywords;
+      const rules3 = self.RULES.keywords;
       for (const key in schema) {
-        if (!rules2[key])
+        if (!rules3[key])
           validate_1.checkStrictMode(it, `unknown keyword: "${key}"`);
       }
     }
     exports.checkUnknownRules = checkUnknownRules;
-    function schemaHasRules(schema, rules2) {
+    function schemaHasRules(schema, rules3) {
       if (typeof schema == "boolean")
         return !schema;
       for (const key in schema)
-        if (rules2[key])
+        if (rules3[key])
           return true;
       return false;
     }
@@ -4405,15 +4405,15 @@ var require_core = __commonJS({
         return errors.map((e) => `${dataVar}${e.dataPath} ${e.message}`).reduce((text4, msg) => text4 + separator + msg);
       }
       $dataMetaSchema(metaSchema, keywordsJsonPointers) {
-        const rules2 = this.RULES.all;
+        const rules3 = this.RULES.all;
         metaSchema = JSON.parse(JSON.stringify(metaSchema));
         for (const jsonPointer of keywordsJsonPointers) {
           const segments = jsonPointer.split("/").slice(1);
           let keywords = metaSchema;
           for (const seg of segments)
             keywords = keywords[seg];
-          for (const key in rules2) {
-            const rule = rules2[key];
+          for (const key in rules3) {
+            const rule = rules3[key];
             if (typeof rule != "object")
               continue;
             const { $data } = rule.definition;
@@ -8295,6 +8295,9 @@ var require_AstTree = __commonJS({
                 "number"
               ]
             },
+            checked: {
+              type: "boolean"
+            },
             type: {
               type: "string",
               enum: [
@@ -9297,6 +9300,15 @@ var require_AstTree = __commonJS({
             title: {
               type: "string"
             },
+            foldedLevels: {
+              type: "object",
+              additionalProperties: false,
+              patternProperties: {
+                "^[0-9]+$": {
+                  type: "boolean"
+                }
+              }
+            },
             content: {
               $ref: "#/definitions/TocList"
             }
@@ -11057,6 +11069,9 @@ var require_PodliteDocument = __commonJS({
                 "number"
               ]
             },
+            checked: {
+              type: "boolean"
+            },
             type: {
               type: "string",
               enum: [
@@ -12059,6 +12074,15 @@ var require_PodliteDocument = __commonJS({
             title: {
               type: "string"
             },
+            foldedLevels: {
+              type: "object",
+              additionalProperties: false,
+              patternProperties: {
+                "^[0-9]+$": {
+                  type: "boolean"
+                }
+              }
+            },
             content: {
               $ref: "#/definitions/TocList"
             }
@@ -12778,7 +12802,7 @@ var require_grammar = __commonJS({
           config,
           location: location()
         };
-      }, peg$c125 = /^[+-=_|]/, peg$c126 = peg$classExpectation([["+", "="], "_", "|"], false, false), peg$c127 = function() {
+      }, peg$c125 = /^[\-+=_|]/, peg$c126 = peg$classExpectation(["-", "+", "=", "_", "|"], false, false), peg$c127 = function() {
         return { type: "separator", text: text4() };
       }, peg$c128 = function() {
         return options.isDelimited;
@@ -25081,9 +25105,18 @@ var require_package = __commonJS({
   "../podlite-schema/package.json"(exports, module) {
     module.exports = {
       name: "@podlite/schema",
-      version: "0.0.33",
-      description: "AST tools for Podlite markup language",
+      version: "0.0.35",
+      description: "AST tools and schema for Podlite markup language \u2014 validate, traverse, and transform document trees",
       main: "./src/index.ts",
+      homepage: "https://podlite.org",
+      bugs: {
+        url: "https://github.com/podlite/podlite/issues"
+      },
+      repository: {
+        type: "git",
+        url: "https://github.com/podlite/podlite.git",
+        directory: "packages/podlite-schema"
+      },
       license: "MIT",
       funding: {
         type: "opencollective",
@@ -25112,16 +25145,22 @@ var require_package = __commonJS({
         build: "run-s build:pegjs build_lib build:ast ",
         build_lib: "yarn g:build",
         "build:ast": "ts-node scripts/make-ast-scheme.ts",
-        "build:pegjs": "pegjs -o src/grammar.js src/grammar.pegjs && pegjs -o src/grammarfc.js src/grammarfc.pegjs",
+        "build:pegjs": "pegmill -o src/grammar.js src/grammar.pegjs && pegmill -o src/grammarfc.js src/grammarfc.pegjs",
         watch: "npx nodemon -e js,ts --exec 'yarn' build",
-        "watch:pegjs": "npx nodemon -e pegjs --exec 'yarn' build:pegjs",
+        "watch:pegjs": "npx nodemon -e pegmill --exec 'yarn' build:pegjs",
         test: "yarn g:jest  --passWithNoTests"
       },
       keywords: [
-        "markdown",
         "podlite",
-        "markup",
-        "markup-language"
+        "schema",
+        "ast",
+        "syntax-tree",
+        "markup-language",
+        "transform",
+        "visitor",
+        "parser",
+        "markdown",
+        "tree"
       ],
       dependencies: {
         ajv: "^7.2.3",
@@ -25134,7 +25173,7 @@ var require_package = __commonJS({
         "@types/node": "^17.0.7",
         glob: "^7.2.0",
         "npm-run-all": "^4.1.5",
-        pegjs: "^0.10.0",
+        pegmill: "0.1.0",
         "ts-node": "^9.1.1",
         typescript: "4.5.5",
         "typescript-json-schema": "0.53.0"
@@ -25342,13 +25381,13 @@ var makeRulesArray = (key, fn) => {
     }, []);
   }
   if (key instanceof Object) {
-    let rules2 = [];
+    let rules3 = [];
     for (var prop in key) {
       if (key.hasOwnProperty(prop)) {
-        rules2.push(makeRule(makePlug(prop), key[prop]));
+        rules3.push(makeRule(makePlug(prop), key[prop]));
       }
     }
-    return rules2;
+    return rules3;
   }
   return [makeRule(makePlug(key), fn)];
 };
@@ -25490,7 +25529,7 @@ function flattenDeep(arr) {
   }
   return arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(flattenDeep(val)) : acc.concat(val), []);
 }
-function thisFunc(rules2) {
+function thisFunc(rules3) {
   function interator(node, context) {
     if (node == null) {
       return node;
@@ -25501,7 +25540,7 @@ function thisFunc(rules2) {
     if ("string" === typeof node) {
       return interator({ type: "text", value: node }, context);
     }
-    const reversed = rules2.slice();
+    const reversed = rules3.slice();
     reversed.reverse();
     const ruleIndex = reversed.findIndex((rule) => rule.isFor(node));
     if (ruleIndex !== -1) {
@@ -25526,7 +25565,7 @@ function thisFunc(rules2) {
       }
     }
   }
-  interator.rules = rules2;
+  interator.rules = rules3;
   return interator;
 }
 var makeInterator_default = thisFunc;
@@ -25550,8 +25589,8 @@ var setFn = (check) => (writer, processor) => {
     return check(node, ctx)(writer, processor)(node, ctx, interator);
   };
 };
-var subUse = (rules2, processNode) => {
-  const newFns = makeRulesArray(rules2).reverse();
+var subUse = (rules3, processNode) => {
+  const newFns = makeRulesArray(rules3).reverse();
   return (writer, processor) => {
     const inited = newFns.map((item) => makeRule(item.rule, item.fn(writer, processor))).reverse();
     const processNodeInited = processNode(writer, processor);
@@ -25587,7 +25626,7 @@ function flattenDeep2(arr) {
   return arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(flattenDeep2(val)) : acc.concat(val), []);
 }
 var makeTransformer = (rule) => {
-  let rules2 = [];
+  let rules3 = [];
   function use(key, fn) {
     if (key instanceof Array) {
       console.warn(`[podlite] Unsupported param for ${key}`);
@@ -25600,7 +25639,7 @@ var makeTransformer = (rule) => {
       }
       return [];
     }
-    rules2.push(makeRule(makePlug(key), fn));
+    rules3.push(makeRule(makePlug(key), fn));
   }
   function visiter(node, context = {}) {
     if (node == null) {
@@ -25612,7 +25651,7 @@ var makeTransformer = (rule) => {
     if ("string" === typeof node) {
       return node;
     }
-    const reversed = rules2.slice();
+    const reversed = rules3.slice();
     reversed.reverse();
     const ruleIndex = reversed.findIndex((rule2) => rule2.isFor(node));
     if (ruleIndex !== -1) {
@@ -25626,7 +25665,7 @@ var makeTransformer = (rule) => {
     }
   }
   use(rule);
-  visiter.rules = rules2;
+  visiter.rules = rules3;
   return visiter;
 };
 var makeTransformer_default = makeTransformer;
@@ -25769,6 +25808,303 @@ var pluginCleanLocation = () => (tree) => {
 };
 var plugin_clean_location_default = pluginCleanLocation;
 
+// ../podlite-schema/src/exportMarkdown.ts
+var rules = {
+  ":text": (writer, processor) => (node, ctx, interator) => {
+    if (node.value) {
+      writer.write(node.value);
+    } else {
+      interator(node.content, ctx);
+    }
+  },
+  "A<>": (writer, processor) => (node, ctx, interator) => {
+    if (!(ctx.alias && ctx.alias.hasOwnProperty(node.content))) {
+      writer.writeRaw(`A<${node.content}>`);
+    } else {
+      const src = ctx.alias[node.content].join("\n");
+      const tree_1 = processor(src);
+      const tree = plugin_clean_location_default()(tree_1);
+      if (tree[0].type === "para") {
+        interator(tree[0].content, ctx);
+      } else {
+        interator(tree, ctx);
+      }
+    }
+  },
+  "C<>": wrapContent("`", "`"),
+  "D<>": (writer, processor) => (node, ctx, interator) => {
+    if (!writer.hasOwnProperty("DEFINITIONS")) {
+      writer.DEFINITIONS = [];
+    }
+    writer.DEFINITIONS.push({ definition: [node.content[0]] });
+    writer.writeRaw("**");
+    interator(node.content, ctx);
+    writer.writeRaw("**");
+  },
+  "B<>": wrapContent("**", "**"),
+  "I<>": wrapContent("*", "*"),
+  "R<>": wrapContent("*", "*"),
+  "K<>": wrapContent("`", "`"),
+  "L<>": setFn((node, ctx) => {
+    let { meta } = node;
+    if (meta === null) {
+      meta = node.content;
+    }
+    return wrapContent(`[`, `](${meta})`);
+  }),
+  "N<>": (writer, processor) => {
+    writer.addListener("end", () => {
+      if (!writer.hasOwnProperty("FOOTNOTES")) {
+        return;
+      }
+      const footnotes = writer.FOOTNOTES;
+      if (footnotes.length < 1) {
+        return;
+      }
+      writer.writeRaw("\n\n---\n\n");
+      footnotes.map((footnote) => {
+        writer.writeRaw(`[^${footnote.gid}]: `);
+        footnote.make();
+        writer.writeRaw("\n");
+      });
+    });
+    return (node, ctx, interator) => {
+      if (node.content.length < 1) {
+        return;
+      }
+      if (!writer.hasOwnProperty("gid")) {
+        writer.gid = 1;
+      }
+      const gid = writer.gid++;
+      writer.writeRaw(`[^${gid}]`);
+      if (!writer.hasOwnProperty("FOOTNOTES")) {
+        writer.FOOTNOTES = [];
+      }
+      writer.FOOTNOTES.push({
+        gid,
+        fnRefId: `fnref:${gid}`,
+        fnId: `fn:${gid}`,
+        make: () => {
+          interator(node.content, ctx);
+        }
+      });
+    };
+  },
+  "S<>": (writer, processor) => (node, ctx, interator) => {
+    const content4 = node.content || "";
+    writer.writeRaw(content4.replace(/ /g, "&nbsp;").replace(/\n/g, "  \n"));
+  },
+  "T<>": wrapContent("`", "`"),
+  "U<>": wrapContent("", ""),
+  "V<>": content,
+  "X<>": (writer, processor) => (node, ctx, interator) => {
+    interator(node.content, ctx);
+    let { entry } = node;
+    if (entry === null && node.content.length > 0) {
+      entry = [node.content[0]];
+    } else {
+      return;
+    }
+    if (!writer.hasOwnProperty("INDEXTERMS")) {
+      writer.INDEXTERMS = [];
+    }
+    writer.INDEXTERMS.push({ entry });
+  },
+  "Z<>": emptyContent,
+  pod: content,
+  ":code": (writer, processor) => (node, ctx, interator) => {
+    const conf = config_default(node, ctx);
+    const lang = conf.exists("lang") ? conf.getFirstValue("lang") : "";
+    writer.writeRaw("```" + lang + "\n");
+    if (node.content) {
+      node.content.forEach((child) => {
+        if (typeof child === "string") {
+          writer.writeRaw(child);
+        } else if (child.type === "verbatim") {
+          writer.writeRaw(child.value);
+        } else {
+          interator([child], ctx);
+        }
+      });
+    }
+    writer.writeRaw("```\n");
+  },
+  code: handleNested((writer, processor) => (node, ctx, interator) => {
+    const conf = config_default(node, ctx);
+    const lang = conf.exists("lang") ? conf.getFirstValue("lang") : "";
+    writer.writeRaw("```" + lang + "\n");
+    if (node.content) {
+      node.content.forEach((child) => {
+        if (typeof child === "string") {
+          writer.writeRaw(child);
+        } else if (child.type === "verbatim") {
+          writer.writeRaw(child.value);
+        } else {
+          interator([child], ctx);
+        }
+      });
+    }
+    writer.writeRaw("```\n");
+  }),
+  data: emptyContent,
+  ":verbatim": (writer, processor) => (node, ctx, interator) => {
+    if (node.error) {
+      writer.emit("errors", node.location);
+    }
+    writer.writeRaw(node.value);
+  },
+  ":blankline": emptyContent,
+  ":ambient": emptyContent,
+  ":config": setFn((node, ctx) => {
+    if (!ctx.hasOwnProperty("config"))
+      ctx.config = {};
+    ctx.config[node.name] = node.config;
+    return emptyContent;
+  }),
+  ":alias": setFn((node, ctx) => {
+    if (!ctx.hasOwnProperty("alias"))
+      ctx.alias = {};
+    ctx.alias[node.name] = node.replacement;
+    return emptyContent;
+  }),
+  para: handleNested(content),
+  ":para": (writer, processor) => (node, ctx, interator) => {
+    if (node.content)
+      interator(node.content, ctx);
+    writer.writeRaw("\n");
+  },
+  "head:block": subUse(
+    {
+      ":para": content
+    },
+    setFn((node, ctx) => {
+      const { level } = node;
+      const prefix = "#".repeat(level) + " ";
+      return (writer, processor) => (node2, ctx2, interator) => {
+        writer.writeRaw(prefix);
+        if (node2.content)
+          interator(node2.content, ctx2);
+        writer.writeRaw("\n");
+      };
+    })
+  ),
+  ":list": setFn((node, ctx) => {
+    return (writer, processor) => (node2, ctx2, interator) => {
+      const newCtx = {
+        ...ctx2,
+        listType: node2.list,
+        listCounter: { value: 1 },
+        listDepth: (ctx2.listDepth || 0) + 1
+      };
+      if (node2.content)
+        interator(node2.content, newCtx);
+    };
+  }),
+  "item:block": (writer, processor) => (node, ctx, interator) => {
+    const indent2 = "  ".repeat(Math.max(0, (ctx.listDepth || 1) - 1));
+    const listType = ctx.listType || "unordered";
+    let prefix;
+    if (listType === "ordered") {
+      const counter = ctx.listCounter || { value: 1 };
+      prefix = `${counter.value}. `;
+      counter.value++;
+    } else if (listType === "variable") {
+      prefix = "- ";
+    } else {
+      prefix = "- ";
+    }
+    writer.writeRaw(indent2 + prefix);
+    if (node.content)
+      interator(node.content, ctx);
+  },
+  "comment:block": emptyContent,
+  defn: (writer, processor) => (node, ctx, interator) => {
+    if (node.content)
+      interator(node.content, ctx);
+    writer.writeRaw("\n");
+  },
+  "term:para": (writer, processor) => (node, ctx, interator) => {
+    writer.writeRaw("**");
+    if (node.content)
+      interator(node.content, ctx);
+    writer.writeRaw(":** ");
+  },
+  nested: handleNested(content, 1),
+  output: handleNested(
+    (writer, processor) => (node, ctx, interator) => {
+      writer.writeRaw("```\n");
+      if (node.content)
+        interator(node.content, ctx);
+      writer.writeRaw("```\n");
+    },
+    1
+  ),
+  input: handleNested(
+    (writer, processor) => (node, ctx, interator) => {
+      writer.writeRaw("```\n");
+      if (node.content)
+        interator(node.content, ctx);
+      writer.writeRaw("```\n");
+    },
+    1
+  ),
+  "table:block": handleNested((writer, processor) => (node, ctx, interator) => {
+    const conf = config_default(node, ctx);
+    if (conf.exists("caption")) {
+      writer.writeRaw("**");
+      writer.write(conf.getFirstValue("caption"));
+      writer.writeRaw("**\n\n");
+    }
+    const rows = (node.content || []).filter((child) => child.name === "table_row" || child.name === "table_head");
+    if (rows.length === 0)
+      return;
+    const hasHeader = rows[0].name === "table_head";
+    rows.forEach((row, rowIndex) => {
+      const cells = (row.content || []).filter((c) => c.name === "table_cell");
+      writer.writeRaw("|");
+      cells.forEach((cell) => {
+        writer.writeRaw(" ");
+        if (cell.content) {
+          cell.content.forEach((c) => {
+            if (typeof c === "string") {
+              writer.write(c.trim());
+            } else {
+              interator([c], ctx);
+            }
+          });
+        }
+        writer.writeRaw(" |");
+      });
+      writer.writeRaw("\n");
+      if (rowIndex === 0 && hasHeader) {
+        writer.writeRaw("|");
+        cells.forEach(() => {
+          writer.writeRaw(" --- |");
+        });
+        writer.writeRaw("\n");
+      }
+      if (rowIndex === 0 && !hasHeader) {
+        writer.writeRaw("|");
+        cells.forEach(() => {
+          writer.writeRaw(" --- |");
+        });
+        writer.writeRaw("\n");
+      }
+    });
+    writer.writeRaw("\n");
+  }),
+  ":separator": emptyContent,
+  table_row: emptyContent,
+  table_cell: emptyContent,
+  table_head: emptyContent,
+  ":toc": emptyContent,
+  ":toc-list": emptyContent,
+  ":toc-item": emptyContent,
+  ":image": (writer, processor) => (node, ctx, interator) => {
+    writer.writeRaw(`![${node.alt || ""}](${node.src})`);
+  }
+};
+
 // ../podlite-schema/src/helpers/ids.ts
 var import_slugify = __toESM(require_slugify());
 
@@ -25869,9 +26205,30 @@ var plugin_items_default = () => (tree) => {
         if (matchItem) {
           node.name = "item";
           node.level = matchItem[1] || 1;
+          const checkedConfig = (node.config || []).find((c) => c.name === "checked");
+          if (checkedConfig) {
+            node.checked = checkedConfig.value !== false && checkedConfig.value !== 0 && checkedConfig.value !== "0";
+          }
           if (node.content[0]) {
             const startText = node.content[0];
             if (startText.text) {
+              if (!checkedConfig) {
+                const checkboxRe = /^\[( |x)\]\s*/;
+                const checkboxMatch = checkboxRe.exec(startText.text);
+                if (checkboxMatch) {
+                  node.checked = checkboxMatch[1] === "x";
+                  startText.text = startText.text.replace(checkboxRe, "");
+                  if (startText.type === "para") {
+                    startText.content = [startText.text];
+                  }
+                  node.config = node.config || [];
+                  node.config.push({
+                    name: "checked",
+                    value: node.checked,
+                    type: "boolean"
+                  });
+                }
+              }
               let re = /^(\s*#\s*)/;
               const match = re.exec(startText.text);
               if (match) {
@@ -25984,8 +26341,9 @@ var plugin_group_defn_default = () => (tree) => {
 
 // ../podlite-schema/src/plugin-group-items.ts
 var plugin_group_items_default = () => (tree) => {
-  const isNodesEqual = (n1, n2) => (n1.name === "item" || n1.name === "defn") && n2.name === n1.name && n1["level"] === n2.level && isNumbered(n1) === isNumbered(n2);
+  const isNodesEqual = (n1, n2) => (n1.name === "item" || n1.name === "defn") && n2.name === n1.name && n1["level"] === n2.level && isNumbered(n1) === isNumbered(n2) && isChecked(n1) === isChecked(n2);
   const isNumbered = (node) => Boolean(config_default(node, {}).exists("numbered"));
+  const isChecked = (node) => node.checked !== void 0;
   const group = (a, level = 1) => {
     const isInListMode = (a2) => {
       return a2.length > 0 && a2[a2.length - 1].type === "list";
@@ -26000,12 +26358,12 @@ var plugin_group_items_default = () => (tree) => {
       if (i.name === "item" && i.type === "block" && i.level < level) {
         return [...a2, i];
       }
-      if (i.name === "item" && i.type === "block" && (!isInListMode(a2) || i.level === level && getList(a2).list !== (isNumbered(i) ? "ordered" : "itemized"))) {
+      if (i.name === "item" && i.type === "block" && (!isInListMode(a2) || Number(i.level) === level && getList(a2).list !== (isNumbered(i) ? "ordered" : isChecked(i) ? "task" : "itemized"))) {
         a2.push({
           type: "list",
           level: i.level,
           content: [],
-          list: isNumbered(i) ? "ordered" : "itemized"
+          list: isNumbered(i) ? "ordered" : isChecked(i) ? "task" : "itemized"
         });
       }
       if (isInListMode(a2) && isInsertableToList(getList(a2), i)) {
@@ -26017,7 +26375,7 @@ var plugin_group_items_default = () => (tree) => {
     }, []);
     return result.map((item) => {
       if (item.content && item.type !== "fcode") {
-        item.content = group(item.content, item.level + 1);
+        item.content = group(item.content, Number(item.level || 0) + 1);
       }
       return item;
     });
@@ -26195,7 +26553,7 @@ var plugin_tables_default = () => (tree) => {
 };
 
 // ../podlite-schema/src/exportHtml.ts
-var rules = {
+var rules2 = {
   ":text": (writer, processor) => (node, ctx, interator) => {
     if (node.value) {
       writer.write(node.value);
@@ -26348,14 +26706,19 @@ var rules = {
     })
   ),
   ":list": setFn(
-    (node, ctx) => node.list === "ordered" ? wrapContent("<ol>", "</ol>") : node.list === "variable" ? wrapContent("<dl>", "</dl>") : wrapContent("<ul>", "</ul>")
+    (node, ctx) => node.list === "ordered" ? wrapContent("<ol>", "</ol>") : node.list === "variable" ? wrapContent("<dl>", "</dl>") : node.list === "task" ? wrapContent('<ul class="task-list">', "</ul>") : wrapContent("<ul>", "</ul>")
   ),
   "item:block": (writer, processor) => (node, ctx, interator) => {
     if (!(node.content instanceof Array)) {
       console.error("[pod6] item:block : Error in content of " + JSON.stringify(node));
     }
-    const [firstPara, ...other] = node.content;
-    writer.writeRaw("<li>");
+    const isTask = node.checked !== void 0;
+    if (isTask) {
+      writer.writeRaw('<li class="task-list-item">');
+      writer.writeRaw(node.checked ? '<input type="checkbox" disabled checked> ' : '<input type="checkbox" disabled> ');
+    } else {
+      writer.writeRaw("<li>");
+    }
     interator(node.content, ctx);
     writer.writeRaw("</li>");
   },
@@ -26456,7 +26819,7 @@ function bail(error) {
 var import_is_buffer2 = __toESM(require_is_buffer(), 1);
 var import_extend = __toESM(require_extend(), 1);
 
-// ../../node_modules/unified/node_modules/is-plain-obj/index.js
+// ../../node_modules/is-plain-obj/index.js
 function isPlainObject(value) {
   if (typeof value !== "object" || value === null) {
     return false;
@@ -35053,11 +35416,18 @@ var md2ast = (src, { lineOffset } = { lineOffset: 0 }) => {
     },
     ":listItem": (writer, processor) => (node, ctx, interator) => {
       const savedListLevel = ctx["listLevel"] || 0;
-      const { children, position: position2, ...attr } = node;
-      return mkBlock(
-        { name: "item", type: "block", level: ctx["listLevel"], location: applyLineOffset(position2) },
-        interator(children, { ...ctx, listLevel: savedListLevel, ordered: node.ordered })
-      );
+      const { children, position: position2, checked, ...attr } = node;
+      const blockAttrs = {
+        name: "item",
+        type: "block",
+        level: ctx["listLevel"],
+        location: applyLineOffset(position2)
+      };
+      if (checked !== null && checked !== void 0) {
+        blockAttrs.checked = checked;
+        blockAttrs.config = [{ name: "checked", value: checked, type: "boolean" }];
+      }
+      return mkBlock(blockAttrs, interator(children, { ...ctx, listLevel: savedListLevel, ordered: node.ordered }));
     },
     ":paragraph": (writer, processor) => (node, ctx, interator) => {
       const { children, position: position2, ...attr } = node;