weml-monaco 0.4.0 → 0.4.3

package/dist/index.mjs

@@ -6111,21 +6111,47 @@ var require_wemlContentNormalizeV2 = __commonJS({
       "a",
       "w-anchor",
       "w-sent",
-      "w-page"
+      "w-page",
+      "w-color"
     ]);
-    var VOID_HTML_ELEMENTS = /* @__PURE__ */ new Set(["meta", "br", "hr", "img", "link"]);
-    var VOID_TAG_RE = /<\s*(meta|br|hr|img|link)\b([^<>]*?)(?:\/\s*)?>/gi;
-    var ENTITY_RE2 = /&(#[xX][0-9a-fA-F]+|#[0-9]+|[a-zA-Z][a-zA-Z0-9]*);/g;
+    var VOID_HTML_ELEMENTS = /* @__PURE__ */ new Set([
+      "area",
+      "base",
+      "br",
+      "col",
+      "embed",
+      "hr",
+      "img",
+      "input",
+      "link",
+      "meta",
+      "source",
+      "track",
+      "wbr",
+      "param"
+    ]);
+    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";
-    var PH_RE = /\uE000([0-9]+)\uE001/g;
-    var VOID_ELEMENTS = /* @__PURE__ */ new Set(["meta", "br", "hr", "img", "link"]);
+    var VOID_ELEMENTS = VOID_HTML_ELEMENTS;
+    var SPACE_SEPARATED_ATTRIBUTES = /* @__PURE__ */ new Set(["class", "headers", "rel", "rev"]);
     var WHITE_SPACE = /* @__PURE__ */ new Set([
       9,
       10,
       11,
       12,
       13,
+      28,
+      29,
+      30,
+      31,
       32,
       133,
       160,
@@ -6145,40 +6171,193 @@ var require_wemlContentNormalizeV2 = __commonJS({
       8233,
       8239,
       8287,
-      12288
+      12288,
+      65279
     ]);
     function formatWeml(input) {
-      const { html, entities: entities2 } = protectEntities(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");
       if (body) processBlockElement(body);
-      return restoreEntities(serializeDocument(doc), entities2);
+      return restoreEntities(serializeDocument(doc, entities2, marker), entities2, marker);
     }
     function protectEntities(input) {
+      let markerLength = 1;
+      let marker = PH_OPEN.repeat(markerLength) + PH_CLOSE;
+      while (input.includes(marker)) {
+        markerLength += 1;
+        marker = PH_OPEN.repeat(markerLength) + PH_CLOSE;
+      }
       const entities2 = [];
       const html = input.replace(ENTITY_RE2, (match) => {
         const index = entities2.length;
         entities2.push(match);
-        return `${PH_OPEN}${index}${PH_CLOSE}`;
+        return `${marker}${index}${marker}`;
       });
-      return { html, entities: entities2 };
-    }
-    function restoreEntities(text, entities2) {
-      return text.replace(PH_RE, (_, index) => entities2[Number(index)]);
+      return { html, entities: entities2, marker };
+    }
+    function restoreEntities(text, entities2, marker) {
+      const result = [];
+      let position = 0;
+      while (position < text.length) {
+        const open = text.indexOf(marker, position);
+        if (open < 0) {
+          result.push(text.slice(position));
+          break;
+        }
+        result.push(text.slice(position, open));
+        const indexStart = open + marker.length;
+        const close = text.indexOf(marker, indexStart);
+        const indexText = close >= 0 ? text.slice(indexStart, close) : "";
+        const entityIndex = Number(indexText);
+        if (close < 0 || !/^[0-9]+$/.test(indexText) || !Number.isSafeInteger(entityIndex) || entityIndex >= entities2.length) {
+          throw new Error("Invalid internal entity placeholder.");
+        }
+        result.push(entities2[entityIndex]);
+        position = close + marker.length;
+      }
+      return result.join("");
     }
     function normalizeVoidTagSyntax(input) {
-      return input.replace(VOID_TAG_RE, (_, name, attrs) => `<${name.toLowerCase()}${attrs.trimEnd()} />`);
+      function slashBelongsToUnquotedValue(attrs) {
+        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 = index2;
+          while (index2 < attrs.length && !whitespace.has(attrs[index2])) index2 += 1;
+          if (index2 === attrs.length) {
+            return valueStart < attrs.length && attrs.endsWith("/");
+          }
+        }
+        return false;
+      }
+      const result = [];
+      let index = 0;
+      while (index < input.length) {
+        if (input[index] !== "<") {
+          result.push(input[index++]);
+          continue;
+        }
+        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 === 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 && child.rawText.trim() === "") child.remove();
+        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();
         if (INLINE_CONTAINERS.has(name)) processInlineContainer(child);
         else if (BLOCK_ELEMENTS.has(name)) processBlockElement(child);
-        else if (INLINE_ELEMENTS.has(name)) processInlineContent(child, true);
+        else if (isInlineTextElement(child)) processInlineContent(child, true);
       }
     }
     function processInlineContainer(node) {
@@ -6189,7 +6368,7 @@ var require_wemlContentNormalizeV2 = __commonJS({
       for (const child of [...node.childNodes]) {
         if (child.nodeType !== 1) continue;
         const name = child.rawTagName.toLowerCase();
-        if (INLINE_ELEMENTS.has(name)) {
+        if (isInlineTextElement(child)) {
           if (hasDirectSentChildren(child)) processSentContainer(child);
           else processInlineContent(child, false);
         } else if (BLOCK_ELEMENTS.has(name)) {
@@ -6199,19 +6378,19 @@ var require_wemlContentNormalizeV2 = __commonJS({
         }
       }
       for (const child of [...node.childNodes]) {
-        if (child.nodeType === 1 && INLINE_ELEMENTS.has(child.rawTagName.toLowerCase())) {
+        if (child.nodeType === 1 && isInlineTextElement(child)) {
           bleedEdgeSpaces(child);
         }
       }
       for (const child of [...node.childNodes]) {
-        if (child.nodeType === 3) child.rawText = child.rawText.replace(/[ \t\r\n]+/g, " ");
+        if (child.nodeType === 3) child.rawText = collapseWhitespace(child.rawText);
       }
       for (const child of [...node.childNodes]) {
         if (child.nodeType === 1 && child.rawTagName.toLowerCase() === "br") {
           const prev = child.previousSibling;
-          if (prev && prev.nodeType === 3) prev.rawText = prev.rawText.replace(/\s+$/, "");
+          if (prev && prev.nodeType === 3) prev.rawText = trimEndWhitespace(prev.rawText);
           const next = child.nextSibling;
-          if (next && next.nodeType === 3) next.rawText = next.rawText.replace(/^\s+/, "");
+          if (next && next.nodeType === 3) next.rawText = trimStartWhitespace(next.rawText);
         }
       }
       trimContainerEdges(node);
@@ -6225,17 +6404,17 @@ var require_wemlContentNormalizeV2 = __commonJS({
       const first = children[0];
       const last = children[children.length - 1];
       if (children.length === 1) {
-        if (first.nodeType === 3) first.rawText = first.rawText.trim();
+        if (first.nodeType === 3) first.rawText = trimWhitespace(first.rawText);
       } else {
-        if (first.nodeType === 3) first.rawText = first.rawText.replace(/^\s+/, "");
-        if (last.nodeType === 3) last.rawText = last.rawText.replace(/\s+$/, "");
+        if (first.nodeType === 3) first.rawText = trimStartWhitespace(first.rawText);
+        if (last.nodeType === 3) last.rawText = trimEndWhitespace(last.rawText);
       }
     }
     function processInlineContent(node, trimEdges) {
       for (const child of [...node.childNodes]) {
         if (child.nodeType !== 1) continue;
         const name = child.rawTagName.toLowerCase();
-        if (INLINE_ELEMENTS.has(name)) {
+        if (isInlineTextElement(child)) {
           if (hasDirectSentChildren(child)) processSentContainer(child);
           else processInlineContent(child, false);
         } else if (BLOCK_ELEMENTS.has(name)) {
@@ -6245,19 +6424,19 @@ var require_wemlContentNormalizeV2 = __commonJS({
         }
       }
       for (const child of [...node.childNodes]) {
-        if (child.nodeType === 1 && INLINE_ELEMENTS.has(child.rawTagName.toLowerCase())) {
+        if (child.nodeType === 1 && isInlineTextElement(child)) {
           bleedEdgeSpaces(child);
         }
       }
       for (const child of [...node.childNodes]) {
-        if (child.nodeType === 3) child.rawText = child.rawText.replace(/[ \t\r\n]+/g, " ");
+        if (child.nodeType === 3) child.rawText = collapseWhitespace(child.rawText);
       }
       for (const child of [...node.childNodes]) {
         if (child.nodeType === 1 && child.rawTagName.toLowerCase() === "br") {
           const prev = child.previousSibling;
-          if (prev && prev.nodeType === 3) prev.rawText = prev.rawText.replace(/\s+$/, "");
+          if (prev && prev.nodeType === 3) prev.rawText = trimEndWhitespace(prev.rawText);
           const next = child.nextSibling;
-          if (next && next.nodeType === 3) next.rawText = next.rawText.replace(/^\s+/, "");
+          if (next && next.nodeType === 3) next.rawText = trimStartWhitespace(next.rawText);
         }
       }
       if (trimEdges) trimEdgeTextNodes(node);
@@ -6295,7 +6474,7 @@ var require_wemlContentNormalizeV2 = __commonJS({
       const first = getFirstTextNode(node);
       if (!first) return "";
       const raw = first.rawText;
-      const trimmed = raw.replace(/^\s+/, "");
+      const trimmed = trimStartWhitespace(raw);
       if (trimmed === raw) return "";
       first.rawText = trimmed;
       return " ";
@@ -6304,7 +6483,7 @@ var require_wemlContentNormalizeV2 = __commonJS({
       const last = getLastTextNode(node);
       if (!last) return "";
       const raw = last.rawText;
-      const trimmed = raw.replace(/\s+$/, "");
+      const trimmed = trimEndWhitespace(raw);
       if (trimmed === raw) return "";
       last.rawText = trimmed;
       return " ";
@@ -6341,10 +6520,10 @@ var require_wemlContentNormalizeV2 = __commonJS({
       const first = children[0];
       const last = children[children.length - 1];
       if (first === last) {
-        if (first.nodeType === 3) first.rawText = first.rawText.trim();
+        if (first.nodeType === 3) first.rawText = trimWhitespace(first.rawText);
       } else {
-        if (first.nodeType === 3) first.rawText = first.rawText.replace(/^\s+/, "");
-        if (last.nodeType === 3) last.rawText = last.rawText.replace(/\s+$/, "");
+        if (first.nodeType === 3) first.rawText = trimStartWhitespace(first.rawText);
+        if (last.nodeType === 3) last.rawText = trimEndWhitespace(last.rawText);
       }
     }
     function hasDirectSentChildren(node) {
@@ -6352,17 +6531,22 @@ var require_wemlContentNormalizeV2 = __commonJS({
         (child) => child.nodeType === 1 && child.rawTagName.toLowerCase() === "w-sent"
       );
     }
-    function serializeDocument(doc) {
+    function isInlineTextElement(node) {
+      if (node.nodeType !== 1) return false;
+      const name = node.rawTagName.toLowerCase();
+      return INLINE_ELEMENTS.has(name) || !BLOCK_ELEMENTS.has(name) && !INLINE_CONTAINERS.has(name) && !VOID_HTML_ELEMENTS.has(name);
+    }
+    function serializeDocument(doc, entities2, marker) {
       const parts = ["<!DOCTYPE html>\n"];
       const htmlNode = doc.querySelector("html");
-      parts.push(`<html${serializeAttrs(htmlNode ? htmlNode.attrs : {})}>
+      parts.push(`<html${serializeAttrs(htmlNode ? htmlNode.rawAttrs : "", entities2, marker)}>
 
 `);
       const head = doc.querySelector("head");
       parts.push("<head>\n");
       if (head) {
         for (const child of head.childNodes) {
-          if (child.nodeType === 1) parts.push(serializeNode(child), "\n");
+          if (child.nodeType === 1) parts.push(serializeNode(child, entities2, marker), "\n");
         }
       }
       parts.push("</head>\n\n");
@@ -6370,28 +6554,81 @@ var require_wemlContentNormalizeV2 = __commonJS({
       parts.push("<body>\n");
       if (body) {
         for (const child of body.childNodes) {
-          if (child.nodeType === 1) parts.push(serializeNode(child), "\n");
+          if (child.nodeType === 1) parts.push(serializeNode(child, entities2, marker), "\n");
         }
       }
       parts.push("</body>\n</html>");
       return parts.join("");
     }
-    function serializeNode(node) {
+    function serializeNode(node, entities2, marker) {
       if (node.nodeType === 3) return node.rawText;
       if (node.nodeType === 8 || node.nodeType !== 1) return "";
       const name = node.rawTagName.toLowerCase();
-      const attrs = serializeAttrs(node.attrs);
+      const attrs = serializeAttrs(node.rawAttrs, entities2, marker);
       if (VOID_HTML_ELEMENTS.has(name)) return `<${name}${attrs} />`;
       const isBlock = BLOCK_ELEMENTS.has(name);
       const inner = [];
       for (const child of node.childNodes) {
-        if (isBlock && child.nodeType === 3 && child.rawText.trim() === "") continue;
-        inner.push(serializeNode(child));
+        if (isBlock && child.nodeType === 3 && isWhitespaceOnly(child.rawText)) continue;
+        inner.push(serializeNode(child, entities2, marker));
       }
       return `<${name}${attrs}>${inner.join("")}</${name}>`;
     }
-    function serializeAttrs(attrs) {
-      return Object.entries(attrs).map(([name, value]) => ` ${name}="${encodeAttr(String(value))}"`).join("");
+    function serializeAttrs(rawAttrs, entities2, marker) {
+      const canonical = /* @__PURE__ */ new Map();
+      let index = 0;
+      while (index < rawAttrs.length) {
+        while (index < rawAttrs.length && isNormalizableWhitespace(rawAttrs[index])) index++;
+        if (index >= rawAttrs.length || rawAttrs[index] === "/") break;
+        const nameStart = index;
+        while (index < rawAttrs.length && !isNormalizableWhitespace(rawAttrs[index]) && !"=/>".includes(rawAttrs[index])) index++;
+        if (index === nameStart) {
+          index++;
+          continue;
+        }
+        const name = rawAttrs.slice(nameStart, index).toLowerCase();
+        while (index < rawAttrs.length && isNormalizableWhitespace(rawAttrs[index])) index++;
+        let value = "";
+        if (rawAttrs[index] === "=") {
+          index++;
+          while (index < rawAttrs.length && isNormalizableWhitespace(rawAttrs[index])) index++;
+          if (rawAttrs[index] === '"' || rawAttrs[index] === "'") {
+            const quote = rawAttrs[index++];
+            const valueStart = index;
+            while (index < rawAttrs.length && rawAttrs[index] !== quote) index++;
+            value = rawAttrs.slice(valueStart, index);
+            if (index < rawAttrs.length) index++;
+          } else {
+            const valueStart = index;
+            while (index < rawAttrs.length && !isNormalizableWhitespace(rawAttrs[index])) index++;
+            value = rawAttrs.slice(valueStart, index);
+          }
+        }
+        canonical.set(
+          name,
+          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("");
+    }
+    function normalizeTokenList(value, entities2, marker) {
+      const normalized = trimWhitespace(value);
+      if (!normalized) return normalized;
+      return normalized.split(" ").sort((left, right) => compareUnicodeScalars(
+        restoreEntities(left, entities2, marker),
+        restoreEntities(right, entities2, marker)
+      )).join(" ");
+    }
+    function compareUnicodeScalars(left, right) {
+      const leftScalars = Array.from(left, (character) => character.codePointAt(0));
+      const rightScalars = Array.from(right, (character) => character.codePointAt(0));
+      const limit = Math.min(leftScalars.length, rightScalars.length);
+      for (let index = 0; index < limit; index++) {
+        if (leftScalars[index] !== rightScalars[index]) {
+          return leftScalars[index] - rightScalars[index];
+        }
+      }
+      return leftScalars.length - rightScalars.length;
     }
     function encodeAttr(value) {
       return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
@@ -6429,6 +6666,7 @@ var require_wemlContentNormalizeV2 = __commonJS({
       }
     };
     function wemlContentNormalize2(input, isWemlValid = false) {
+      if (input.startsWith("\uFEFF")) input = input.slice(1);
       const inputText = withoutWhiteSpace(analyze(input, !isWemlValid).text);
       const result = formatWeml(input);
       const outputText = withoutWhiteSpace(analyze(result, true).text);
@@ -6443,6 +6681,9 @@ var require_wemlContentNormalizeV2 = __commonJS({
         if (source[index2] === "\n") lineStarts.push(index2 + 1);
       }
       const stack = [];
+      const rootTagCounts = /* @__PURE__ */ new Map([["html", 0], ["head", 0], ["body", 0]]);
+      let seenHead = false;
+      let seenBody = false;
       const textParts = [];
       let textStart = 0;
       let index = 0;
@@ -6526,6 +6767,26 @@ var require_wemlContentNormalizeV2 = __commonJS({
             if (expected !== name) fail("MISMATCHED_CLOSING_TAG", index, expected, name);
             stack.pop();
           } else {
+            if (rootTagCounts.has(name)) {
+              if (rootTagCounts.get(name) > 0) {
+                fail("DUPLICATE_ROOT_TAG", index, null, name);
+              }
+              const parent = stack.length > 0 ? stack.at(-1).name : null;
+              if (name === "html") {
+                if (parent !== null) fail("INVALID_ROOT_TAG_PARENT", index, null, name);
+              } else if (parent !== "html") {
+                fail("INVALID_ROOT_TAG_PARENT", index, "html", name);
+              }
+              if (name === "body" && !seenHead) {
+                fail("BODY_BEFORE_HEAD", index, "head", "body");
+              }
+              if (name === "head" && seenBody) {
+                fail("HEAD_AFTER_BODY", index, "body", "head");
+              }
+              rootTagCounts.set(name, rootTagCounts.get(name) + 1);
+              seenHead || (seenHead = name === "head");
+              seenBody || (seenBody = name === "body");
+            }
             let last = found.end - 1;
             while (last >= cursor && isSourceSpace(source[last])) last--;
             const selfClosing = last >= cursor && source[last] === "/";
@@ -6547,6 +6808,11 @@ var require_wemlContentNormalizeV2 = __commonJS({
           null
         );
       }
+      if (validateStructure) {
+        for (const name of ["html", "head", "body"]) {
+          if (rootTagCounts.get(name) === 0) fail("MISSING_ROOT_TAG", 0, name, null);
+        }
+      }
       return { text: textParts.join("") };
     }
     function findTagEnd(source, start) {
@@ -6570,11 +6836,40 @@ 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("");
     }
+    function isNormalizableWhitespace(character) {
+      return character !== void 0 && WHITE_SPACE.has(character.codePointAt(0));
+    }
+    function collapseWhitespace(text) {
+      const result = [];
+      let inWhitespace = false;
+      for (const character of text) {
+        if (isNormalizableWhitespace(character)) {
+          if (!inWhitespace) result.push(" ");
+          inWhitespace = true;
+        } else {
+          result.push(character);
+          inWhitespace = false;
+        }
+      }
+      return result.join("");
+    }
+    function trimStartWhitespace(text) {
+      return collapseWhitespace(text).replace(/^ +/, "");
+    }
+    function trimEndWhitespace(text) {
+      return collapseWhitespace(text).replace(/ +$/, "");
+    }
+    function trimWhitespace(text) {
+      return collapseWhitespace(text).replace(/^ +| +$/g, "");
+    }
+    function isWhitespaceOnly(text) {
+      return Array.from(text).every(isNormalizableWhitespace);
+    }
     function sha256(text) {
       const crypto = __require("crypto");
       return crypto.createHash("sha256").update(text, "utf8").digest("hex");
@@ -6594,6 +6889,16 @@ var require_wemlContentNormalizeV2 = __commonJS({
         detail = `unexpected closing tag </${actualTag}>.`;
       } else if (code === "UNCLOSED_TAG") {
         detail = `tag <${expectedTag}> is not closed.`;
+      } else if (code === "DUPLICATE_ROOT_TAG") {
+        detail = `document contains more than one <${actualTag}> tag.`;
+      } else if (code === "INVALID_ROOT_TAG_PARENT") {
+        detail = expectedTag ? `tag <${actualTag}> must be a direct child of <${expectedTag}>.` : `root tag <${actualTag}> must not be nested.`;
+      } else if (code === "BODY_BEFORE_HEAD") {
+        detail = "tag <body> appears before <head>.";
+      } else if (code === "HEAD_AFTER_BODY") {
+        detail = "tag <head> appears after <body>.";
+      } else if (code === "MISSING_ROOT_TAG") {
+        detail = `required root tag <${expectedTag}> is missing.`;
       } else if (code === "UNTERMINATED_COMMENT") {
         detail = "comment is not terminated.";
       } else if (code === "UNTERMINATED_DECLARATION") {
@@ -29245,6 +29550,13 @@ var TAGS = {
         "default": "paragraph",
         "description": "Type of the paragraph. See corresponding page for values",
         "enumRef": "paragraph-type"
+      },
+      {
+        "name": "align",
+        "required": false,
+        "default": "`left` for LTR, `right` for RTL",
+        "description": "Horizontal alignment. See corresponding page for allowed values",
+        "enumRef": "horizontal-alignment"
       }
     ],
     "notes": "",
@@ -29257,6 +29569,24 @@ var TAGS = {
     "notes": "Current line is broken and the next line is started. Next line has the same alignment\nas the current line, and the same indentation level as any line other than the first.",
     "source": "inlines/br.md"
   },
+  "w-color": {
+    "tag": "w-color",
+    "description": "Represents an inline span with a foreground color, a background color, or both.",
+    "attributes": [
+      {
+        "name": "background",
+        "required": false,
+        "description": "Background color. See Colors."
+      },
+      {
+        "name": "foreground",
+        "required": false,
+        "description": "Foreground color. See Colors."
+      }
+    ],
+    "notes": "Any inline elements.",
+    "source": "inlines/w-color.md"
+  },
   "w-entity": {
     "tag": "w-entity",
     "description": "An entity is a reference to a person, place, or thing. Entities are used to",
@@ -29389,6 +29719,16 @@ var TAGS = {
         "name": "override-chapter-number",
         "required": false,
         "description": "Chapter number for manual set"
+      },
+      {
+        "name": "background",
+        "required": false,
+        "description": "Background color. See Colors"
+      },
+      {
+        "name": "foreground",
+        "required": false,
+        "description": "Foreground color. See Colors"
       }
     ],
     "notes": "Must contain a single text block element.",
@@ -29419,6 +29759,16 @@ var TAGS = {
         "required": false,
         "description": "Horizontal alignment. See corresponding page for allowed values. Defaults to `left` for left-to-right languages and `right` to right-to-left",
         "enumRef": "horizontal-alignment"
+      },
+      {
+        "name": "background",
+        "required": false,
+        "description": "Background color. See Colors"
+      },
+      {
+        "name": "foreground",
+        "required": false,
+        "description": "Foreground color. See Colors"
       }
     ],
     "notes": "Must contain a single block element.",
@@ -29775,8 +30125,12 @@ var META_FIELDS = [
     "description": "Publication description."
   },
   {
-    "name": "parent_id",
-    "description": "Parent publication version GUID."
+    "name": "purchase-link",
+    "description": "Purchase link."
+  },
+  {
+    "name": "version-id",
+    "description": "Publication version GUID."
   }
 ];
 
@@ -30033,7 +30387,7 @@ Unicode: \`U+${resolved.codePoint.toString(16).toUpperCase().padStart(4, "0")}\`
 // src/schema/structureRules.ts
 var CONTAINER_TAGS = ["w-para", "w-heading", "w-para-group", "w-toc"];
 var BLOCK_TAGS = ["w-text-block", "figure", "w-list", "table", "hr"];
-var INLINE_TAGS = ["a", "br", "w-entity", "w-format", "w-lang", "w-non-egw", "w-note", "w-page", "w-sent"];
+var INLINE_TAGS = ["a", "br", "w-color", "w-entity", "w-format", "w-lang", "w-non-egw", "w-note", "w-page", "w-sent"];
 var STRUCTURE_RULES = {
   html: {
     children: [
@@ -30180,6 +30534,13 @@ var STRUCTURE_RULES = {
     allowText: true,
     description: "With href: a link that may contain inline content. With id: a named anchor that must be empty. Exactly one of href/id is required, not both."
   },
+  "w-color": {
+    children: [
+      { tags: [...INLINE_TAGS], min: 0, max: null, description: "inline elements" }
+    ],
+    allowText: true,
+    description: "May contain inline elements and text; requires a foreground or background color."
+  },
   "w-entity": {
     children: [
       { tags: [...INLINE_TAGS], min: 0, max: null, description: "inline elements" }
@@ -30253,11 +30614,18 @@ var STRUCTURE_RULES = {
   }
 };
 var ARABIC_OR_ROMAN = /^(?:\d+|[ivxlcdm]+)$/i;
+var COLOR_VALUE = /^#(?:[0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
 var ATTRIBUTE_CONSTRAINTS = [
   { tag: "w-heading", attribute: "level", kind: "integer-range", min: 1, max: 6, message: "`level` must be an integer between 1 and 6." },
   { tag: "w-heading", attribute: "override-chapter-number", kind: "integer-min", min: 0, message: "`override-chapter-number` must be a non-negative integer." },
+  { tag: "w-heading", attribute: "background", kind: "pattern", pattern: COLOR_VALUE, allowEmpty: false, message: "`background` must be a color in #RGB, #RGBA, #RRGGBB or #RRGGBBAA format." },
+  { tag: "w-heading", attribute: "foreground", kind: "pattern", pattern: COLOR_VALUE, allowEmpty: false, message: "`foreground` must be a color in #RGB, #RGBA, #RRGGBB or #RRGGBBAA format." },
   { tag: "w-page", attribute: "number", kind: "pattern", pattern: ARABIC_OR_ROMAN, message: "`number` must be an arabic or roman number." },
   { tag: "w-para", attribute: "indent", kind: "integer-min", min: -4, message: "`indent` must be an integer >= -4." },
+  { tag: "w-para", attribute: "background", kind: "pattern", pattern: COLOR_VALUE, allowEmpty: false, message: "`background` must be a color in #RGB, #RGBA, #RRGGBB or #RRGGBBAA format." },
+  { tag: "w-para", attribute: "foreground", kind: "pattern", pattern: COLOR_VALUE, allowEmpty: false, message: "`foreground` must be a color in #RGB, #RGBA, #RRGGBB or #RRGGBBAA format." },
+  { tag: "w-color", attribute: "background", kind: "pattern", pattern: COLOR_VALUE, allowEmpty: false, message: "`background` must be a color in #RGB, #RGBA, #RRGGBB or #RRGGBBAA format." },
+  { tag: "w-color", attribute: "foreground", kind: "pattern", pattern: COLOR_VALUE, allowEmpty: false, message: "`foreground` must be a color in #RGB, #RGBA, #RRGGBB or #RRGGBBAA format." },
   { tag: "w-note-para", attribute: "indent", kind: "integer-min", min: 0, message: "`indent` must be an integer >= 0." },
   { tag: "td", attribute: "indent", kind: "integer-min", min: -4, message: "`indent` must be an integer >= -4." },
   { tag: "th", attribute: "indent", kind: "integer-min", min: -4, message: "`indent` must be an integer >= -4." },
@@ -30398,6 +30766,9 @@ function indent(text) {
 function buildElement(tag, counter, depth) {
   const schema = TAGS[tag];
   let attrs = "";
+  if (tag === "w-color") {
+    attrs = ` foreground="${placeholder(counter)}"`;
+  }
   for (const attr of schema?.attributes ?? []) {
     if (attr.required) {
       attrs += ` ${attr.name}="${placeholder(counter)}"`;
@@ -30433,6 +30804,9 @@ function buildElementSnippet(tag) {
 function buildOpeningTag(tag) {
   const counter = { n: 1 };
   let attrs = "";
+  if (tag === "w-color") {
+    attrs = ` foreground="${placeholder(counter)}"`;
+  }
   for (const attr of TAGS[tag]?.attributes ?? []) {
     if (attr.required) {
       attrs += ` ${attr.name}="${placeholder(counter)}"`;
@@ -30540,24 +30914,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;
@@ -30595,8 +30967,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:
@@ -30636,6 +31007,7 @@ function dedupe(items) {
 function hasValueSuggestions(tag, attribute, enumRef) {
   if (enumRef && ENUMS[enumRef]) return true;
   if (tag === "w-heading" && attribute === "level") return true;
+  if (tag === "meta" && attribute === "name") return true;
   if (tag === "meta" && attribute === "content") return true;
   if (tag === "a" && attribute === "href") return true;
   return false;
@@ -30805,6 +31177,18 @@ var WemlCompletionProvider = class {
         });
       }
     }
+    if (ctx.tag === "meta" && ctx.attribute === "name") {
+      for (const field of META_FIELDS) {
+        items.push({
+          label: field.name,
+          kind: this.m.languages.CompletionItemKind.Property,
+          detail: "WEML metadata field",
+          documentation: metaFieldMarkdown(field.name),
+          insertText: wrap(field.name),
+          range
+        });
+      }
+    }
     if (ctx.tag === "meta" && ctx.attribute === "content" && stripQuotes2(node.attributes?.["name"]) === "type") {
       const codeEnum = ENUMS["publication-type"];
       if (codeEnum) {
@@ -30962,6 +31346,9 @@ function validateWemlModel(m, model) {
         push(href.valueRange, `Unrecognized href format "${href.value}". Expected formats like: ${types}.`, "warning");
       }
     }
+    if (tag === "w-color" && !attrs.has("background") && !attrs.has("foreground")) {
+      push(tagRange, '<w-color> must have either "background" or "foreground".', "error");
+    }
     if (tag === "div") {
       const id = stripQuotes2(node.attributes?.["id"]);
       const range = attrs.get("id")?.valueRange ?? tagRange;
@@ -30975,7 +31362,8 @@ function validateWemlModel(m, model) {
   function validateConstraint(constraint, info) {
     if (info.value === void 0 || !info.valueRange) return;
     if (constraint.kind === "pattern") {
-      if (info.value !== "" && constraint.pattern && !constraint.pattern.test(info.value)) {
+      const emptyIsInvalid = constraint.allowEmpty === false && info.value === "";
+      if (emptyIsInvalid || info.value !== "" && constraint.pattern && !constraint.pattern.test(info.value)) {
         push(info.valueRange, constraint.message, "error");
       }
       return;
@@ -31354,7 +31742,7 @@ function escapeSnippet(text) {
   return text.replace(/\\/g, "\\\\").replace(/\$/g, "\\$").replace(/}/g, "\\}");
 }
 function buildWrapSnippet(tag, type, selection) {
-  const attrs = type ? ` type="${type}"` : tag === "a" ? ' href="$1"' : (TAGS[tag]?.attributes ?? []).filter((a) => a.required).map((a) => ` ${a.name}="$1"`).join("");
+  const attrs = type ? ` type="${type}"` : tag === "a" ? ' href="$1"' : tag === "w-color" ? ' foreground="$1"' : (TAGS[tag]?.attributes ?? []).filter((a) => a.required).map((a) => ` ${a.name}="$1"`).join("");
   const inner = selection.length > 0 ? escapeSnippet(selection) : attrs.includes("$1") ? "$2" : "$1";
   return `<${tag}${attrs}>${inner}</${tag}>`;
 }
@@ -31507,7 +31895,7 @@ var WRAP_OPTIONS = [
     tag: "w-format",
     type: v.value
   })),
-  ...["w-lang", "w-non-egw", "w-entity", "a"].map((t2) => ({ value: t2, label: t2, tag: t2 }))
+  ...["w-color", "w-lang", "w-non-egw", "w-entity", "a"].map((t2) => ({ value: t2, label: t2, tag: t2 }))
 ];
 var SNIPPET_BUTTONS = [
   { label: "w-para", id: "w-para" },