@diagrammo/dgmo 0.45.0 → 0.47.0

package/dist/chunk-EVCVDTXE.js

@@ -0,0 +1,732 @@
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  finalizeAutoTagColors,
+  isTagBlockHeading,
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  validateTagGroupNames
+} from "./chunk-QLCCJEJI.js";
+import {
+  OPTION_NOCOLON_RE,
+  extractColor,
+  measureIndent,
+  parseFirstLine,
+  tryParseSharedOption
+} from "./chunk-Y3J7VR52.js";
+import {
+  formatDgmoError,
+  makeDgmoError
+} from "./chunk-CXK4DZH3.js";
+
+// src/wireframe/parser.ts
+var KNOWN_OPTIONS = /* @__PURE__ */ new Set(["palette", "theme", "active-tag"]);
+var GROUP_ONLY_METADATA = /* @__PURE__ */ new Set([
+  "horizontal",
+  "scrollable",
+  "collapsed"
+]);
+var STATE_KEYWORDS = /* @__PURE__ */ new Set([
+  "disabled",
+  "active",
+  "selected",
+  "empty",
+  "ghost",
+  "destructive",
+  "success",
+  "warning",
+  "info",
+  "scrollable",
+  "collapsed",
+  "toggle",
+  "password",
+  "textarea",
+  "horizontal",
+  "primary"
+]);
+var ELEMENT_KEYWORDS = {
+  nav: { block: true },
+  tabs: { block: true },
+  table: { block: true },
+  image: { block: false, params: /* @__PURE__ */ new Set(["round", "wide"]) },
+  modal: { block: true },
+  skeleton: { block: true },
+  alert: { block: true },
+  progress: { block: false },
+  chart: { block: false, params: /* @__PURE__ */ new Set(["line", "bar", "pie"]) }
+};
+var BRACKET_RE = /^\[([^\]]*)\](.*)$/;
+var BUTTON_RE = /^\(([^)]+)\)(.*)$/;
+var DROPDOWN_RE = /^\{([^}]+)\}(.*)$/;
+var CHECKBOX_CHECKED_RE = /^<\s*x\s*>$/i;
+var CHECKBOX_UNCHECKED_RE = /^<\s*>$/;
+var RADIO_SELECTED_RE = /^\(\*\)\s+(.+)$/;
+var RADIO_UNSELECTED_RE = /^\(\s*\)\s+(.+)$/;
+var HEADING_RE = /^(#{1,2})\s+(.+)$/;
+var DIVIDER_RE = /^-{3,}$/;
+var LIST_ITEM_RE = /^-\s+(.+)$/;
+var TABLE_SKELETON_RE = /^table\s+(\d+)x(\d+)$/i;
+function genId(lineNumber, indent, suffix = "") {
+  return `wf-${lineNumber}-${indent}${suffix ? "-" + suffix : ""}`;
+}
+function resetWireframeIds() {
+}
+function makeElement(type, label, lineNumber, indent) {
+  return {
+    id: genId(lineNumber, indent),
+    type,
+    label,
+    children: [],
+    metadata: {},
+    states: [],
+    annotations: [],
+    lineNumber,
+    indent,
+    isContainer: false,
+    orientation: "vertical",
+    isSkeleton: false
+  };
+}
+function peelTrailingFlags(label) {
+  const tokens = label.split(/\s+/).filter(Boolean);
+  const states = [];
+  while (tokens.length > 0) {
+    const last = tokens[tokens.length - 1];
+    if (last !== last.toLowerCase()) break;
+    if (!STATE_KEYWORDS.has(last)) break;
+    states.unshift(last);
+    tokens.pop();
+  }
+  return { label: tokens.join(" "), states };
+}
+function parseWireframeMetadata(raw) {
+  const states = [];
+  const annotations = [];
+  const metadata = {};
+  const parts = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  for (const part of parts) {
+    const lower = part.toLowerCase();
+    if (STATE_KEYWORDS.has(lower)) {
+      states.push(lower);
+    } else if (part.includes(":")) {
+      const [key, ...rest] = part.split(":");
+      metadata[key.trim()] = rest.join(":").trim();
+    } else {
+      annotations.push(part);
+    }
+  }
+  return { states, annotations, metadata };
+}
+function applyTrailingMeta(el, rawTail) {
+  if (!rawTail) return;
+  const trimmed = rawTail.trim();
+  if (!trimmed) return;
+  if (trimmed.startsWith("|")) {
+    applyMetadata(el, trimmed.substring(1).trim());
+    return;
+  }
+  const tokens = trimmed.split(/\s+/);
+  if (tokens.every((t) => t === t.toLowerCase() && STATE_KEYWORDS.has(t))) {
+    applyMetadata(el, tokens.join(", "));
+    return;
+  }
+  applyMetadata(el, trimmed);
+}
+function applyMetadata(el, metaStr) {
+  if (!metaStr) return;
+  const { states, annotations, metadata } = parseWireframeMetadata(metaStr);
+  el.states.push(...states);
+  el.annotations.push(...annotations);
+  Object.assign(el.metadata, metadata);
+  if (el.type === "textInput") {
+    if (states.includes("password")) el.fieldVariant = "password";
+    if (states.includes("textarea")) el.fieldVariant = "textarea";
+  }
+  for (const s of states) {
+    if (GROUP_ONLY_METADATA.has(s)) {
+      el.isContainer = true;
+      if (s === "horizontal") el.orientation = "horizontal";
+    }
+  }
+}
+function matchKeyword(segment) {
+  const words = segment.split(/\s+/);
+  const first = words[0].toLowerCase();
+  const kw = ELEMENT_KEYWORDS[first];
+  if (!kw) return null;
+  if (words.length === 1) {
+    return { keyword: first, type: first };
+  }
+  const rest = words.slice(1).join(" ");
+  if (first === "modal") {
+    return { keyword: first, type: "modal", param: rest };
+  }
+  if (first === "progress") {
+    const num = parseInt(rest, 10);
+    if (!isNaN(num)) {
+      return { keyword: first, type: "progress", param: rest };
+    }
+    return null;
+  }
+  if (first === "table") {
+    if (TABLE_SKELETON_RE.test(segment)) {
+      return { keyword: first, type: "table", param: rest };
+    }
+    return { keyword: first, type: "table" };
+  }
+  if (kw.params) {
+    if (kw.params.has(rest.toLowerCase())) {
+      return {
+        keyword: first,
+        type: first,
+        param: rest.toLowerCase()
+      };
+    }
+    return null;
+  }
+  return null;
+}
+function parseSegment(segment, lineNumber, indent, diagnostics) {
+  const trimmed = segment.trim();
+  if (!trimmed) return null;
+  const headingMatch = trimmed.match(HEADING_RE);
+  if (headingMatch) {
+    const level = headingMatch[1].length;
+    const el = makeElement(
+      "heading",
+      headingMatch[2].trim(),
+      lineNumber,
+      indent
+    );
+    el.headingLevel = level;
+    return el;
+  }
+  if (DIVIDER_RE.test(trimmed)) {
+    return makeElement("divider", "", lineNumber, indent);
+  }
+  if (CHECKBOX_CHECKED_RE.test(trimmed)) {
+    const el = makeElement("checkbox", "", lineNumber, indent);
+    el.checked = true;
+    return el;
+  }
+  if (CHECKBOX_UNCHECKED_RE.test(trimmed)) {
+    const el = makeElement("checkbox", "", lineNumber, indent);
+    el.checked = false;
+    return el;
+  }
+  const radioSelMatch = trimmed.match(RADIO_SELECTED_RE);
+  if (radioSelMatch) {
+    const el = makeElement(
+      "radio",
+      // In-bounds: regex has one capture group; matched group is defined.
+      radioSelMatch[1].trim(),
+      lineNumber,
+      indent
+    );
+    el.selected = true;
+    return el;
+  }
+  const radioUnselMatch = trimmed.match(RADIO_UNSELECTED_RE);
+  if (radioUnselMatch) {
+    const el = makeElement(
+      "radio",
+      // In-bounds: regex has one capture group; matched group is defined.
+      radioUnselMatch[1].trim(),
+      lineNumber,
+      indent
+    );
+    el.selected = false;
+    return el;
+  }
+  const checkLabelMatch = trimmed.match(/^(<\s*x?\s*>)\s+(.+)$/i);
+  if (checkLabelMatch) {
+    const isChecked = /x/i.test(checkLabelMatch[1]);
+    const labelPart = checkLabelMatch[2];
+    const pipeSplit = labelPart.split(/\s*\|\s*/);
+    const baseLabel = pipeSplit[0].trim();
+    const peeled = peelTrailingFlags(baseLabel);
+    const el = makeElement("checkbox", peeled.label, lineNumber, indent);
+    el.checked = isChecked;
+    if (peeled.states.length > 0) {
+      applyMetadata(el, peeled.states.join(", "));
+    }
+    if (pipeSplit.length > 1) {
+      applyMetadata(el, pipeSplit.slice(1).join(", "));
+    }
+    return el;
+  }
+  const dropdownMatch = trimmed.match(DROPDOWN_RE);
+  if (dropdownMatch) {
+    const options = dropdownMatch[1].split("|").map((s) => s.trim()).filter(Boolean);
+    const el = makeElement("dropdown", options[0] || "", lineNumber, indent);
+    el.options = options;
+    applyTrailingMeta(el, dropdownMatch[2]);
+    return el;
+  }
+  const parenPipeMatch = trimmed.match(/^\(([^)]*\|[^)]*)\)\s*$/);
+  if (parenPipeMatch) {
+    diagnostics.push(
+      makeDgmoError(
+        lineNumber,
+        // In-bounds: regex has one capture group; matched group is defined.
+        `Did you mean a dropdown? Use braces: {${parenPipeMatch[1]}} instead of (${parenPipeMatch[1]})`,
+        "warning"
+      )
+    );
+    const options = parenPipeMatch[1].split("|").map((s) => s.trim()).filter(Boolean);
+    const el = makeElement("dropdown", options[0] || "", lineNumber, indent);
+    el.options = options;
+    return el;
+  }
+  const buttonMatch = trimmed.match(BUTTON_RE);
+  if (buttonMatch) {
+    const el = makeElement(
+      "button",
+      buttonMatch[1].trim(),
+      lineNumber,
+      indent
+    );
+    applyTrailingMeta(el, buttonMatch[2]);
+    return el;
+  }
+  const bracketMatch = trimmed.match(BRACKET_RE);
+  if (bracketMatch) {
+    const el = makeElement(
+      "group",
+      bracketMatch[1].trim(),
+      lineNumber,
+      indent
+    );
+    applyTrailingMeta(el, bracketMatch[2]);
+    if (!el.isContainer) {
+      el.type = "textInput";
+      if (el.states.includes("password")) el.fieldVariant = "password";
+      if (el.states.includes("textarea")) el.fieldVariant = "textarea";
+    }
+    return el;
+  }
+  const listMatch = trimmed.match(LIST_ITEM_RE);
+  if (listMatch) {
+    return makeElement("listItem", listMatch[1].trim(), lineNumber, indent);
+  }
+  const kwMatch = matchKeyword(trimmed);
+  if (kwMatch) {
+    const el = makeElement(
+      kwMatch.type,
+      kwMatch.param || "",
+      lineNumber,
+      indent
+    );
+    if (kwMatch.type === "image") {
+      el.imageHint = kwMatch.param || "default";
+    } else if (kwMatch.type === "progress") {
+      const val = parseInt(kwMatch.param || "0", 10);
+      el.progressValue = Math.max(0, Math.min(100, isNaN(val) ? 0 : val));
+    } else if (kwMatch.type === "chart") {
+      el.chartHint = kwMatch.param || "line";
+    } else if (kwMatch.type === "table") {
+      const skelMatch = `table ${kwMatch.param || ""}`.match(TABLE_SKELETON_RE);
+      if (skelMatch) {
+        el.tableRows = parseInt(skelMatch[1], 10);
+        el.tableCols = parseInt(skelMatch[2], 10);
+      }
+    }
+    if (ELEMENT_KEYWORDS[kwMatch.keyword]?.block) {
+      el.isContainer = true;
+    }
+    return el;
+  }
+  if (/^\[[^\]]*$/.test(trimmed)) {
+    diagnostics.push(
+      makeDgmoError(
+        lineNumber,
+        `Unmatched '[' \u2014 auto-closing bracket`,
+        "warning"
+      )
+    );
+    const label = trimmed.substring(1).trim();
+    return makeElement("textInput", label, lineNumber, indent);
+  }
+  if (/^\([^)]*$/.test(trimmed) && !trimmed.match(/^\(\s*\*?\s*\)/)) {
+    diagnostics.push(
+      makeDgmoError(
+        lineNumber,
+        `Unmatched '(' \u2014 auto-closing bracket`,
+        "warning"
+      )
+    );
+    const label = trimmed.substring(1).trim();
+    return makeElement("button", label, lineNumber, indent);
+  }
+  if (/^\{[^}]*$/.test(trimmed)) {
+    diagnostics.push(
+      makeDgmoError(
+        lineNumber,
+        `Unmatched '{' \u2014 auto-closing bracket`,
+        "warning"
+      )
+    );
+    const rawContent = trimmed.substring(1).trim();
+    const options = rawContent.split("|").map((s) => s.trim()).filter(Boolean);
+    const el = makeElement("dropdown", options[0] || "", lineNumber, indent);
+    el.options = options;
+    return el;
+  }
+  const pipeParts = trimmed.split(/\s*\|\s*/);
+  let textContent;
+  let states;
+  let metaStr;
+  if (pipeParts.length > 1) {
+    textContent = pipeParts[0].trim();
+    metaStr = pipeParts.slice(1).join(", ");
+    states = parseWireframeMetadata(metaStr).states;
+  } else {
+    const peeled = peelTrailingFlags(trimmed);
+    textContent = peeled.label;
+    states = peeled.states;
+    metaStr = states.length > 0 ? states.join(", ") : void 0;
+  }
+  const semanticStates = ["warning", "destructive", "success", "info"];
+  const hasSemantic = states.some((s) => semanticStates.includes(s));
+  if (hasSemantic) {
+    const el = makeElement("alert", textContent, lineNumber, indent);
+    el.states = states;
+    return el;
+  }
+  if (metaStr) {
+    const el = makeElement("text", textContent, lineNumber, indent);
+    applyMetadata(el, metaStr);
+    return el;
+  }
+  return makeElement("text", trimmed, lineNumber, indent);
+}
+function splitLineSegments(line) {
+  return line.split(/\s{2,}/).filter(Boolean);
+}
+function parseWireframe(content) {
+  resetWireframeIds();
+  const diagnostics = [];
+  const lines = content.split("\n");
+  let title = null;
+  let titleLineNumber = null;
+  let formFactor = "desktop";
+  const roots = [];
+  const modals = [];
+  const tagGroups = [];
+  const options = {};
+  let phase = "header";
+  let currentTagGroup = null;
+  function pushWarning(line, msg) {
+    diagnostics.push(makeDgmoError(line, msg, "warning"));
+  }
+  function makeTagGroup(trimmed, lineNumber) {
+    const match = matchTagBlockHeading(trimmed);
+    if (!match) return null;
+    return {
+      name: match.name,
+      ...match.alias !== void 0 && { alias: match.alias },
+      entries: [],
+      lineNumber
+    };
+  }
+  const indentStack = [];
+  function findParent(indent) {
+    while (indentStack.length > 0 && // In-bounds by length-check guard above.
+    indentStack[indentStack.length - 1].indent >= indent) {
+      const popped = indentStack.pop();
+      if (popped.node.children.length > 0 && !popped.node.isContainer) {
+        popped.node.isContainer = true;
+        if (popped.node.type === "textInput") {
+          popped.node.type = "group";
+        }
+      }
+    }
+    return indentStack.length > 0 ? (
+      // In-bounds by length-check.
+      indentStack[indentStack.length - 1].node
+    ) : null;
+  }
+  function pushElement(el) {
+    if (el.type === "modal") {
+      modals.push(el);
+      indentStack.push({ node: el, indent: el.indent });
+      return;
+    }
+    findParent(el.indent);
+    if (indentStack.length === 0) {
+      roots.push(el);
+    } else {
+      const parent = indentStack[indentStack.length - 1].node;
+      parent.children.push(el);
+      if (parent.type === "skeleton" || parent.isSkeleton) {
+        el.isSkeleton = true;
+      }
+    }
+    if (el.isContainer || el.type === "group" || el.type === "textInput" || // might become group if children follow
+    el.type === "nav" || el.type === "tabs" || el.type === "table" || el.type === "skeleton" || el.type === "alert") {
+      indentStack.push({ node: el, indent: el.indent });
+    }
+  }
+  function pushInlineRow(segments, lineNumber, indent, diags) {
+    const children = [];
+    let lastEl = null;
+    for (const seg of segments) {
+      if (seg.startsWith("|") && lastEl) {
+        applyMetadata(lastEl, seg.substring(1).trim());
+        continue;
+      }
+      const el = parseSegment(seg, lineNumber, indent, diags);
+      if (el) {
+        children.push(el);
+        lastEl = el;
+      }
+    }
+    if (children.length === 0) return;
+    if (children.length === 1) {
+      pushElement(children[0]);
+      return;
+    }
+    const wrapper = makeElement("group", "", lineNumber, indent);
+    wrapper.id = genId(lineNumber, indent, "row");
+    wrapper.isContainer = true;
+    wrapper.orientation = "horizontal";
+    wrapper.children = children;
+    const wrapperMetadata = { _inlineRow: "true" };
+    wrapper.metadata = wrapperMetadata;
+    pushElement(wrapper);
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    const indent = measureIndent(line);
+    if (phase === "header") {
+      const firstLineResult = parseFirstLine(trimmed);
+      if (firstLineResult?.chartType === "wireframe") {
+        title = firstLineResult.title || null;
+        titleLineNumber = lineNumber;
+        continue;
+      }
+      if (trimmed === "mobile") {
+        formFactor = "mobile";
+        continue;
+      }
+      if (tryParseSharedOption(trimmed, options)) {
+        continue;
+      }
+      const optMatch = trimmed.match(OPTION_NOCOLON_RE);
+      if (optMatch && KNOWN_OPTIONS.has(optMatch[1].toLowerCase())) {
+        options[optMatch[1]] = optMatch[2] || "";
+        continue;
+      }
+      if (isTagBlockHeading(trimmed)) {
+        const tg = makeTagGroup(trimmed, lineNumber);
+        if (tg) {
+          currentTagGroup = tg;
+          tagGroups.push(tg);
+          phase = "tags";
+          continue;
+        }
+      }
+      phase = "content";
+    }
+    if (phase === "tags") {
+      if (isTagBlockHeading(trimmed)) {
+        const tg = makeTagGroup(trimmed, lineNumber);
+        if (tg) {
+          currentTagGroup = tg;
+          tagGroups.push(tg);
+          continue;
+        }
+      }
+      if (indent > 0 && currentTagGroup) {
+        const { text: cleanEntry, isDefault } = stripDefaultModifier(trimmed);
+        const { label, color } = extractColor(
+          cleanEntry,
+          void 0,
+          diagnostics,
+          lineNumber
+        );
+        currentTagGroup.entries.push({
+          value: label,
+          color: color ?? AUTO_TAG_COLOR_SENTINEL,
+          lineNumber
+        });
+        if (isDefault) {
+          currentTagGroup.defaultValue = label;
+        } else if (currentTagGroup.entries.length === 1) {
+          currentTagGroup.defaultValue = label;
+        }
+        continue;
+      }
+      phase = "content";
+      currentTagGroup = null;
+    }
+    if (phase !== "content") {
+      phase = "content";
+    }
+    if (indent === 0 && trimmed === "mobile") {
+      formFactor = "mobile";
+      continue;
+    }
+    if (indent === 0) {
+      const optMatch = trimmed.match(OPTION_NOCOLON_RE);
+      if (optMatch && !trimmed.startsWith("#") && !trimmed.startsWith("[") && !trimmed.startsWith("(")) {
+        const key = optMatch[1];
+        if (["palette", "theme", "active-tag"].includes(key)) {
+          options[key] = optMatch[2] || "";
+          continue;
+        }
+      }
+    }
+    if (isTagBlockHeading(trimmed)) {
+      const tg = makeTagGroup(trimmed, lineNumber);
+      if (tg) {
+        currentTagGroup = tg;
+        tagGroups.push(tg);
+        phase = "tags";
+        continue;
+      }
+    }
+    if (indentStack.length > 0) {
+      const topNode = indentStack[indentStack.length - 1].node;
+      if (topNode.type === "table" && indent > topNode.indent) {
+        const cells = parseTableRow(trimmed);
+        if (!topNode.tableHeaders) {
+          if (trimmed.includes(",")) {
+            topNode.tableHeaders = cells;
+          } else {
+            topNode.tableHeaders = cells;
+          }
+        } else {
+          if (!topNode.tableData) topNode.tableData = [];
+          topNode.tableData.push(cells);
+        }
+        continue;
+      }
+    }
+    const segments = splitLineSegments(trimmed);
+    if (segments.length === 1) {
+      const el = parseSegment(segments[0], lineNumber, indent, diagnostics);
+      if (el) pushElement(el);
+    } else if (segments.length === 2) {
+      if (segments[1].startsWith("|")) {
+        const el = parseSegment(segments[0], lineNumber, indent, diagnostics);
+        if (el) {
+          applyMetadata(el, segments[1].substring(1).trim());
+          pushElement(el);
+        }
+      } else {
+        const firstIsBare = isBareText(segments[0]);
+        const secondIsElement = hasBracketMnemonic(segments[1]);
+        if (firstIsBare && secondIsElement) {
+          const fieldEl = parseSegment(
+            segments[1],
+            lineNumber,
+            indent,
+            diagnostics
+          );
+          if (fieldEl) {
+            const labelEl = makeElement(
+              "text",
+              segments[0].trim(),
+              lineNumber,
+              indent
+            );
+            labelEl.id = genId(lineNumber, indent, "lbl");
+            labelEl.labelFor = fieldEl;
+            const wrapper = makeElement("group", "", lineNumber, indent);
+            wrapper.id = genId(lineNumber, indent, "lf");
+            wrapper.isContainer = true;
+            wrapper.orientation = "horizontal";
+            wrapper.children.push(labelEl, fieldEl);
+            const wrapperMetadata = {
+              _labelField: "true"
+            };
+            wrapper.metadata = wrapperMetadata;
+            pushElement(wrapper);
+          }
+        } else {
+          pushInlineRow(segments, lineNumber, indent, diagnostics);
+        }
+      }
+    } else {
+      pushInlineRow(segments, lineNumber, indent, diagnostics);
+    }
+  }
+  while (indentStack.length > 0) {
+    const popped = indentStack.pop();
+    if (popped.node.children.length > 0 && !popped.node.isContainer) {
+      popped.node.isContainer = true;
+      if (popped.node.type === "textInput") {
+        popped.node.type = "group";
+      }
+    }
+  }
+  finalizeAutoTagColors(tagGroups);
+  validateTagGroupNames(tagGroups, pushWarning, (line, msg) => {
+    diagnostics.push(makeDgmoError(line, msg));
+  });
+  const error = diagnostics.find((d) => d.severity === "error") ? formatDgmoError(diagnostics.find((d) => d.severity === "error")) : null;
+  return {
+    title,
+    titleLineNumber,
+    formFactor,
+    roots,
+    modals,
+    tagGroups,
+    options,
+    diagnostics,
+    error
+  };
+}
+function parseTableRow(line) {
+  const cells = [];
+  let current = "";
+  let depth = 0;
+  let escaped = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (escaped) {
+      current += ch;
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (ch === "[" || ch === "{" || ch === "(" || ch === "<") depth++;
+    if (ch === "]" || ch === "}" || ch === ")" || ch === ">")
+      depth = Math.max(0, depth - 1);
+    if (ch === "," && depth === 0) {
+      cells.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) {
+    cells.push(current.trim());
+  }
+  return cells;
+}
+function isBareText(segment) {
+  const s = segment.trim();
+  if (!s) return false;
+  if (/^[[\]({<#-]/.test(s)) return false;
+  if (matchKeyword(s)) return false;
+  return true;
+}
+function hasBracketMnemonic(segment) {
+  const s = segment.trim();
+  return /^\[/.test(s) || /^\(/.test(s) || /^\{/.test(s) || /^<\s*x?\s*>/i.test(s);
+}
+
+export {
+  GROUP_ONLY_METADATA,
+  STATE_KEYWORDS,
+  resetWireframeIds,
+  parseWireframe
+};
+//# sourceMappingURL=chunk-EVCVDTXE.js.map