weml-monaco 0.4.2 → 0.4.4

package/CHANGELOG.md

@@ -8,6 +8,25 @@ This package mirrors the language logic of the VS Code extension; entries below
 track the port catching up with the VS Code provider changes (see the root
 `CHANGELOG.md` for the extension).
 
+## [0.4.4] — 2026-09-07
+
+Synced with VS Code extension `0.7.12`.
+
+### Fixed
+- Preserve surrounding word separators in nested inline wrappers containing
+  sentence elements when applying canonical formatting.
+
+## [0.4.3] — 2026-09-07
+
+Synced with VS Code extension `0.7.11`.
+
+### Changed
+- Updated the shared V2 normalizer: remove comments and empty text wrappers
+  without IDs, preserve word separators, normalize Unicode attribute separators
+  and trim attribute values.
+- Improved void-tag scanning and whitespace cleanup between blocks, while
+  retaining browser and HTML-parser compatibility.
+
 ## [0.4.2] — 2026-08-30
 
 Synced with VS Code extension `0.7.9`.

package/dist/index.cjs

@@ -6125,7 +6125,13 @@ var require_wemlContentNormalizeV2 = __commonJS({
       "wbr",
       "param"
     ]);
-    var VOID_TAG_RE = /<[ \t\n\f\r]*(area|base|br|col|embed|hr|img|input|link|meta|source|track|wbr|param)(?=[ \t\n\f\r/>])((?:[^<>"']|"[^"]*"|'[^']*')*?)>/gi;
+    var EMPTY_TEXT_WRAPPERS = /* @__PURE__ */ new Set([
+      "w-format",
+      "w-lang",
+      "w-color",
+      "w-non-egw",
+      "w-sent"
+    ]);
     var ENTITY_RE2 = /&(#[xX][0-9a-fA-F]+|#[0-9]+|[a-zA-Z][a-zA-Z0-9]*);?/g;
     var PH_OPEN = "\uE000";
     var PH_CLOSE = "\uE001";
@@ -6166,6 +6172,7 @@ var require_wemlContentNormalizeV2 = __commonJS({
     function formatWeml(input) {
       const { html, entities: entities2, marker } = protectEntities(input);
       const doc = parse2(normalizeVoidTagSyntax(html));
+      removeEmptyWrappers(doc);
       const title = doc.querySelector("head title");
       if (title) processInlineContent(title, true);
       const body = doc.querySelector("body");
@@ -6211,47 +6218,135 @@ var require_wemlContentNormalizeV2 = __commonJS({
     }
     function normalizeVoidTagSyntax(input) {
       function slashBelongsToUnquotedValue(attrs) {
-        let index = 0;
-        const whitespace = /* @__PURE__ */ new Set([" ", "	", "\n", "\f", "\r"]);
-        while (index < attrs.length) {
-          while (index < attrs.length && whitespace.has(attrs[index])) index += 1;
-          if (index >= attrs.length || attrs[index] === "/") return false;
-          while (index < attrs.length && !whitespace.has(attrs[index]) && !["=", "/"].includes(attrs[index])) index += 1;
-          while (index < attrs.length && whitespace.has(attrs[index])) index += 1;
-          if (index >= attrs.length || attrs[index] !== "=") continue;
-          index += 1;
-          while (index < attrs.length && whitespace.has(attrs[index])) index += 1;
-          if (index >= attrs.length) return false;
-          if (attrs[index] === '"' || attrs[index] === "'") {
-            const quote = attrs[index];
-            index += 1;
-            while (index < attrs.length && attrs[index] !== quote) index += 1;
-            if (index < attrs.length) index += 1;
+        let index2 = 0;
+        const whitespace = /* @__PURE__ */ new Set([" ", "	", "\n", "\f", "\r", "\v"]);
+        while (index2 < attrs.length) {
+          while (index2 < attrs.length && whitespace.has(attrs[index2])) index2 += 1;
+          if (index2 >= attrs.length || attrs[index2] === "/") return false;
+          while (index2 < attrs.length && !whitespace.has(attrs[index2]) && !["=", "/"].includes(attrs[index2])) index2 += 1;
+          while (index2 < attrs.length && whitespace.has(attrs[index2])) index2 += 1;
+          if (index2 >= attrs.length || attrs[index2] !== "=") continue;
+          index2 += 1;
+          while (index2 < attrs.length && whitespace.has(attrs[index2])) index2 += 1;
+          if (index2 >= attrs.length) return false;
+          if (attrs[index2] === '"' || attrs[index2] === "'") {
+            const quote = attrs[index2];
+            index2 += 1;
+            while (index2 < attrs.length && attrs[index2] !== quote) index2 += 1;
+            if (index2 < attrs.length) index2 += 1;
             continue;
           }
-          const valueStart = index;
-          while (index < attrs.length && !whitespace.has(attrs[index])) index += 1;
-          if (index === attrs.length) {
+          const valueStart = index2;
+          while (index2 < attrs.length && !whitespace.has(attrs[index2])) index2 += 1;
+          if (index2 === attrs.length) {
             return valueStart < attrs.length && attrs.endsWith("/");
           }
         }
         return false;
       }
-      return input.replace(VOID_TAG_RE, (_, name, rawAttrs) => {
-        let attrs = trimRawEndWhitespace(rawAttrs);
-        if (attrs.endsWith("/") && !slashBelongsToUnquotedValue(attrs)) {
-          attrs = trimRawEndWhitespace(attrs.slice(0, -1));
+      const result = [];
+      let index = 0;
+      while (index < input.length) {
+        if (input[index] !== "<") {
+          result.push(input[index++]);
+          continue;
         }
-        return `<${name.toLowerCase()}${attrs} />`;
-      });
+        const start = index;
+        if (input.startsWith("<!--", index) || input.startsWith("<?", index)) {
+          const delimiter = input.startsWith("<!--", index) ? "-->" : "?>";
+          let end2 = input.indexOf(delimiter, index + 2);
+          end2 = end2 < 0 ? input.length : end2 + delimiter.length;
+          result.push(input.slice(start, end2));
+          index = end2;
+          continue;
+        }
+        const { end } = findTagEnd(input, index + 1);
+        if (end < 0) {
+          result.push(input.slice(index));
+          break;
+        }
+        let cursor = index + 1;
+        if (input[cursor] === "!") {
+          result.push(input.slice(start, end + 1));
+          index = end + 1;
+          continue;
+        }
+        const closing = input[cursor] === "/";
+        if (closing) cursor++;
+        if (cursor >= end || !isNameStart(input[cursor])) {
+          result.push(input[index++]);
+          continue;
+        }
+        const nameStart = cursor++;
+        while (cursor < end && isNameChar(input[cursor])) cursor++;
+        const name = input.slice(nameStart, cursor);
+        const attributes = [];
+        let quote = null;
+        let inSpace = false;
+        for (let offset = cursor; offset < end; offset++) {
+          const character = input[offset];
+          if (quote !== null) {
+            attributes.push(character);
+            if (character === quote) quote = null;
+            continue;
+          }
+          if (isSourceSpace(character)) {
+            if (!inSpace) attributes.push(" ");
+            inSpace = true;
+          } else {
+            inSpace = false;
+            attributes.push(character);
+            if (character === '"' || character === "'") quote = character;
+          }
+        }
+        let attrs = attributes.join("").replace(/ +$/, "");
+        if (!closing && VOID_HTML_ELEMENTS.has(name.toLowerCase())) {
+          if (attrs.endsWith("/") && !slashBelongsToUnquotedValue(attrs)) {
+            attrs = attrs.slice(0, -1).replace(/ +$/, "");
+          }
+          result.push(`<${name.toLowerCase()}${attrs} />`);
+        } else {
+          result.push(input.slice(start, cursor), attrs, ">");
+        }
+        index = end + 1;
+      }
+      return result.join("");
     }
-    function processBlockElement(node) {
+    function removeEmptyWrappers(node) {
       for (const child of [...node.childNodes]) {
-        if (child.nodeType !== 3) continue;
-        const normalized = trimWhitespace(child.rawText);
-        if (normalized) child.rawText = normalized;
-        else child.remove();
+        if (child.nodeType === 8) {
+          node.removeChild(child);
+          continue;
+        }
+        if (child.nodeType !== 1) continue;
+        removeEmptyWrappers(child);
+        const hasId = Object.keys(child.rawAttributes).some((name) => name.toLowerCase() === "id");
+        if (EMPTY_TEXT_WRAPPERS.has(child.rawTagName.toLowerCase()) && !hasId && child.childNodes.every((item) => item.nodeType === 3 && isWhitespaceOnly(item.rawText))) {
+          const replacement = new TextNode(child.childNodes.some((item) => item.rawText.length > 0) ? " " : "", node);
+          node.exchangeChild(child, replacement);
+        }
       }
+      let previous = null;
+      for (const child of [...node.childNodes]) {
+        if (child.nodeType === 3) {
+          if (previous !== null) {
+            previous.rawText += child.rawText;
+            node.removeChild(child);
+          } else previous = child;
+        } else previous = null;
+      }
+    }
+    function processBlockElement(node) {
+      node.childNodes = node.childNodes.filter((child) => {
+        if (child.nodeType !== 3) return true;
+        const normalized = trimWhitespace(child.rawText);
+        if (normalized) {
+          child.rawText = normalized;
+          return true;
+        }
+        child.parentNode = null;
+        return false;
+      });
       for (const child of [...node.childNodes]) {
         if (child.nodeType !== 1) continue;
         const name = child.rawTagName.toLowerCase();
@@ -6261,15 +6356,15 @@ var require_wemlContentNormalizeV2 = __commonJS({
       }
     }
     function processInlineContainer(node) {
-      if (hasDirectSentChildren(node)) processSentContainer(node);
+      if (hasDirectSentChildren(node)) processSentContainer(node, true);
       else processInlineContent(node, true);
     }
-    function processSentContainer(node) {
+    function processSentContainer(node, trimEdges) {
       for (const child of [...node.childNodes]) {
         if (child.nodeType !== 1) continue;
         const name = child.rawTagName.toLowerCase();
         if (isInlineTextElement(child)) {
-          if (hasDirectSentChildren(child)) processSentContainer(child);
+          if (hasDirectSentChildren(child)) processSentContainer(child, false);
           else processInlineContent(child, false);
         } else if (BLOCK_ELEMENTS.has(name)) {
           processBlockElement(child);
@@ -6293,7 +6388,7 @@ var require_wemlContentNormalizeV2 = __commonJS({
           if (next && next.nodeType === 3) next.rawText = trimStartWhitespace(next.rawText);
         }
       }
-      trimContainerEdges(node);
+      if (trimEdges) trimContainerEdges(node);
       for (const child of [...node.childNodes]) {
         if (child.nodeType === 3 && child.rawText === "") child.remove();
       }
@@ -6315,7 +6410,7 @@ var require_wemlContentNormalizeV2 = __commonJS({
         if (child.nodeType !== 1) continue;
         const name = child.rawTagName.toLowerCase();
         if (isInlineTextElement(child)) {
-          if (hasDirectSentChildren(child)) processSentContainer(child);
+          if (hasDirectSentChildren(child)) processSentContainer(child, false);
           else processInlineContent(child, false);
         } else if (BLOCK_ELEMENTS.has(name)) {
           processBlockElement(child);
@@ -6506,7 +6601,7 @@ var require_wemlContentNormalizeV2 = __commonJS({
         }
         canonical.set(
           name,
-          SPACE_SEPARATED_ATTRIBUTES.has(name) ? normalizeTokenList(value, entities2, marker) : value
+          SPACE_SEPARATED_ATTRIBUTES.has(name) ? normalizeTokenList(value, entities2, marker) : trimWhitespace(value)
         );
       }
       return [...canonical.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([name, value]) => ` ${name}="${encodeAttr(String(value))}"`).join("");
@@ -6736,7 +6831,7 @@ var require_wemlContentNormalizeV2 = __commonJS({
       return isNameStart(character) || character >= "0" && character <= "9" || character === "-" || character === "_" || character === ":" || character === ".";
     }
     function isSourceSpace(character) {
-      return character === " " || character === "	" || character === "\n" || character === "\r" || character === "\f" || character === "\v";
+      return isNormalizableWhitespace(character);
     }
     function withoutWhiteSpace(text) {
       return Array.from(text, (character) => WHITE_SPACE.has(character.codePointAt(0)) ? "" : character).join("");
@@ -6767,13 +6862,6 @@ var require_wemlContentNormalizeV2 = __commonJS({
     function trimWhitespace(text) {
       return collapseWhitespace(text).replace(/^ +| +$/g, "");
     }
-    function trimRawEndWhitespace(text) {
-      const characters = Array.from(text);
-      while (characters.length > 0 && isNormalizableWhitespace(characters.at(-1))) {
-        characters.pop();
-      }
-      return characters.join("");
-    }
     function isWhitespaceOnly(text) {
       return Array.from(text).every(isNormalizableWhitespace);
     }
@@ -30842,24 +30930,22 @@ function getCompletionContext(text, offset, nodeStart) {
     switch (token) {
       case TokenType.StartTagOpen:
         if (scanner.getTokenEnd() === offset) {
-          const end = scanNextEnd(scanner, offset, TokenType.StartTag);
-          return { kind: "tag", start: offset - 1, end, includesBracket: true };
+          return { kind: "tag", start: offset - 1, end: offset, includesBracket: true };
         }
         break;
       case TokenType.EndTagOpen:
         if (scanner.getTokenEnd() === offset) {
-          const end = scanNextEnd(scanner, offset, TokenType.EndTag);
-          return { kind: "end-tag", start: offset, end };
+          return { kind: "end-tag", start: offset, end: offset };
         }
         break;
       case TokenType.EndTag:
         if (scanner.getTokenOffset() <= offset && offset <= scanner.getTokenEnd()) {
-          return { kind: "end-tag", start: scanner.getTokenOffset(), end: scanner.getTokenEnd() };
+          return { kind: "end-tag", start: scanner.getTokenOffset(), end: offset };
         }
         break;
       case TokenType.StartTag:
         if (scanner.getTokenOffset() <= offset && offset <= scanner.getTokenEnd()) {
-          return { kind: "tag", start: scanner.getTokenOffset(), end: scanner.getTokenEnd(), includesBracket: false };
+          return { kind: "tag", start: scanner.getTokenOffset(), end: offset, includesBracket: false };
         }
         currentTag = scanner.getTokenText();
         break;
@@ -30897,8 +30983,7 @@ function getCompletionContext(text, offset, nodeStart) {
           switch (scanner.getScannerState()) {
             case ScannerState.AfterOpeningStartTag: {
               const start = scanner.getTokenOffset();
-              const end = scanNextEnd(scanner, offset, TokenType.StartTag);
-              return { kind: "tag", start, end, includesBracket: false };
+              return { kind: "tag", start, end: offset, includesBracket: false };
             }
             case ScannerState.WithinTag:
             case ScannerState.AfterAttributeName: