mason-parser 1.0.0 → 1.0.2

package/dist/index.mjs

@@ -1,216 +1,822 @@
 // index.ts
+var BACKTICK_REGEX = /`+/g;
+var DOUBLE_QUOTE_REGEX = /"/g;
+var LANGUAGE_TAG_REGEX = /^[a-zA-Z0-9+#-]+$/;
+var NUMBER_REGEX = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+function findColonIndex(line, start) {
+  const len = line.length;
+  let inDouble = false;
+  let inSingle = false;
+  let inBacktick = false;
+  for (let i = start; i < len; i++) {
+    const code = line.charCodeAt(i);
+    if (code === 92) {
+      i++;
+      continue;
+    }
+    if (code === 34 && !inSingle && !inBacktick) {
+      inDouble = !inDouble;
+    } else if (code === 39 && !inDouble && !inBacktick) {
+      inSingle = !inSingle;
+    } else if (code === 96 && !inDouble && !inSingle) {
+      inBacktick = !inBacktick;
+    } else if (code === 58 && !inDouble && !inSingle && !inBacktick) {
+      return i;
+    }
+  }
+  return -1;
+}
 function parsePrimitiveValue(val) {
-  const trimmed = val.trim();
-  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
-    return trimmed.slice(1, -1);
+  const len = val.length;
+  if (len === 0) return val;
+  const first = val.charCodeAt(0);
+  const last = val.charCodeAt(len - 1);
+  if (len >= 2) {
+    if (first === 34 && last === 34 || first === 39 && last === 39 || first === 96 && last === 96) {
+      const content = val.slice(1, -1);
+      if (content.indexOf("\\") !== -1) {
+        if (first === 34) {
+          return content.replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+        } else if (first === 39) {
+          return content.replace(/\\'/g, "'").replace(/\\\\/g, "\\");
+        } else if (first === 96) {
+          return content.replace(/\\`/g, "`").replace(/\\\\/g, "\\");
+        }
+      }
+      return content;
+    }
   }
