@podlite/editor-react 0.0.29 → 0.0.31

package/lib/index.cjs

@@ -6948,6 +6948,9 @@ var require_AstTree = __commonJS({
             {
               $ref: "#/definitions/BlockInput"
             },
+            {
+              $ref: "#/definitions/BlockInclude"
+            },
             {
               $ref: "#/definitions/BlockPara"
             },
@@ -7547,6 +7550,58 @@ var require_AstTree = __commonJS({
             "type"
           ]
         },
+        BlockInclude: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              enum: [
+                "include"
+              ]
+            },
+            type: {
+              type: "string",
+              enum: [
+                "block"
+              ]
+            },
+            location: {
+              $ref: "#/definitions/Location"
+            },
+            content: {
+              type: "array",
+              items: {
+                $ref: "#/definitions/PodNode"
+              }
+            },
+            margin: {
+              type: "string"
+            },
+            config: {
+              type: "array",
+              items: {
+                anyOf: [
+                  {
+                    $ref: "#/definitions/BrokenConfigItem"
+                  },
+                  {
+                    $ref: "#/definitions/ConfigItem"
+                  }
+                ]
+              }
+            },
+            id: {
+              type: "string"
+            }
+          },
+          required: [
+            "content",
+            "location",
+            "margin",
+            "name",
+            "type"
+          ]
+        },
         BlockPara: {
           type: "object",
           properties: {
@@ -7814,6 +7869,9 @@ var require_AstTree = __commonJS({
                   {
                     $ref: "#/definitions/BlockInput"
                   },
+                  {
+                    $ref: "#/definitions/BlockInclude"
+                  },
                   {
                     $ref: "#/definitions/BlockPara"
                   },
@@ -9642,6 +9700,9 @@ var require_PodliteDocument = __commonJS({
             {
               $ref: "#/definitions/BlockInput"
             },
+            {
+              $ref: "#/definitions/BlockInclude"
+            },
             {
               $ref: "#/definitions/BlockPara"
             },
@@ -10241,6 +10302,58 @@ var require_PodliteDocument = __commonJS({
             "type"
           ]
         },
+        BlockInclude: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              enum: [
+                "include"
+              ]
+            },
+            type: {
+              type: "string",
+              enum: [
+                "block"
+              ]
+            },
+            location: {
+              $ref: "#/definitions/Location"
+            },
+            content: {
+              type: "array",
+              items: {
+                $ref: "#/definitions/PodNode"
+              }
+            },
+            margin: {
+              type: "string"
+            },
+            config: {
+              type: "array",
+              items: {
+                anyOf: [
+                  {
+                    $ref: "#/definitions/BrokenConfigItem"
+                  },
+                  {
+                    $ref: "#/definitions/ConfigItem"
+                  }
+                ]
+              }
+            },
+            id: {
+              type: "string"
+            }
+          },
+          required: [
+            "content",
+            "location",
+            "margin",
+            "name",
+            "type"
+          ]
+        },
         BlockPara: {
           type: "object",
           properties: {
@@ -10508,6 +10621,9 @@ var require_PodliteDocument = __commonJS({
                   {
                     $ref: "#/definitions/BlockInput"
                   },
+                  {
+                    $ref: "#/definitions/BlockInclude"
+                  },
                   {
                     $ref: "#/definitions/BlockPara"
                   },
@@ -18450,6 +18566,7 @@ var require_grammar = __commonJS({
           "defn",
           "formula",
           "head",
+          "include",
           "input",
           "item",
           "markdown",
@@ -25128,7 +25245,7 @@ var require_package = __commonJS({
   "../podlite-schema/package.json"(exports, module2) {
     module2.exports = {
       name: "@podlite/schema",
-      version: "0.0.23",
+      version: "0.0.25",
       description: "AST tools for Podlite markup language",
       main: "./src/index.ts",
       license: "MIT",
@@ -25194,7 +25311,7 @@ __export(exports, {
 });
 var import_react = __toModule(require("react"));
 var import_react_codemirror2 = __toModule(require("react-codemirror2"));
-var import_codemirror = __toModule(require("codemirror"));
+var import_codemirror3 = __toModule(require("codemirror"));
 
 // src/dict.ts
 var dict = [
@@ -25462,6 +25579,693 @@ var import_searchcursor = __toModule(require("codemirror/addon/search/searchcurs
 var import_dialog = __toModule(require("codemirror/addon/dialog/dialog"));
 var import_dialog2 = __toModule(require("codemirror/addon/dialog/dialog.css"));
 
+// src/podlite-mode.js
+var import_codemirror2 = __toModule(require("codemirror"));
+
+// src/simpleplus.js
+var import_codemirror = __toModule(require("codemirror"));
+import_codemirror.default.defineSimpleModePlus = function(name, states) {
+  import_codemirror.default.defineMode(name, function(config) {
+    return import_codemirror.default.simpleModePlus(config, states);
+  });
+};
+import_codemirror.default.simpleModePlus = function(config, states) {
+  ensureState(states, "start");
+  var states_ = {}, meta = states.meta || {}, hasIndentation = false;
+  for (var state in states)
+    if (state != meta && states.hasOwnProperty(state)) {
+      var list = states_[state] = [], orig = states[state];
+      for (var i = 0; i < orig.length; i++) {
+        var data = orig[i];
+        list.push(new Rule(data, states));
+        if (data.indent || data.dedent)
+          hasIndentation = true;
+      }
+    }
+  var mode = {
+    startState: function() {
+      return {state: "start", pending: null, local: null, localState: null, indent: hasIndentation ? [] : null};
+    },
+    copyState: function(state2) {
+      var s = {
+        state: state2.state,
+        pending: state2.pending,
+        local: state2.local,
+        localState: null,
+        indent: state2.indent && state2.indent.slice(0),
+        blankLine: state2.blankLine && state2.blankLine
+      };
+      if (state2.localState)
+        s.localState = import_codemirror.default.copyState(state2.local.mode, state2.localState);
+      if (state2.stack)
+        s.stack = state2.stack.slice(0);
+      for (var pers = state2.persistentStates; pers; pers = pers.next)
+        s.persistentStates = {
+          mode: pers.mode,
+          spec: pers.spec,
+          state: pers.state == state2.localState ? s.localState : import_codemirror.default.copyState(pers.mode, pers.state),
+          next: s.persistentStates
+        };
+      return s;
+    },
+    token: tokenFunction(states_, config),
+    innerMode: function(state2) {
+      return state2.local && {mode: state2.local.mode, state: state2.localState};
+    },
+    indent: indentFunction(states_, meta),
+    blankLine: function(state2) {
+      state2.blankLine = 1;
+    }
+  };
+  if (meta) {
+    for (var prop in meta)
+      if (meta.hasOwnProperty(prop))
+        mode[prop] = meta[prop];
+  }
+  return mode;
+};
+function ensureState(states, name) {
+  if (!states.hasOwnProperty(name))
+    throw new Error("Undefined state " + name + " in simple mode");
+}
+function toRegex(val, caret) {
+  if (!val)
+    return /(?:)/;
+  var flags = "";
+  if (val instanceof RegExp) {
+    if (val.ignoreCase)
+      flags = "i";
+    if (val.unicode)
+      flags += "u";
+    val = val.source;
+  } else {
+    val = String(val);
+  }
+  return new RegExp((caret === false ? "" : "^") + "(?:" + val + ")", flags);
+}
+function asToken(val) {
+  if (!val)
+    return null;
+  if (val.apply)
+    return val;
+  if (typeof val == "string")
+    return val.replace(/\./g, " ");
+  var result = [];
+  for (var i = 0; i < val.length; i++)
+    result.push(val[i] && val[i].replace(/\./g, " "));
+  return result;
+}
+function Rule(data, states) {
+  if (data.push)
+    ensureState(states, data.push);
+  this.regex = toRegex(data.regex);
+  this.token = asToken(data.token);
+  this.data = data;
+}
+function tokenFunction(states, config) {
+  return function(stream, state) {
+    if (state.pending) {
+      var pend = state.pending.shift();
+      if (state.pending.length == 0)
+        state.pending = null;
+      stream.pos += pend.text.length;
+      return pend.token;
+    }
+    if (state.local) {
+      if (state.local.end && stream.match(state.local.end)) {
+        var tok = state.local.endToken || null;
+        state.local = state.localState = null;
+        return tok;
+      } else {
+        var tok = state.local.mode.token(stream, state.localState), m;
+        if (state.local.endScan && (m = state.local.endScan.exec(stream.current())))
+          stream.pos = stream.start + m.index;
+        return tok;
+      }
+    }
+    const ruleBlankLine = states[state.state].find((i2) => i2.data.blankline);
+    if (state.blankLine && ruleBlankLine) {
+      if (ruleBlankLine.data.next) {
+        state.state = ruleBlankLine.data.next;
+      } else if (ruleBlankLine.data.push) {
+        ;
+        (state.stack || (state.stack = [])).push(state.state);
+        state.state = ruleBlankLine.data.push;
+      } else if (ruleBlankLine.data.pop && state.stack && state.stack.length) {
+        state.state = state.stack.pop();
+      }
+    }
+    state.blankLine = void 0;
+    var curState = states[state.state];
+    for (var i = 0; i < curState.length; i++) {
+      var rule = curState[i];
+      var matches = (!rule.data.sol || stream.sol()) && stream.match(rule.regex);
+      if (matches) {
+        if (rule.data.next) {
+          var next = rule.data.next;
+          if (next.apply)
+            next = next(matches);
+          state.state = next;
+        } else if (rule.data.push) {
+          ;
+          (state.stack || (state.stack = [])).push(state.state);
+          state.state = rule.data.push;
+        } else if (rule.data.pop && state.stack && state.stack.length) {
+          state.state = state.stack.pop();
+        }
+        if (rule.data.mode)
+          enterLocalMode(config, state, rule.data.mode, rule.token);
+        if (rule.data.indent)
+          state.indent.push(stream.indentation() + config.indentUnit);
+        if (rule.data.dedent)
+          state.indent.pop();
+        var token = rule.token;
+        if (token && token.apply)
+          token = token(matches, state);
+        if (matches.length > 2 && rule.token && typeof rule.token != "string") {
+          for (var j = 2; j < matches.length; j++)
+            if (matches[j])
+              (state.pending || (state.pending = [])).push({text: matches[j], token: token[j - 1]});
+          stream.backUp(matches[0].length - (matches[1] ? matches[1].length : 0));
+          return token[0];
+        } else if (token && token.join) {
+          return token[0];
+        } else {
+          return token;
+        }
+      }
+    }
+    stream.next();
+    return null;
+  };
+}
+function cmp(a, b) {
+  if (a === b)
+    return true;
+  if (!a || typeof a != "object" || !b || typeof b != "object")
+    return false;
+  var props = 0;
+  for (var prop in a)
+    if (a.hasOwnProperty(prop)) {
+      if (!b.hasOwnProperty(prop) || !cmp(a[prop], b[prop]))
+        return false;
+      props++;
+    }
+  for (var prop in b)
+    if (b.hasOwnProperty(prop))
+      props--;
+  return props == 0;
+}
+function enterLocalMode(config, state, spec, token) {
+  var pers;
+  if (spec.persistent) {
+    for (var p = state.persistentStates; p && !pers; p = p.next)
+      if (spec.spec ? cmp(spec.spec, p.spec) : spec.mode == p.mode)
+        pers = p;
+  }
+  var mode = pers ? pers.mode : spec.mode || import_codemirror.default.getMode(config, spec.spec);
+  var lState = pers ? pers.state : import_codemirror.default.startState(mode);
+  if (spec.persistent && !pers)
+    state.persistentStates = {mode, spec: spec.spec, state: lState, next: state.persistentStates};
+  state.localState = lState;
+  state.local = {
+    mode,
+    end: spec.end && toRegex(spec.end),
+    endScan: spec.end && spec.forceEnd !== false && toRegex(spec.end, false),
+    endToken: token && token.join ? token[token.length - 1] : token
+  };
+}
+function indexOf(val, arr) {
+  for (var i = 0; i < arr.length; i++)
+    if (arr[i] === val)
+      return true;
+}
+function indentFunction(states, meta) {
+  return function(state, textAfter, line) {
+    if (state.local && state.local.mode.indent)
+      return state.local.mode.indent(state.localState, textAfter, line);
+    if (state.indent == null || state.local || meta.dontIndentStates && indexOf(state.state, meta.dontIndentStates) > -1)
+      return import_codemirror.default.Pass;
+    var pos = state.indent.length - 1, rules2 = states[state.state];
+    scan:
+      for (; ; ) {
+        for (var i = 0; i < rules2.length; i++) {
+          var rule = rules2[i];
+          if (rule.data.dedent && rule.data.dedentIfLineStart !== false) {
+            var m = rule.regex.exec(textAfter);
+            if (m && m[0]) {
+              pos--;
+              if (rule.next || rule.push)
+                rules2 = states[rule.next || rule.push];
+              textAfter = textAfter.slice(m[0].length);
+              continue scan;
+            }
+          }
+        }
+        break;
+      }
+    return pos < 0 ? 0 : state.indent[pos];
+  };
+}
+
+// src/podlite-mode.js
+function ifBeginAbbrBlock(ifOk) {
+  const res = [
+    {
+      regex: /\s*(=)(?=head\d*|item\d*|code|comment|data|defn|formula|input|markdown|nested|output|para|picture|pod|table|toc|include)/,
+      token: "keyword",
+      sol: true,
+      push: ifOk
+    }
+  ];
+  return res;
+}
+function getBlockNames() {
+  const names = [
+    "code",
+    "comment",
+    "data",
+    "defn",
+    "formula",
+    "input",
+    "markdown",
+    "nested",
+    "output",
+    "para",
+    "picture",
+    "pod",
+    "table",
+    "toc",
+    "include"
+  ];
+  names.push(...[...Array(10)].map((_, i) => `head${i + 1}`));
+  names.push(...[...Array(10)].map((_, i) => `item${i + 1}`).reverse());
+  names.push("item", "head");
+  return names;
+}
+function getContentState(token = "content") {
+  return [
+    {
+      regex: /(?=\s*=\w+)/,
+      token: "content",
+      sol: true,
+      pop: true
+    },
+    ...getDefaultContentState(token)
+  ];
+}
+function getDefaultContentState(token = "content") {
+  const getStateForMarkupCodes = ({token: token2}) => {
+    const allcodes = ["A", "B", "F", "I", "L", "O", "Z"].join("|");
+    const handler = (token3) => (matches) => {
+      var _a;
+      const code = ((_a = matches == null ? void 0 : matches.groups) == null ? void 0 : _a.code) || "NONEXISTS";
+      const mapCodeToToken = {
+        A: `variable-3 ${token3}`,
+        B: `strong ${token3}`,
+        F: `${token3}`,
+        I: `em ${token3}`,
+        L: `link ${token3}`,
+        O: `strikethrough ${token3}`,
+        Z: `comment ${token3}`
+      };
+      const resultToken = matches[1];
+      return ["keyword", "keyword", mapCodeToToken[resultToken] || token3, "keyword"];
+    };
+    return [
+      {
+        regex: new RegExp(`(?<code>${allcodes})(<)([^>]*)(>)`),
+        token: handler(token2)
+      },
+      {
+        regex: new RegExp(`(?<code>${allcodes})(\xAB)([^\xBB]*)(\xBB)`),
+        token: handler(token2)
+      },
+      {
+        regex: /./,
+        token: token2
+      }
+    ];
+  };
+  return [
+    ...getStateForMarkupCodes({token}),
+    {
+      regex: /./,
+      token
+    }
+  ];
+}
+function getVerbatimContentState(token = "content") {
+  return [
+    {
+      regex: /./,
+      token
+    }
+  ];
+}
+function isBlankLine(attr = {}) {
+  return [
+    {
+      regex: /^\s*$/,
+      token: null,
+      sol: true,
+      pop: true,
+      ...attr
+    },
+    {
+      regex: /blankline/,
+      token: null,
+      blankline: true,
+      pop: true,
+      ...attr
+    }
+  ];
+}
+function getStatesForBlock(blockName, contentToken) {
+  if (blockName.match(/^(?:code|comment|data)$/)) {
+    return {
+      [`${blockName}_content_Abbr`]: [...getVerbatimContentState(contentToken)],
+      [`${blockName}_attr_Para`]: [
+        ...ifNextStartAnyBlock({pop: true}),
+        ...attributesContent({next: `${blockName}_content_Para`})
+      ],
+      [`${blockName}_content_Para`]: [...isBlankLine({pop: true}), ...getVerbatimContentState(contentToken)],
+      [`${blockName}_attr_Delim`]: [...attributesContent({next: `${blockName}_content_Delim`})],
+      [`${blockName}_content_Delim`]: [
+        {
+          regex: new RegExp(`(?=\\s*=end\\s*(?:${blockName}))`),
+          token: null,
+          sol: true,
+          next: "endDelimBlock"
+        },
+        ...getVerbatimContentState(contentToken),
+        {
+          regex: /.*/,
+          token: `content`
+        }
+      ]
+    };
+  }
+  return {
+    [`${blockName}_content_Abbr`]: [...isBlankLine({pop: true}), ...getContentState(contentToken)],
+    [`${blockName}_attr_Para`]: [
+      ...ifNextStartAnyBlock({pop: true}),
+      ...attributesContent({next: `${blockName}_content_Para`})
+    ],
+    [`${blockName}_content_Para`]: [...isBlankLine({pop: true}), ...getContentState(contentToken)],
+    [`${blockName}_attr_Delim`]: [
+      ...ifNextStartAnyBlock({pop: true}),
+      ...attributesContent({next: `${blockName}_content_Delim`})
+    ],
+    [`${blockName}_content_Delim`]: [
+      ...ifNextAliasDirective("beginAliasDirective"),
+      ...ifNextConfigDirective("beginConfigDirective"),
+      ...ifBeginParaBlock("beginParaBlock"),
+      ...ifBeginAbbrBlock("beginAbbrBlock"),
+      ...ifBeginDelimBlock("beginDelimBlock"),
+      ...ifNextEndDelimBlock({next: "endDelimBlock"}),
+      ...getDefaultContentState(contentToken),
+      {
+        regex: /.*/,
+        token: `content`
+      }
+    ]
+  };
+}
+function getContentStates() {
+  const names = getBlockNames();
+  const getStateForBlock = (blockName) => {
+    var _a, _b;
+    const matchRes = blockName.match(/(?<blockname>[^\d]+)(?<level>\d*)/);
+    const level = ((_a = matchRes == null ? void 0 : matchRes.groups) == null ? void 0 : _a.level) || 1;
+    const blName = ((_b = matchRes == null ? void 0 : matchRes.groups) == null ? void 0 : _b.blockname) || blockName;
+    if (blName === "head") {
+      return getStatesForBlock(blockName, `header header-${level}`);
+    }
+    if (blName === "comment") {
+      return getStatesForBlock(blockName, `comment`);
+    }
+    return getStatesForBlock(blockName);
+  };
+  return names.reduce((acc, name) => {
+    return {...acc, ...getStateForBlock(name)};
+  }, {});
+}
+function ifBlockName(ifOk = "content", attr = {}) {
+  const names = getBlockNames();
+  if (ifOk === "Para") {
+    const res = {
+      regex: /(?<blockName>head\d*|item\d*|code|comment|data|defn|formula|input|markdown|nested|output|para|picture|pod|table|toc|include)/,
+      token: function(matches) {
+        var _a;
+        const blockName = ((_a = matches == null ? void 0 : matches.groups) == null ? void 0 : _a.blockName) || "default";
+        return [`variable-2 ${blockName}`];
+      },
+      next: function(matches) {
+        var _a;
+        const blockName = ((_a = matches == null ? void 0 : matches.groups) == null ? void 0 : _a.blockName) || "default";
+        return `${blockName}_attr_Para`;
+      }
+    };
+    return [res];
+  }
+  if (ifOk === "Abbr") {
+    const res = {
+      regex: /(?<blockName>head\d*|item\d*|code|comment|data|defn|formula|input|markdown|nested|output|para|picture|pod|table|toc|include)/,
+      token: function(matches) {
+        var _a;
+        const blockName = ((_a = matches == null ? void 0 : matches.groups) == null ? void 0 : _a.blockName) || "default";
+        return [`variable-2 ${blockName}`];
+      },
+      next: function(matches) {
+        var _a;
+        const blockName = ((_a = matches == null ? void 0 : matches.groups) == null ? void 0 : _a.blockName) || "default";
+        return `${blockName}_content_Abbr`;
+      }
+    };
+    return [res];
+  }
+  if (ifOk === "Delim") {
+    const res = {
+      regex: /(?<blockName>head\d*|item\d*|code|comment|data|defn|formula|input|markdown|nested|output|para|picture|pod|table|toc|include)/,
+      token: function(matches) {
+        var _a;
+        const blockName = ((_a = matches == null ? void 0 : matches.groups) == null ? void 0 : _a.blockName) || "default";
+        return [`variable-2 ${blockName}`];
+      },
+      next: function(matches) {
+        var _a;
+        const blockName = ((_a = matches == null ? void 0 : matches.groups) == null ? void 0 : _a.blockName) || "default";
+        return `${blockName}_attr_Delim`;
+      }
+    };
+    return [res];
+  }
+  throw new Error("[ifBlockName] Undefined parametr vlue " + ifOk);
+}
+function ifNextBeginDelimBlock(attr = {}) {
+  return [
+    {
+      regex: /(?=\s*=begin\s*(?:head\d*|item\d*|code|comment|data|defn|formula|input|markdown|nested|output|para|picture|pod|table|toc|include|\w+))/,
+      token: null,
+      sol: true,
+      ...attr
+    }
+  ];
+}
+function ifNextEndDelimBlock(attr = {}) {
+  return [
+    {
+      regex: /(?=\s*=end\s*(?:head\d*|item\d*|code|comment|data|defn|formula|input|markdown|nested|output|para|picture|pod|table|toc|include|\w+))/,
+      token: null,
+      sol: true,
+      ...attr
+    }
+  ];
+}
+function ifNextBeginAbbrBlock(attr = {}) {
+  return [
+    {
+      regex: /(?=\s*=(?:head\d*|item\d*|code|comment|data|defn|formula|input|markdown|nested|output|para|picture|pod|table|toc|include))/,
+      token: null,
+      sol: true,
+      ...attr
+    }
+  ];
+}
+function ifNextBeginParaBlock(attr = {}) {
+  return [
+    {
+      regex: /(?=\s*=for\s*(?=head\d*|item\d*|code|comment|data|defn|formula|input|markdown|nested|output|para|picture|pod|table|toc|include|\w+))/,
+      token: "keyword",
+      sol: true,
+      ...attr
+    }
+  ];
+}
+function ifNextStartAnyBlock(attr = {}) {
+  return [...ifNextBeginDelimBlock(attr), ...ifNextBeginAbbrBlock(attr), ...ifNextBeginParaBlock(attr)];
+}
+function attributesContent(attr = {}) {
+  return [
+    ...ifEndOfAttributes(attr),
+    {
+      regex: /(\s*)(=)(\s*)/,
+      token: [null, "keyword", null],
+      sol: true
+    },
+    {
+      regex: /:\w+/,
+      token: "attribute"
+    },
+    {
+      regex: /[<(].*?[>)]/,
+      token: "string"
+    }
+  ];
+}
+function ifEndOfAttributes(attr = {}) {
+  return [
+    {
+      regex: /(?!\s*=\s+)/,
+      token: null,
+      sol: true,
+      ...attr
+    }
+  ];
+}
+function ifBeginDelimBlock(ifOk) {
+  return [
+    {
+      regex: /\s*(=begin)\s*(?=head\d*|item\d*|code|comment|data|defn|formula|input|markdown|nested|output|para|picture|pod|table|toc|include|\w+)/,
+      token: "keyword",
+      sol: true,
+      push: ifOk
+    }
+  ];
+}
+function ifBeginParaBlock(ifOk) {
+  return [
+    {
+      regex: /\s*(=for)\s*(?=head\d*|item\d*|code|comment|data|defn|formula|input|markdown|nested|output|para|picture|pod|table|toc|include|\w+)/,
+      token: "keyword",
+      sol: true,
+      push: ifOk
+    }
+  ];
+}
+function ifNextAliasDirective(ifOk) {
+  return [
+    {
+      regex: /(?=\s*=alias)/,
+      token: null,
+      sol: true,
+      push: ifOk
+    }
+  ];
+}
+function ifNextConfigDirective(ifOk) {
+  return [
+    {
+      regex: /(?=\s*=config)/,
+      token: null,
+      sol: true,
+      push: ifOk
+    }
+  ];
+}
+import_codemirror2.default.defineSimpleModePlus("podlite", {
+  start: [
+    ...ifNextAliasDirective("beginAliasDirective"),
+    ...ifNextConfigDirective("beginConfigDirective"),
+    ...ifBeginParaBlock("beginParaBlock"),
+    ...ifBeginAbbrBlock("beginAbbrBlock"),
+    ...ifBeginDelimBlock("beginDelimBlock"),
+    ...getDefaultContentState()
+  ],
+  beginDelimBlock: [
+    ...ifBlockName("Delim"),
+    {
+      regex: /(\w+)(\s*)/,
+      token: [`variable-3`, null],
+      next: "attributes_delim"
+    }
+  ],
+  attributes_delim: [
+    ...ifNextEndDelimBlock({next: "endDelimBlock"}),
+    ...attributesContent({next: "contentDelimBlock"})
+  ],
+  contentDelimBlock: [
+    ...ifBeginParaBlock("beginParaBlock"),
+    ...ifBeginAbbrBlock("beginAbbrBlock"),
+    ...ifBeginDelimBlock("beginDelimBlock"),
+    ...ifNextEndDelimBlock({next: "endDelimBlock"}),
+    ...getDefaultContentState(),
+    {
+      regex: /.*/,
+      token: `content`
+    }
+  ],
+  endDelimBlock: [
+    {
+      regex: /(\s*)(=end)(\s*)(?<blockName>head\d*|item\d*|code|comment|data|defn|formula|input|markdown|nested|output|para|picture|pod|table|toc|include)/,
+      token: function(matches) {
+        var _a;
+        const blockName = ((_a = matches == null ? void 0 : matches.groups) == null ? void 0 : _a.blockName) || "default";
+        return [null, "keyword", null, blockName === "comment" ? "comment" : "variable-2"];
+      },
+      sol: true,
+      pop: true
+    },
+    {
+      regex: /(\s*)(=end)(\s*)(\w+)/,
+      token: [null, "keyword", null, "variable-3"],
+      sol: true,
+      pop: true
+    }
+  ],
+  beginAliasDirective: [
+    {
+      regex: /(\s*)(=)(\s+)(.*)$/,
+      token: [null, "keyword", null, "content"],
+      sol: true
+    },
+    {
+      regex: /^(\s*)(=\w+)(\s*)(\w*)(.*)$/,
+      token: [null, "keyword", null, "variable-3", "content"],
+      sol: true
+    },
+    {
+      regex: /(?!\s*=\s+)/,
+      token: null,
+      sol: true,
+      pop: true
+    }
+  ],
+  beginConfigDirective: [
+    {
+      regex: /(\s*)(=\w+)(\s*)/,
+      token: [null, "keyword", null],
+      sol: true,
+      next: "config_attr"
+    }
+  ],
+  config_attr: [...ifNextStartAnyBlock({pop: true}), ...attributesContent({pop: true})],
+  beginParaBlock: [
+    ...ifBlockName("Para"),
+    {
+      regex: /(\w+)(\s*)/,
+      token: ["variable-3", null],
+      next: "attributes"
+    }
+  ],
+  attributes: [...ifNextStartAnyBlock({pop: true}), ...attributesContent({next: "content"})],
+  beginAbbrBlock: [...ifBlockName("Abbr")],
+  content: [...getContentState()],
+  ...getContentStates()
+});
+import_codemirror2.default.defineMIME("text/podlite", "podlite");
+
 // ../podlite-schema/src/index.ts
 var import_ajv = __toModule(require_ajv());
 var pointer = __toModule(require_json_pointer());
@@ -26999,7 +27803,8 @@ var Editor = ({
   },
   sourceType = "pod6",
   isControlled = false,
-  isAutoComplete = true
+  isAutoComplete = true,
+  isHighlightSource = false
 }) => {
   const [text, updateText] = (0, import_react2.useState)(content2);
   const [marks, updateMarks] = (0, import_react2.useState)([]);
@@ -27039,12 +27844,14 @@ var Editor = ({
     autofocus: true,
     lineWrapping: true,
     viewportMargin: Infinity,
-    mode: sourceType !== "md" ? null : {
-      name: "gfm",
-      tokenTypeOverrides: {
-        emoji: "emoji"
+    ...isHighlightSource ? {
+      mode: sourceType !== "md" ? {name: "podlite"} : {
+        name: "gfm",
+        tokenTypeOverrides: {
+          emoji: "emoji"
+        }
       }
-    },
+    } : {mode: null},
     theme: isDarkTheme ? "duotone-dark" : "default"
   };
   const previewEl = (0, import_react2.useRef)(null);
@@ -27141,11 +27948,11 @@ var Editor = ({
       return;
     var onChange = function(instance, object) {
       if (object.text[0] === "=" && instance.getRange({ch: 0, line: object.to.line}, object.to).match(/^\s*$/)) {
-        import_codemirror.default.showHint(instanceCMLocal, import_codemirror.default.hint.dictionaryHint);
+        import_codemirror3.default.showHint(instanceCMLocal, import_codemirror3.default.hint.dictionaryHint);
       }
     };
     instanceCMLocal.on("change", onChange);
-    import_codemirror.default.registerHelper("hint", "dictionaryHint", function(editor) {
+    import_codemirror3.default.registerHelper("hint", "dictionaryHint", function(editor) {
       var cur = editor.getCursor();
       var curLine = editor.getLine(cur.line);
       var start = cur.ch;
@@ -27191,8 +27998,8 @@ var Editor = ({
       });
       return {
         list: resultDict,
-        from: import_codemirror.default.Pos(cur.line, start - 1),
-        to: import_codemirror.default.Pos(cur.line, end)
+        from: import_codemirror3.default.Pos(cur.line, start - 1),
+        to: import_codemirror3.default.Pos(cur.line, end)
       };
     });
     instanceCMLocal.refresh();