wyreframe 0.1.0

package/src/parser/Semantic/SemanticParser.mjs

@@ -0,0 +1,850 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Grid from "../Core/Grid.mjs";
+import * as Types from "../Core/Types.mjs";
+import * as Core__Int from "@rescript/core/src/Core__Int.mjs";
+import * as AlignmentCalc from "./AlignmentCalc.mjs";
+import * as ParserRegistry from "./ParserRegistry.mjs";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+
+function isWithinChildBoxGrid(row, col, children) {
+  return children.some(child => {
+    let b = child.bounds;
+    if (row >= b.top && row <= b.bottom && col >= b.left) {
+      return col <= b.right;
+    } else {
+      return false;
+    }
+  });
+}
+
+function extractContentLinesFromGrid(box, grid) {
+  let bounds = box.bounds;
+  let children = box.children;
+  let contentStartRow = bounds.top + 1 | 0;
+  let contentEndRow = bounds.bottom - 1 | 0;
+  if (contentStartRow > contentEndRow) {
+    return [];
+  }
+  let contentLines = [];
+  for (let row = contentStartRow; row <= contentEndRow; ++row) {
+    let rowCoveredByChild = children.some(child => {
+      let b = child.bounds;
+      if (row >= b.top && row <= b.bottom && b.left <= (bounds.left + 1 | 0)) {
+        return b.right >= (bounds.right - 1 | 0);
+      } else {
+        return false;
+      }
+    });
+    if (!rowCoveredByChild) {
+      let rowCells = Grid.getLine(grid, row);
+      if (rowCells !== undefined) {
+        let contentStartCol = bounds.left + 1 | 0;
+        let contentEndCol = bounds.right - 1 | 0;
+        if (contentStartCol <= contentEndCol) {
+          let lineChars = [];
+          for (let col = contentStartCol; col <= contentEndCol; ++col) {
+            if (!isWithinChildBoxGrid(row, col, children)) {
+              let cell = rowCells[col];
+              if (cell !== undefined) {
+                let char;
+                if (typeof cell !== "object") {
+                  switch (cell) {
+                    case "Corner" :
+                      char = "+";
+                      break;
+                    case "HLine" :
+                      char = "-";
+                      break;
+                    case "VLine" :
+                      char = "|";
+                      break;
+                    case "Divider" :
+                      char = "=";
+                      break;
+                    case "Space" :
+                      char = " ";
+                      break;
+                  }
+                } else {
+                  char = cell._0;
+                }
+                lineChars.push(char);
+              }
+            }
+          }
+          let line = lineChars.join("");
+          contentLines.push(line);
+        } else {
+          contentLines.push("");
+        }
+      } else {
+        contentLines.push("");
+      }
+    }
+  }
+  return contentLines;
+}
+
+function cellCharToString(cell) {
+  if (typeof cell === "object") {
+    return cell._0;
+  }
+  switch (cell) {
+    case "Corner" :
+      return "+";
+    case "HLine" :
+      return "-";
+    case "VLine" :
+      return "|";
+    case "Divider" :
+      return "=";
+    case "Space" :
+      return " ";
+  }
+}
+
+function cellCharsToString(cells) {
+  return cells.map(cellCharToString).join("");
+}
+
+function getBoxContentAsString(box, grid) {
+  let lines = extractContentLinesFromGrid(box, grid);
+  return lines.join("\n");
+}
+
+function hasContent(box, grid) {
+  let lines = extractContentLinesFromGrid(box, grid);
+  return lines.some(line => {
+    let trimmed = line.trim();
+    return trimmed.length > 0;
+  });
+}
+
+function getContentLineCount(box, _grid) {
+  let bounds = box.bounds;
+  let contentStartRow = bounds.top + 1 | 0;
+  let contentEndRow = bounds.bottom - 1 | 0;
+  if (contentStartRow > contentEndRow) {
+    return 0;
+  } else {
+    return (contentEndRow - contentStartRow | 0) + 1 | 0;
+  }
+}
+
+function defaultSceneMetadata() {
+  return {
+    id: "main",
+    title: "main",
+    transition: "fade",
+    device: "Desktop"
+  };
+}
+
+function parseSceneDirectives(lines) {
+  let sceneId = {
+    contents: undefined
+  };
+  let title = {
+    contents: undefined
+  };
+  let transition = {
+    contents: undefined
+  };
+  let device = {
+    contents: undefined
+  };
+  let contentLines = [];
+  lines.forEach(line => {
+    let trimmed = line.trim();
+    if (trimmed.startsWith("@scene:")) {
+      let id = trimmed.replace("@scene:", "").trim();
+      sceneId.contents = id;
+      return;
+    }
+    if (trimmed.startsWith("@title:")) {
+      let titleValue = trimmed.replace("@title:", "").trim().replaceAll("\"", "");
+      title.contents = titleValue;
+      return;
+    }
+    if (trimmed.startsWith("@transition:")) {
+      let transitionValue = trimmed.replace("@transition:", "").trim();
+      transition.contents = transitionValue;
+      return;
+    }
+    if (!trimmed.startsWith("@device:")) {
+      if (trimmed.startsWith("@")) {
+        return;
+      } else {
+        contentLines.push(line);
+        return;
+      }
+    }
+    let deviceValue = trimmed.replace("@device:", "").trim();
+    let d = Types.parseDeviceType(deviceValue);
+    if (d !== undefined) {
+      device.contents = d;
+      return;
+    }
+  });
+  let id = sceneId.contents;
+  let finalId = id !== undefined ? id : "main";
+  let match = title.contents;
+  let match$1 = sceneId.contents;
+  let finalTitle = match !== undefined ? match : (
+      match$1 !== undefined ? match$1 : "main"
+    );
+  let t = transition.contents;
+  let finalTransition = t !== undefined ? t : "fade";
+  let d = device.contents;
+  let finalDevice = d !== undefined ? d : "Desktop";
+  let metadata = {
+    id: finalId,
+    title: finalTitle,
+    transition: finalTransition,
+    device: finalDevice
+  };
+  return [
+    metadata,
+    contentLines
+  ];
+}
+
+function splitSceneBlocks(wireframeText) {
+  let lines = wireframeText.split("\n");
+  let blocks = [];
+  let currentBlock = {
+    contents: []
+  };
+  lines.forEach(line => {
+    let trimmed = line.trim();
+    if (trimmed === "---") {
+      if (currentBlock.contents.length > 0) {
+        blocks.push(currentBlock.contents.join("\n"));
+        currentBlock.contents = [];
+        return;
+      } else {
+        return;
+      }
+    } else {
+      if (trimmed.startsWith("@scene:") && currentBlock.contents.length > 0) {
+        blocks.push(currentBlock.contents.join("\n"));
+        currentBlock.contents = [line];
+      } else {
+        currentBlock.contents = currentBlock.contents.concat([line]);
+      }
+      return;
+    }
+  });
+  if (currentBlock.contents.length > 0) {
+    blocks.push(currentBlock.contents.join("\n"));
+  }
+  return blocks.filter(block => block.trim() !== "");
+}
+
+function groupContentByScenes(wireframeText) {
+  let blocks = splitSceneBlocks(wireframeText);
+  if (blocks.length !== 0) {
+    return blocks.map(block => parseSceneDirectives(block.split("\n")));
+  }
+  let trimmed = wireframeText.trim();
+  if (trimmed !== "") {
+    return [[
+        {
+          id: "main",
+          title: "main",
+          transition: "fade",
+          device: "Desktop"
+        },
+        [wireframeText]
+      ]];
+  } else {
+    return [];
+  }
+}
+
+function isWithinChildBox(row, col, children) {
+  return children.some(child => {
+    let b = child.bounds;
+    if (row >= b.top && row <= b.bottom && col >= b.left) {
+      return col <= b.right;
+    } else {
+      return false;
+    }
+  });
+}
+
+function rowIntersectsChildBox(row, children) {
+  return children.some(child => {
+    let b = child.bounds;
+    if (row >= b.top) {
+      return row <= b.bottom;
+    } else {
+      return false;
+    }
+  });
+}
+
+function extractContentLines(box, gridCells) {
+  let bounds = box.bounds;
+  let children = box.children;
+  let contentStartRow = bounds.top + 1 | 0;
+  let contentEndRow = bounds.bottom - 1 | 0;
+  if (contentStartRow > contentEndRow) {
+    return [];
+  }
+  let contentLines = [];
+  let gridHeight = gridCells.length;
+  for (let row = contentStartRow; row <= contentEndRow; ++row) {
+    let rowCoveredByChild = children.some(child => {
+      let b = child.bounds;
+      if (row >= b.top && row <= b.bottom && b.left <= (bounds.left + 1 | 0)) {
+        return b.right >= (bounds.right - 1 | 0);
+      } else {
+        return false;
+      }
+    });
+    if (!rowCoveredByChild && row >= 0 && row < gridHeight) {
+      let rowCells = gridCells[row];
+      if (rowCells !== undefined) {
+        let leftBorderCell = rowCells[bounds.left];
+        let startsWithCorner = leftBorderCell === "Corner" && typeof leftBorderCell !== "object";
+        let contentStartCol = startsWithCorner ? bounds.left : bounds.left + 1 | 0;
+        let contentEndCol = bounds.right - 1 | 0;
+        let lineChars = [];
+        for (let col = contentStartCol; col <= contentEndCol; ++col) {
+          if (!isWithinChildBox(row, col, children) && col >= 0 && col < rowCells.length) {
+            let cell = rowCells[col];
+            if (typeof cell !== "object") {
+              switch (cell) {
+                case "Corner" :
+                  lineChars.push("+");
+                  break;
+                case "HLine" :
+                  lineChars.push("-");
+                  break;
+                case "VLine" :
+                  lineChars.push("|");
+                  break;
+                case "Divider" :
+                  lineChars.push("=");
+                  break;
+                case "Space" :
+                  lineChars.push(" ");
+                  break;
+              }
+            } else {
+              lineChars.push(cell._0);
+            }
+          }
+        }
+        let line = lineChars.join("");
+        contentLines.push(line);
+      }
+    }
+  }
+  return contentLines;
+}
+
+function isCheckboxContent(content) {
+  let trimmed = content.trim();
+  let lowerContent = trimmed.toLowerCase();
+  if (lowerContent === "x") {
+    return true;
+  } else {
+    return trimmed === "";
+  }
+}
+
+function splitInlineSegments(line) {
+  let segments = [];
+  let currentText = "";
+  let currentTextStart = 0;
+  let i = 0;
+  let len = line.length;
+  while (i < len) {
+    let char = line.charAt(i);
+    if (char === "[") {
+      let buttonStart = i;
+      let start = i + 1 | 0;
+      let endPos;
+      let j = start;
+      while (j < len && endPos === undefined) {
+        if (line.charAt(j) === "]") {
+          endPos = j;
+        }
+        j = j + 1 | 0;
+      };
+      let end = endPos;
+      if (end !== undefined) {
+        let bracketContent = line.slice(start, end);
+        if (isCheckboxContent(bracketContent)) {
+          if (currentText === "") {
+            currentTextStart = i;
+          }
+          let checkboxText = "[" + bracketContent + "]";
+          currentText = currentText + checkboxText;
+          i = end + 1 | 0;
+        } else {
+          let text = currentText.trim();
+          if (text !== "") {
+            let leadingSpaces = currentText.length - currentText.trimStart().length | 0;
+            segments.push({
+              TAG: "TextSegment",
+              _0: text,
+              _1: currentTextStart + leadingSpaces | 0
+            });
+          }
+          currentText = "";
+          let buttonText = bracketContent.trim();
+          if (buttonText !== "") {
+            segments.push({
+              TAG: "ButtonSegment",
+              _0: buttonText,
+              _1: buttonStart
+            });
+          }
+          i = end + 1 | 0;
+          currentTextStart = i;
+        }
+      } else {
+        if (currentText === "") {
+          currentTextStart = i;
+        }
+        currentText = currentText + char;
+        i = i + 1 | 0;
+      }
+    } else {
+      if (currentText === "") {
+        currentTextStart = i;
+      }
+      currentText = currentText + char;
+      i = i + 1 | 0;
+    }
+  };
+  let text$1 = currentText.trim();
+  if (text$1 !== "") {
+    let leadingSpaces$1 = currentText.length - currentText.trimStart().length | 0;
+    segments.push({
+      TAG: "TextSegment",
+      _0: text$1,
+      _1: currentTextStart + leadingSpaces$1 | 0
+    });
+  }
+  return segments;
+}
+
+function hasInlineElements(line) {
+  let segments = splitInlineSegments(line);
+  if (segments.length > 1) {
+    return true;
+  }
+  let match = segments[0];
+  if (match === undefined) {
+    return false;
+  }
+  switch (match.TAG) {
+    case "TextSegment" :
+      return false;
+    case "ButtonSegment" :
+    case "LinkSegment" :
+      return true;
+  }
+}
+
+function isDividerLine(line) {
+  let trimmed = line.trim();
+  let pureEqualsPattern = /^=+$/;
+  let cornerDividerPattern = /^\+=+\+?$/;
+  let length = trimmed.length;
+  if (length >= 3) {
+    if (pureEqualsPattern.test(trimmed)) {
+      return true;
+    } else {
+      return cornerDividerPattern.test(trimmed);
+    }
+  } else {
+    return false;
+  }
+}
+
+function extractSectionName(line) {
+  let trimmed = line.trim();
+  let sectionPattern = /^\+?-{2,}([^-+]+)-{2,}\+?\s*$/;
+  let result = sectionPattern.exec(trimmed);
+  if (result === null) {
+    return;
+  }
+  let match = result[1];
+  if (match === undefined) {
+    return;
+  }
+  let name = Primitive_option.valFromOption(match);
+  if (name == null) {
+    return;
+  }
+  let cleanName = name.trim();
+  if (cleanName !== "") {
+    return cleanName;
+  }
+}
+
+function isSectionFooter(line) {
+  let trimmed = line.trim();
+  let footerPattern = /^\+?-{3,}\+?\s*$/;
+  return footerPattern.test(trimmed);
+}
+
+function stripSectionBorders(line) {
+  let trimmed = line.trim();
+  let withoutLeading = trimmed.startsWith("| ") ? trimmed.slice(2) : (
+      trimmed.startsWith("|") ? trimmed.slice(1) : trimmed
+    );
+  if (withoutLeading.endsWith(" |")) {
+    return withoutLeading.slice(0, withoutLeading.length - 2 | 0);
+  } else if (withoutLeading.endsWith("|")) {
+    return withoutLeading.slice(0, withoutLeading.length - 1 | 0);
+  } else {
+    return withoutLeading;
+  }
+}
+
+function segmentToElement(segment, basePosition, baseCol, bounds) {
+  switch (segment.TAG) {
+    case "TextSegment" :
+      let text = segment._0;
+      let actualCol = baseCol + segment._1 | 0;
+      let position = Types.Position.make(basePosition.row, actualCol);
+      let align = AlignmentCalc.calculateWithStrategy(text, position, bounds, "RespectPosition");
+      return {
+        TAG: "Text",
+        content: text,
+        emphasis: false,
+        position: position,
+        align: align
+      };
+    case "ButtonSegment" :
+      let text$1 = segment._0;
+      let actualCol$1 = baseCol + segment._1 | 0;
+      let position$1 = Types.Position.make(basePosition.row, actualCol$1);
+      let id = text$1.trim().toLowerCase().replace(/\\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+      let buttonContent = "[ " + text$1 + " ]";
+      let align$1 = AlignmentCalc.calculateWithStrategy(buttonContent, position$1, bounds, "RespectPosition");
+      return {
+        TAG: "Button",
+        id: id,
+        text: text$1,
+        position: position$1,
+        align: align$1,
+        actions: []
+      };
+    case "LinkSegment" :
+      let text$2 = segment._0;
+      let actualCol$2 = baseCol + segment._1 | 0;
+      let position$2 = Types.Position.make(basePosition.row, actualCol$2);
+      let id$1 = text$2.trim().toLowerCase().replace(/\\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+      let align$2 = AlignmentCalc.calculateWithStrategy(text$2, position$2, bounds, "RespectPosition");
+      return {
+        TAG: "Link",
+        id: id$1,
+        text: text$2,
+        position: position$2,
+        align: align$2,
+        actions: []
+      };
+  }
+}
+
+function parseContentLine(line, lineIndex, contentStartRow, box, registry) {
+  let trimmed = line.trim();
+  if (trimmed === "") {
+    return;
+  }
+  let row = contentStartRow + lineIndex | 0;
+  let baseCol = box.bounds.left + 1 | 0;
+  let basePosition = Types.Position.make(row, baseCol);
+  let segments = splitInlineSegments(trimmed);
+  if (segments.length > 1) {
+    let rowChildren = segments.map(segment => segmentToElement(segment, basePosition, baseCol, box.bounds));
+    return {
+      TAG: "Row",
+      children: rowChildren,
+      align: "Left"
+    };
+  }
+  if (segments.length === 1) {
+    let trimmedStart = line.trimStart();
+    let leadingSpaces = line.length - trimmedStart.length | 0;
+    let match = segments[0];
+    if (match !== undefined) {
+      switch (match.TAG) {
+        case "TextSegment" :
+          break;
+        case "ButtonSegment" :
+          let actualCol = (baseCol + leadingSpaces | 0) + match._1 | 0;
+          let position = Types.Position.make(row, actualCol);
+          let buttonContent = "[ " + match._0 + " ]";
+          return ParserRegistry.parse(registry, buttonContent, position, box.bounds);
+        case "LinkSegment" :
+          let colOffset = match._1;
+          let actualCol$1 = (baseCol + leadingSpaces | 0) + colOffset | 0;
+          let adjustedPosition = Types.Position.make(basePosition.row, actualCol$1);
+          return segmentToElement({
+            TAG: "LinkSegment",
+            _0: match._0,
+            _1: colOffset
+          }, adjustedPosition, baseCol + leadingSpaces | 0, box.bounds);
+      }
+    }
+    let position$1 = Types.Position.make(row, baseCol + leadingSpaces | 0);
+    return ParserRegistry.parse(registry, trimmed, position$1, box.bounds);
+  }
+  let trimmedStart$1 = line.trimStart();
+  let leadingSpaces$1 = line.length - trimmedStart$1.length | 0;
+  let position$2 = Types.Position.make(row, baseCol + leadingSpaces$1 | 0);
+  return ParserRegistry.parse(registry, trimmed, position$2, box.bounds);
+}
+
+function parseBoxContent(box, gridCells, registry) {
+  let contentLines = extractContentLines(box, gridCells);
+  let elements = [];
+  let contentStartRow = box.bounds.top + 1 | 0;
+  let currentSection;
+  let i = 0;
+  while (i < contentLines.length) {
+    let lineOpt = contentLines[i];
+    if (lineOpt !== undefined) {
+      let lineIndex = i;
+      if (isDividerLine(lineOpt)) {
+        let row = contentStartRow + lineIndex | 0;
+        let col = box.bounds.left + 1 | 0;
+        elements.push({
+          TAG: "Divider",
+          position: Types.Position.make(row, col)
+        });
+        i = i + 1 | 0;
+      } else {
+        let sectionName = extractSectionName(lineOpt);
+        if (sectionName !== undefined) {
+          let sectionContent = [];
+          i = i + 1 | 0;
+          let foundFooter = false;
+          while (i < contentLines.length && !foundFooter) {
+            let contentLine = contentLines[i];
+            if (contentLine !== undefined) {
+              if (isSectionFooter(contentLine)) {
+                foundFooter = true;
+                i = i + 1 | 0;
+              } else {
+                sectionContent.push([
+                  contentLine,
+                  i
+                ]);
+                i = i + 1 | 0;
+              }
+            } else {
+              i = i + 1 | 0;
+            }
+          };
+          let sectionElements = [];
+          sectionContent.forEach(param => {
+            let strippedLine = stripSectionBorders(param[0]);
+            let elem = parseContentLine(strippedLine, param[1], contentStartRow, box, registry);
+            if (elem !== undefined) {
+              sectionElements.push(elem);
+              return;
+            }
+          });
+          let sectionElement = {
+            TAG: "Section",
+            name: sectionName,
+            children: sectionElements
+          };
+          elements.push(sectionElement);
+        } else if (isSectionFooter(lineOpt)) {
+          i = i + 1 | 0;
+        } else {
+          let elem = parseContentLine(lineOpt, lineIndex, contentStartRow, box, registry);
+          if (elem !== undefined) {
+            elements.push(elem);
+          }
+          i = i + 1 | 0;
+        }
+      }
+    } else {
+      i = i + 1 | 0;
+    }
+  };
+  let match = currentSection;
+  if (match !== undefined) {
+    let sectionElements$1 = [];
+    match[2].forEach(param => {
+      let strippedLine = stripSectionBorders(param[0]);
+      let elem = parseContentLine(strippedLine, param[1], contentStartRow, box, registry);
+      if (elem !== undefined) {
+        sectionElements$1.push(elem);
+        return;
+      }
+    });
+    elements.push({
+      TAG: "Section",
+      name: match[0],
+      children: sectionElements$1
+    });
+  }
+  return elements;
+}
+
+function getElementRow(_elem) {
+  while (true) {
+    let elem = _elem;
+    switch (elem.TAG) {
+      case "Box" :
+        return elem.bounds.top;
+      case "Divider" :
+        return elem.position.row;
+      case "Row" :
+        let child = elem.children[0];
+        if (child === undefined) {
+          return 0;
+        }
+        _elem = child;
+        continue;
+      case "Section" :
+        let child$1 = elem.children[0];
+        if (child$1 === undefined) {
+          return Core__Int.Constants.maxValue;
+        }
+        _elem = child$1;
+        continue;
+      default:
+        return elem.position.row;
+    }
+  };
+}
+
+function parseBoxRecursive(box, gridCells, registry) {
+  let contentElements = parseBoxContent(box, gridCells, registry);
+  let childBoxElements = box.children.map(childBox => parseBoxRecursive(childBox, gridCells, registry));
+  let allChildren = contentElements.concat(childBoxElements);
+  let sortedChildren = allChildren.toSorted((a, b) => {
+    let rowA = getElementRow(a);
+    let rowB = getElementRow(b);
+    return rowA - rowB | 0;
+  });
+  return {
+    TAG: "Box",
+    name: box.name,
+    bounds: box.bounds,
+    children: sortedChildren
+  };
+}
+
+function buildScene(metadata, elements) {
+  return {
+    id: metadata.id,
+    title: metadata.title,
+    transition: metadata.transition,
+    device: metadata.device,
+    elements: elements
+  };
+}
+
+function buildAST(scenes) {
+  return {
+    scenes: scenes
+  };
+}
+
+function parse(context) {
+  let errors = [];
+  if (context.shapes.length === 0) {
+    return {
+      TAG: "Ok",
+      _0: {
+        scenes: []
+      }
+    };
+  }
+  let scenes = context.shapes.map(box => {
+    let boxElement = parseBoxRecursive(box, context.gridCells, context.registry);
+    let elements;
+    elements = boxElement.TAG === "Box" ? boxElement.children : [];
+    let name = box.name;
+    let metadata = name !== undefined ? ({
+        id: name,
+        title: name,
+        transition: "fade",
+        device: "Desktop"
+      }) : ({
+        id: "main",
+        title: "main",
+        transition: "fade",
+        device: "Desktop"
+      });
+    return buildScene(metadata, elements);
+  });
+  let ast = {
+    scenes: scenes
+  };
+  if (errors.length > 0) {
+    return {
+      TAG: "Error",
+      _0: errors
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: ast
+    };
+  }
+}
+
+function parseWithSceneDirectives(wireframeText, context) {
+  let sceneGroups = groupContentByScenes(wireframeText);
+  let scenes = sceneGroups.map(param => {
+    let elements = context.shapes.map(box => parseBoxRecursive(box, context.gridCells, context.registry));
+    return buildScene(param[0], elements);
+  });
+  let ast = {
+    scenes: scenes
+  };
+  return {
+    TAG: "Ok",
+    _0: ast
+  };
+}
+
+export {
+  isWithinChildBoxGrid,
+  extractContentLinesFromGrid,
+  cellCharToString,
+  cellCharsToString,
+  getBoxContentAsString,
+  hasContent,
+  getContentLineCount,
+  defaultSceneMetadata,
+  parseSceneDirectives,
+  splitSceneBlocks,
+  groupContentByScenes,
+  isWithinChildBox,
+  rowIntersectsChildBox,
+  extractContentLines,
+  isCheckboxContent,
+  splitInlineSegments,
+  hasInlineElements,
+  isDividerLine,
+  extractSectionName,
+  isSectionFooter,
+  stripSectionBorders,
+  segmentToElement,
+  parseContentLine,
+  parseBoxContent,
+  getElementRow,
+  parseBoxRecursive,
+  buildScene,
+  buildAST,
+  parse,
+  parseWithSceneDirectives,
+}
+/* Grid Not a pure module */