-  if (trimmed === "true") return true;
-  if (trimmed === "false") return false;
-  if (trimmed === "null") return null;
-  if (trimmed !== "" && !isNaN(Number(trimmed))) {
-    return Number(trimmed);
+  if (first === 116 && val === "true") return true;
+  if (first === 102 && val === "false") return false;
+  if (first === 110 && val === "null") return null;
+  if (first >= 48 && first <= 57 || first === 45 || first === 46 || first === 43) {
+    if (NUMBER_REGEX.test(val)) {
+      const num = Number(val);
+      if (!isNaN(num)) {
+        return num;
+      }
+    }
+  }
+  return val;
+}
+function parseValueWithMultiline(initialValStr, lines, currentLineIndex) {
+  const valStr = initialValStr;
+  let nextLineIndex = currentLineIndex;
+  let backtickCount = 0;
+  while (backtickCount < valStr.length && valStr.charCodeAt(backtickCount) === 96) {
+    backtickCount++;
+  }
+  if (backtickCount > 0) {
+    const termSeq = "`".repeat(backtickCount);
+    if (valStr.endsWith(termSeq) && valStr.length >= backtickCount * 2) {
+      let content = valStr.slice(backtickCount, -backtickCount);
+      if (backtickCount > 1 && content.startsWith(" ") && content.endsWith(" ") && content.trim() !== "") {
+        content = content.slice(1, -1);
+      }
+      const trimmedVal = content.trim();
+      if (trimmedVal === "true" || trimmedVal === "false" || trimmedVal === "null" || trimmedVal !== "" && !isNaN(Number(trimmedVal))) {
+        return { value: parsePrimitiveValue(trimmedVal), nextLineIndex };
+      } else {
+        return { value: content, nextLineIndex };
+      }
+    } else {
+      let firstLineContent = valStr.slice(backtickCount).trim();
+      if (backtickCount >= 3 && LANGUAGE_TAG_REGEX.test(firstLineContent)) {
+        firstLineContent = "";
+      }
+      let multilineContent = firstLineContent;
+      if (multilineContent) {
+        multilineContent += "\n";
+      }
+      let j = currentLineIndex + 1;
+      for (; j < lines.length; j++) {
+        const nextRawLine = lines[j];
+        let endIdx = nextRawLine.length - 1;
+        while (endIdx >= 0) {
+          const code = nextRawLine.charCodeAt(endIdx);
+          if (code === 32 || code === 9 || code === 13) {
+            endIdx--;
+          } else {
+            break;
+          }
+        }
+        let endsWithTerm = false;
+        if (endIdx + 1 >= backtickCount) {
+          endsWithTerm = true;
+          for (let k = 0; k < backtickCount; k++) {
+            if (nextRawLine.charCodeAt(endIdx - k) !== 96) {
+              endsWithTerm = false;
+              break;
+            }
+          }
+        }
+        if (endsWithTerm) {
+          const lastIndex = endIdx - backtickCount + 1;
+          const lineContent = nextRawLine.slice(0, lastIndex);
+          multilineContent += lineContent;
+          nextLineIndex = j;
+          break;
+        } else {
+          multilineContent += nextRawLine + "\n";
+        }
+      }
+      const trimmedVal = multilineContent.trim();
+      if (trimmedVal === "true" || trimmedVal === "false" || trimmedVal === "null" || trimmedVal !== "" && !isNaN(Number(trimmedVal))) {
+        return { value: parsePrimitiveValue(trimmedVal), nextLineIndex };
+      } else {
+        let cleanStr = multilineContent;
+        if (cleanStr.startsWith("\n")) {
+          cleanStr = cleanStr.slice(1);
+        } else if (cleanStr.startsWith("\r\n")) {
+          cleanStr = cleanStr.slice(2);
+        }
+        if (cleanStr.endsWith("\n")) {
+          cleanStr = cleanStr.slice(0, -1);
+        }
+        if (cleanStr.endsWith("\r")) {
+          cleanStr = cleanStr.slice(0, -1);
+        }
+        if (cleanStr.startsWith('"') && cleanStr.endsWith('"') || cleanStr.startsWith("'") && cleanStr.endsWith("'")) {
+          cleanStr = cleanStr.slice(1, -1);
+        }
+        return { value: cleanStr, nextLineIndex };
+      }
+    }
   }
-  return trimmed;
+  return { value: parsePrimitiveValue(valStr), nextLineIndex };
 }
 function stringifyPrimitiveValue(val) {
   if (val === null) return "null";
   if (typeof val === "boolean") return val ? "true" : "false";
   if (typeof val === "number") return String(val);
   const str = String(val);
-  const needsQuotes = str.trim() !== str || str.includes(":") || str === "true" || str === "false" || str === "null" || !isNaN(Number(str)) && str !== "";
+  if (str.includes("\n")) {
+    let maxConsecutive = 0;
+    let match;
+    BACKTICK_REGEX.lastIndex = 0;
+    while ((match = BACKTICK_REGEX.exec(str)) !== null) {
+      if (match[0].length > maxConsecutive) {
+        maxConsecutive = match[0].length;
+      }
+    }
+    const wrapCount = maxConsecutive + 1;
+    const wrapSeq = "`".repeat(wrapCount);
+    return `${wrapSeq}
+${str}
+${wrapSeq}`;
+  }
+  if (str.includes("`")) {
+    let maxConsecutive = 0;
+    let match;
+    BACKTICK_REGEX.lastIndex = 0;
+    while ((match = BACKTICK_REGEX.exec(str)) !== null) {
+      if (match[0].length > maxConsecutive) {
+        maxConsecutive = match[0].length;
+      }
+    }
+    const wrapCount = maxConsecutive + 1;
+    const wrapSeq = "`".repeat(wrapCount);
+    return `${wrapSeq}${str}${wrapSeq}`;
+  }
+  const needsQuotes = str.trim() !== str || str.includes(":") || str === "true" || str === "false" || str === "null" || NUMBER_REGEX.test(str) && str !== "";
   if (needsQuotes) {
-    return `"${str.replace(/"/g, '\\"')}"`;
+    return `"${str.replace(DOUBLE_QUOTE_REGEX, '\\"')}"`;
   }
   return str;
 }
-function parse(text) {
-  return parseWithTrace(text).data;
+function parse(text, options) {
+  return parseWithTrace(text, options).data;
+}
+function fastParseWithTrace(text) {
+  const startTime = typeof performance !== "undefined" ? performance.now() : Date.now();
+  const lines = text.split(/\r?\n/);
+  let root = {};
+  let rootConvertedToArray = false;
+  const stack = [];
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i];
+    const len = rawLine.length;
+    let startIdx = 0;
+    while (startIdx < len) {
+      const code = rawLine.charCodeAt(startIdx);
+      if (code === 32 || code === 9 || code === 13) {
+        startIdx++;
+      } else {
+        break;
+      }
+    }
+    if (startIdx === len) {
+      continue;
+    }
+    const firstChar = rawLine.charCodeAt(startIdx);
+    if (firstChar === 60 && rawLine.startsWith("<!--", startIdx)) {
+      continue;
+    }
+    let endIdx = len - 1;
+    while (endIdx > startIdx) {
+      const code = rawLine.charCodeAt(endIdx);
+      if (code === 32 || code === 9 || code === 13) {
+        endIdx--;
+      } else {
+        break;
+      }
+    }
+    const trimmedLen = endIdx - startIdx + 1;
+    if (trimmedLen === 2 && rawLine.charCodeAt(startIdx) === 91 && rawLine.charCodeAt(startIdx + 1) === 93) {
+      let isRootEmpty = false;
+      if (Array.isArray(root)) {
+        isRootEmpty = root.length === 0;
+      } else {
+        let hasKeys = false;
+        for (const _ in root) {
+          hasKeys = true;
+          break;
+        }
+        isRootEmpty = !hasKeys;
+      }
+      if (stack.length === 0 && !rootConvertedToArray && isRootEmpty) {
+        root = [];
+        rootConvertedToArray = true;
+        continue;
+      }
+    }
+    if (firstChar === 35) {
+      let hashCount = 0;
+      while (startIdx + hashCount <= endIdx && rawLine.charCodeAt(startIdx + hashCount) === 35) {
+        hashCount++;
+      }
+      let hStart = startIdx + hashCount;
+      while (hStart <= endIdx) {
+        const code = rawLine.charCodeAt(hStart);
+        if (code === 32 || code === 9) {
+          hStart++;
+        } else {
+          break;
+        }
+      }
+      let actualHeadingName = "";
+      let isExplicitArray = false;
+      if (hStart <= endIdx) {
+        if (endIdx - hStart >= 1 && rawLine.charCodeAt(endIdx - 1) === 91 && rawLine.charCodeAt(endIdx) === 93) {
+          isExplicitArray = true;
+          let hEnd = endIdx - 2;
+          while (hEnd >= hStart) {
+            const code = rawLine.charCodeAt(hEnd);
+            if (code === 32 || code === 9) {
+              hEnd--;
+            } else {
+              break;
+            }
+          }
+          actualHeadingName = hStart <= hEnd ? rawLine.slice(hStart, hEnd + 1) : "";
+        } else {
+          actualHeadingName = rawLine.slice(hStart, endIdx + 1);
+        }
+      }
+      while (stack.length > 0 && stack[stack.length - 1].level >= hashCount) {
+        stack.pop();
+      }
+      let activeParent = root;
+      let activeParentItem = null;
+      if (stack.length > 0) {
+        activeParentItem = stack[stack.length - 1];
+        activeParent = activeParentItem.value;
+      }
+      if (!actualHeadingName) {
+        if (activeParentItem && activeParentItem.isExplicitArray || Array.isArray(activeParent)) {
+          actualHeadingName = "";
+        } else {
+          continue;
+        }
+      }
+      const newNode = isExplicitArray ? [] : {};
+      if (activeParentItem && activeParentItem.isExplicitArray) {
+        activeParent.push(newNode);
+      } else if (Array.isArray(activeParent)) {
+        if (actualHeadingName === "") {
+          activeParent.push(newNode);
+        } else {
+          activeParent.push({ [actualHeadingName]: newNode });
+        }
+      } else {
+        activeParent[actualHeadingName] = newNode;
+      }
+      stack.push({
+        level: hashCount,
+        key: actualHeadingName,
+        parent: activeParent,
+        value: newNode,
+        type: isExplicitArray ? "array" : "object",
+        isExplicitArray
+      });
+      continue;
+    }
+    if (firstChar === 42 || firstChar === 45 || firstChar === 43) {
+      let bulletValIdx = startIdx + 1;
+      while (bulletValIdx <= endIdx) {
+        const code = rawLine.charCodeAt(bulletValIdx);
+        if (code === 32 || code === 9) {
+          bulletValIdx++;
+        } else {
+          break;
+        }
+      }
+      const bulletValStr = bulletValIdx <= endIdx ? rawLine.slice(bulletValIdx, endIdx + 1) : "";
+      let value;
+      if (bulletValStr.charCodeAt(0) === 96) {
+        const multiline = parseValueWithMultiline(bulletValStr, lines, i);
+        value = multiline.value;
+        i = multiline.nextLineIndex;
+      } else {
+        value = parsePrimitiveValue(bulletValStr);
+      }
+      if (stack.length === 0) {
+        if (!root._items) {
+          root._items = [];
+        }
+        root._items.push(value);
+        continue;
+      }
+      const activeItem = stack[stack.length - 1];
+      if (activeItem.type !== "array") {
+        let hasKeys = false;
+        for (const k in activeItem.value) {
+          if (Object.prototype.hasOwnProperty.call(activeItem.value, k)) {
+            hasKeys = true;
+            break;
+          }
+        }
+        if (!hasKeys) {
+          const parent = activeItem.parent;
+          const key = activeItem.key;
+          activeItem.type = "array";
+          activeItem.value = [];
+          if (Array.isArray(parent)) {
+            parent[parent.length - 1] = { [key]: activeItem.value };
+          } else {
+            parent[key] = activeItem.value;
+          }
+          activeItem.value.push(value);
+        } else {
+          if (!activeItem.value._items) {
+            activeItem.value._items = [];
+          }
+          activeItem.value._items.push(value);
+        }
+      } else {
+        activeItem.value.push(value);
+      }
+      continue;
+    }
+    const colonIndex = findColonIndex(rawLine, startIdx);
+    if (colonIndex !== -1 && colonIndex <= endIdx) {
+      let kEnd = colonIndex - 1;
+      while (kEnd >= startIdx) {
+        const code = rawLine.charCodeAt(kEnd);
+        if (code === 32 || code === 9) {
+          kEnd--;
+        } else {
+          break;
+        }
+      }
+      const key = startIdx <= kEnd ? rawLine.slice(startIdx, kEnd + 1) : "";
+      let vStart = colonIndex + 1;
+      while (vStart <= endIdx) {
+        const code = rawLine.charCodeAt(vStart);
+        if (code === 32 || code === 9) {
+          vStart++;
+        } else {
+          break;
+        }
+      }
+      const valStr = vStart <= endIdx ? rawLine.slice(vStart, endIdx + 1) : "";
+      let parsedVal;
+      if (valStr.charCodeAt(0) === 96) {
+        const multiline = parseValueWithMultiline(valStr, lines, i);
+        parsedVal = multiline.value;
+        i = multiline.nextLineIndex;
+      } else {
+        parsedVal = parsePrimitiveValue(valStr);
+      }
+      if (stack.length === 0) {
+        root[key] = parsedVal;
+        continue;
+      }
+      const activeItem = stack[stack.length - 1];
+      if (activeItem.type === "array") {
+        continue;
+      }
+      activeItem.value[key] = parsedVal;
+      continue;
+    }
+  }
+  const duration = (typeof performance !== "undefined" ? performance.now() : Date.now()) - startTime;
+  return {
+    data: root,
+    trace: [],
+    stats: {
+      parseTimeMs: duration,
+      linesProcessed: lines.length,
+      charCount: text.length,
+      estimatedTokens: Math.ceil(text.length / 3.8),
+      jsonCharCount: 0,
+      jsonEstimatedTokens: 0,
+      tokenSavingsPercent: 0
+    }
+  };
 }
-function parseWithTrace(text) {
+function parseWithTrace(text, options) {
+  if (options?.noTrace) {
+    return fastParseWithTrace(text);
+  }
   const startTime = typeof performance !== "undefined" ? performance.now() : Date.now();
   const lines = text.split(/\r?\n/);
   const trace = [];
-  const root = {};
+  const noTrace = options?.noTrace ?? false;
+  let root = {};
+  let rootConvertedToArray = false;
   const stack = [];
-  const getStackNames = () => stack.map((s) => `${"#".repeat(s.level)} ${s.key}`);
+  const getStackNames = () => {
+    if (noTrace) return [];
+    return stack.map((s) => `${"#".repeat(s.level)} ${s.key}`);
+  };
   for (let i = 0; i < lines.length; i++) {
     const rawLine = lines[i];
-    const line = rawLine.trim();
     const lineNumber = i + 1;
-    if (!line || line.startsWith("<!--")) {
-      trace.push({
-        lineNumber,
-        lineText: rawLine,
-        action: "Skipped empty line or comment",
-        stackDepth: stack.length,
-        currentStack: getStackNames(),
-        status: "info"
-      });
+    let startIdx = 0;
+    const len = rawLine.length;
+    while (startIdx < len) {
+      const code = rawLine.charCodeAt(startIdx);
+      if (code === 32 || code === 9 || code === 13) {
+        startIdx++;
+      } else {
+        break;
+      }
+    }
+    if (startIdx === len) {
+      if (!noTrace) {
+        trace.push({
+          lineNumber,
+          lineText: rawLine,
+          action: "Skipped empty line or comment",
+          stackDepth: stack.length,
+          currentStack: getStackNames(),
+          status: "info"
+        });
+      }
+      continue;
+    }
+    const firstChar = rawLine.charCodeAt(startIdx);
+    if (firstChar === 60 && rawLine.startsWith("<!--", startIdx)) {
+      if (!noTrace) {
+        trace.push({
+          lineNumber,
+          lineText: rawLine,
+          action: "Skipped empty line or comment",
+          stackDepth: stack.length,
+          currentStack: getStackNames(),
+          status: "info"
+        });
+      }
       continue;
     }
-    if (line.startsWith("#")) {
-      const headingMatch = line.match(/^(#+)\s*(.*)$/);
-      if (headingMatch) {
-        const hashCount = headingMatch[1].length;
-        const headingName = headingMatch[2].trim();
-        if (!headingName) {
+    let endIdx = len - 1;
+    while (endIdx > startIdx) {
+      const code = rawLine.charCodeAt(endIdx);
+      if (code === 32 || code === 9 || code === 13) {
+        endIdx--;
+      } else {
+        break;
+      }
+    }
+    const trimmedLen = endIdx - startIdx + 1;
+    if (trimmedLen === 2 && rawLine.charCodeAt(startIdx) === 91 && rawLine.charCodeAt(startIdx + 1) === 93) {
+      let isRootEmpty = false;
+      if (Array.isArray(root)) {
+        isRootEmpty = root.length === 0;
+      } else {
+        let hasKeys = false;
+        for (const _ in root) {
+          hasKeys = true;
+          break;
+        }
+        isRootEmpty = !hasKeys;
+      }
+      if (stack.length === 0 && !rootConvertedToArray && isRootEmpty) {
+        root = [];
+        rootConvertedToArray = true;
+        if (!noTrace) {
           trace.push({
             lineNumber,
             lineText: rawLine,
-            action: `Warning: Empty heading name at level ${hashCount}`,
+            action: 'Converted root container to an Array via top-level "[]"',
             stackDepth: stack.length,
             currentStack: getStackNames(),
-            status: "warning"
+            status: "success"
           });
-          continue;
         }
-        while (stack.length > 0 && stack[stack.length - 1].level >= hashCount) {
-          stack.pop();
+        continue;
+      }
+    }
+    if (firstChar === 35) {
+      let hashCount = 0;
+      while (startIdx + hashCount <= endIdx && rawLine.charCodeAt(startIdx + hashCount) === 35) {
+        hashCount++;
+      }
+      let hStart = startIdx + hashCount;
+      while (hStart <= endIdx) {
+        const code = rawLine.charCodeAt(hStart);
+        if (code === 32 || code === 9) {
+          hStart++;
+        } else {
+          break;
         }
-        let activeParent = root;
-        if (stack.length > 0) {
-          const topItem = stack[stack.length - 1];
-          activeParent = topItem.value;
+      }
+      const headingName = hStart <= endIdx ? rawLine.slice(hStart, endIdx + 1) : "";
+      while (stack.length > 0 && stack[stack.length - 1].level >= hashCount) {
+        stack.pop();
+      }
+      let activeParent = root;
+      let activeParentItem = null;
+      if (stack.length > 0) {
+        activeParentItem = stack[stack.length - 1];
+        activeParent = activeParentItem.value;
+      }
+      let actualHeadingName = headingName;
+      let isExplicitArray = false;
+      if (headingName.endsWith("[]")) {
+        actualHeadingName = headingName.slice(0, -2).trim();
+        isExplicitArray = true;
+      }
+      if (!actualHeadingName) {
+        if (activeParentItem && activeParentItem.isExplicitArray || Array.isArray(activeParent)) {
+          actualHeadingName = "";
+        } else {
+          if (!noTrace) {
+            trace.push({
+              lineNumber,
+              lineText: rawLine,
+              action: `Warning: Empty heading name at level ${hashCount}`,
+              stackDepth: stack.length,
+              currentStack: getStackNames(),
+              status: "warning"
+            });
+          }
+          continue;
         }
-        const newNode = {};
-        if (Array.isArray(activeParent)) {
-          activeParent.push({ [headingName]: newNode });
+      }
+      const newNode = isExplicitArray ? [] : {};
+      if (activeParentItem && activeParentItem.isExplicitArray) {
+        activeParent.push(newNode);
+        if (!noTrace) {
           trace.push({
             lineNumber,
             lineText: rawLine,
-            action: `Created heading "${headingName}" at level ${hashCount} and pushed inside parent Array`,
+            action: `Pushed new item into explicit array "${activeParentItem.key}" via heading "${actualHeadingName}"`,
             stackDepth: stack.length,
             currentStack: getStackNames(),
             status: "success"
           });
+        }
+      } else if (Array.isArray(activeParent)) {
+        if (actualHeadingName === "") {
+          activeParent.push(newNode);
+          if (!noTrace) {
+            trace.push({
+              lineNumber,
+              lineText: rawLine,
+              action: `Pushed anonymous object directly into parent Array`,
+              stackDepth: stack.length,
+              currentStack: getStackNames(),
+              status: "success"
+            });
+          }
         } else {
-          activeParent[headingName] = newNode;
+          activeParent.push({ [actualHeadingName]: newNode });
+          if (!noTrace) {
+            trace.push({
+              lineNumber,
+              lineText: rawLine,
+              action: `Created heading "${actualHeadingName}" at level ${hashCount} and pushed inside parent Array`,
+              stackDepth: stack.length,
+              currentStack: getStackNames(),
+              status: "success"
+            });
+          }
+        }
+      } else {
+        activeParent[actualHeadingName] = newNode;
+        if (!noTrace) {
           trace.push({
             lineNumber,
             lineText: rawLine,
-            action: `Created heading "${headingName}" at level ${hashCount} in parent Object`,
+            action: `Created heading "${actualHeadingName}" at level ${hashCount} in parent Object${isExplicitArray ? " as Array" : ""}`,
             stackDepth: stack.length,
             currentStack: getStackNames(),
             status: "success"
           });
         }
-        stack.push({
-          level: hashCount,
-          key: headingName,
-          parent: activeParent,
-          value: newNode,
-          type: "object"
-        });
-        continue;
       }
+      stack.push({
+        level: hashCount,
+        key: actualHeadingName,
+        parent: activeParent,
+        value: newNode,
+        type: isExplicitArray ? "array" : "object",
+        isExplicitArray
+      });
+      continue;
     }
-    const bulletMatch = line.match(/^([\*\-\+])\s*(.*)$/);
-    if (bulletMatch) {
-      const bulletValStr = bulletMatch[2].trim();
-      const value = parsePrimitiveValue(bulletValStr);
+    if (firstChar === 42 || firstChar === 45 || firstChar === 43) {
+      let bulletValIdx = startIdx + 1;
+      while (bulletValIdx <= endIdx) {
+        const code = rawLine.charCodeAt(bulletValIdx);
+        if (code === 32 || code === 9) {
+          bulletValIdx++;
+        } else {
+          break;
+        }
+      }
+      const bulletValStr = bulletValIdx <= endIdx ? rawLine.slice(bulletValIdx, endIdx + 1) : "";
+      const { value, nextLineIndex } = parseValueWithMultiline(bulletValStr, lines, i);
+      i = nextLineIndex;
       if (stack.length === 0) {
         if (!root._items) {
           root._items = [];
         }
         root._items.push(value);
-        trace.push({
-          lineNumber,
-          lineText: rawLine,
-          action: `No active heading. Pushed bullet item to root implicit list "_items"`,
-          stackDepth: stack.length,
-          currentStack: getStackNames(),
-          status: "info"
-        });
+        if (!noTrace) {
+          trace.push({
+            lineNumber,
+            lineText: rawLine,
+            action: `No active heading. Pushed bullet item to root implicit list "_items"`,
+            stackDepth: stack.length,
+            currentStack: getStackNames(),
+            status: "info"
+          });
+        }
         continue;
       }
       const activeItem = stack[stack.length - 1];
       if (activeItem.type !== "array") {
-        const parent = activeItem.parent;
-        const key = activeItem.key;
-        activeItem.type = "array";
-        activeItem.value = [];
-        if (Array.isArray(parent)) {
-          parent[parent.length - 1] = { [key]: activeItem.value };
+        let hasKeys = false;
+        for (const k in activeItem.value) {
+          if (Object.prototype.hasOwnProperty.call(activeItem.value, k)) {
+            hasKeys = true;
+            break;
+          }
+        }
+        if (!hasKeys) {
+          const parent = activeItem.parent;
+          const key = activeItem.key;
+          activeItem.type = "array";
+          activeItem.value = [];
+          if (Array.isArray(parent)) {
+            parent[parent.length - 1] = { [key]: activeItem.value };
+          } else {
+            parent[key] = activeItem.value;
+          }
+          if (!noTrace) {
+            trace.push({
+              lineNumber,
+              lineText: rawLine,
+              action: `Array trigger: Converted heading "${key}" to an Array because it was an empty Object`,
+              stackDepth: stack.length,
+              currentStack: getStackNames(),
+              status: "info"
+            });
+          }
+          activeItem.value.push(value);
+          if (!noTrace) {
+            trace.push({
+              lineNumber,
+              lineText: rawLine,
+              action: `Pushed item "${value}" (type: ${typeof value}) into array "${activeItem.key}"`,
+              stackDepth: stack.length,
+              currentStack: getStackNames(),
+              status: "success"
+            });
+          }
         } else {
-          parent[key] = activeItem.value;
+          if (!activeItem.value._items) {
+            activeItem.value._items = [];
+          }
+          activeItem.value._items.push(value);
+          if (!noTrace) {
+            trace.push({
+              lineNumber,
+              lineText: rawLine,
+              action: `Pushed bullet item "${value}" to implicit list "_items" inside non-empty Object under heading "${activeItem.key}"`,
+              stackDepth: stack.length,
+              currentStack: getStackNames(),
+              status: "info"
+            });
+          }
+        }
+      } else {
+        activeItem.value.push(value);
+        if (!noTrace) {
+          trace.push({
+            lineNumber,
+            lineText: rawLine,
+            action: `Pushed item "${value}" (type: ${typeof value}) into array "${activeItem.key}"`,
+            stackDepth: stack.length,
+            currentStack: getStackNames(),
+            status: "success"
+          });
         }
-        trace.push({
-          lineNumber,
-          lineText: rawLine,
-          action: `Array trigger: Converted heading "${key}" to an Array`,
-          stackDepth: stack.length,
-          currentStack: getStackNames(),
-          status: "info"
-        });
       }
-      activeItem.value.push(value);
-      trace.push({
-        lineNumber,
-        lineText: rawLine,
-        action: `Pushed item "${value}" (type: ${typeof value}) into array "${activeItem.key}"`,
-        stackDepth: stack.length,
-        currentStack: getStackNames(),
-        status: "success"
-      });
       continue;
     }
-    if (line.includes(":")) {
-      const colonIndex = line.indexOf(":");
-      const key = line.slice(0, colonIndex).trim();
-      const valStr = line.slice(colonIndex + 1).trim();
-      const parsedVal = parsePrimitiveValue(valStr);
+    const colonIndex = findColonIndex(rawLine, startIdx);
+    if (colonIndex !== -1 && colonIndex <= endIdx) {
+      let kEnd = colonIndex - 1;
+      while (kEnd >= startIdx) {
+        const code = rawLine.charCodeAt(kEnd);
+        if (code === 32 || code === 9) {
+          kEnd--;
+        } else {
+          break;
+        }
+      }
+      const key = startIdx <= kEnd ? rawLine.slice(startIdx, kEnd + 1) : "";
+      let vStart = colonIndex + 1;
+      while (vStart <= endIdx) {
+        const code = rawLine.charCodeAt(vStart);
+        if (code === 32 || code === 9) {
+          vStart++;
+        } else {
+          break;
+        }
+      }
+      const valStr = vStart <= endIdx ? rawLine.slice(vStart, endIdx + 1) : "";
+      const { value: parsedVal, nextLineIndex } = parseValueWithMultiline(valStr, lines, i);
+      i = nextLineIndex;
       if (stack.length === 0) {
         root[key] = parsedVal;
-        trace.push({
-          lineNumber,
-          lineText: rawLine,
-          action: `Set root key "${key}" to "${parsedVal}"`,
-          stackDepth: stack.length,
-          currentStack: getStackNames(),
-          status: "success"
-        });
+        if (!noTrace) {
+          trace.push({
+            lineNumber,
+            lineText: rawLine,
+            action: `Set root key "${key}" to "${parsedVal}"`,
+            stackDepth: stack.length,
+            currentStack: getStackNames(),
+            status: "success"
+          });
+        }
         continue;
       }
       const activeItem = stack[stack.length - 1];
       if (activeItem.type === "array") {
+        if (!noTrace) {
+          trace.push({
+            lineNumber,
+            lineText: rawLine,
+            action: `Error: Key-value "${key}" encountered inside array "${activeItem.key}"`,
+            stackDepth: stack.length,
+            currentStack: getStackNames(),
+            status: "error"
+          });
+        }
+        continue;
+      }
+      activeItem.value[key] = parsedVal;
+      if (!noTrace) {
         trace.push({
           lineNumber,
           lineText: rawLine,
-          action: `Error: Key-value "${key}" encountered inside array "${activeItem.key}"`,
+          action: `Set key "${key}" to "${parsedVal}" in active heading "${activeItem.key}"`,
           stackDepth: stack.length,
           currentStack: getStackNames(),
-          status: "error"
+          status: "success"
         });
-        continue;
       }
-      activeItem.value[key] = parsedVal;
+      continue;
+    }
+    if (!noTrace) {
       trace.push({
         lineNumber,
         lineText: rawLine,
-        action: `Set key "${key}" to "${parsedVal}" in active heading "${activeItem.key}"`,
+        action: `Unparsed content: Line skipped or treated as plain text`,
         stackDepth: stack.length,
         currentStack: getStackNames(),
-        status: "success"
+        status: "warning"
       });
-      continue;
     }
-    trace.push({
-      lineNumber,
-      lineText: rawLine,
-      action: `Unparsed content: Line skipped or treated as plain text`,
-      stackDepth: stack.length,
-      currentStack: getStackNames(),
-      status: "warning"
-    });
   }
   const endTime = typeof performance !== "undefined" ? performance.now() : Date.now();
   const parseTimeMs = Number((endTime - startTime).toFixed(3));
   const charCount = text.length;
   const estimatedTokens = Math.ceil(charCount / 4.1);
-  const jsonString = JSON.stringify(root, null, 2);
-  const jsonCharCount = jsonString.length;
-  const jsonEstimatedTokens = Math.ceil(jsonCharCount / 3.7);
-  const tokenSavingsPercent = Number(((jsonEstimatedTokens - estimatedTokens) / jsonEstimatedTokens * 100).toFixed(1));
+  let jsonCharCount = 0;
+  let jsonEstimatedTokens = 0;
+  let tokenSavingsPercent = 0;
+  if (!noTrace) {
+    const jsonString = JSON.stringify(root, null, 2);
+    jsonCharCount = jsonString.length;
+    jsonEstimatedTokens = Math.ceil(jsonCharCount / 3.7);
+    tokenSavingsPercent = Number(((jsonEstimatedTokens - estimatedTokens) / jsonEstimatedTokens * 100).toFixed(1));
+  }
   return {
     data: root,
     trace,
@@ -225,14 +831,35 @@ function parseWithTrace(text) {
     }
   };
 }
-function stringify(obj, level = 0) {
+function stringify(obj, level = 0, parentKey) {
   if (obj === null || obj === void 0) return "";
   let output = "";
   const hashes = (lvl) => "#".repeat(lvl);
   if (Array.isArray(obj)) {
+    if (level === 0) {
+      output += "[]\n\n";
+    }
+    let itemName = "Item";
+    if (parentKey) {
+      if (parentKey.endsWith("ies")) {
+        itemName = parentKey.slice(0, -3) + "y";
+      } else if (parentKey.endsWith("s") && !parentKey.endsWith("ss")) {
+        itemName = parentKey.slice(0, -1);
+      } else {
+        itemName = parentKey;
+      }
+      itemName = itemName.charAt(0).toUpperCase() + itemName.slice(1);
+    }
     for (const item of obj) {
       if (typeof item === "object" && item !== null) {
-        output += stringify(item, level);
+        const nextLevel = level + 1;
+        output += `${hashes(nextLevel)} ${itemName}
+`;
+        const nestedString = stringify(item, nextLevel);
+        if (nestedString) {
+          output += nestedString;
+        }
+        output += "\n";
       } else {
         output += `* ${stringifyPrimitiveValue(item)}
 `;
@@ -251,10 +878,12 @@ function stringify(obj, level = 0) {
     }
     for (const key of complex) {
       const nextLevel = level + 1;
-      output += `${hashes(nextLevel)} ${key}
-`;
       const val = obj[key];
-      const nestedString = stringify(val, nextLevel);
+      const isArrayOfObjects = Array.isArray(val) && val.some((item) => typeof item === "object" && item !== null);
+      const headingNameSuffix = isArrayOfObjects ? "[]" : "";
+      output += `${hashes(nextLevel)} ${key}${headingNameSuffix}
+`;
+      const nestedString = stringify(val, nextLevel, key);
       if (nestedString) {
         output += nestedString;
       }
@@ -264,11 +893,15 @@ function stringify(obj, level = 0) {
   return output.trim() + "\n";
 }
 export {
+  fastParseWithTrace,
   parse,
   parse as parseMSON,
+  parseWithTrace as parseMaSON,
   parsePrimitiveValue,
+  parseValueWithMultiline,
   parseWithTrace,
   stringify,
   stringify as stringifyMSON,
+  stringify as stringifyMaSON,
   stringifyPrimitiveValue
 };