@eriknaslund/skiss 0.4.0 → 0.6.0

package/dist/index.js

@@ -1,3 +1,82 @@
+// src/inheritance.ts
+function inheritance(classes) {
+  const declared = /* @__PURE__ */ new Map();
+  for (const cls of classes) {
+    if (!declared.has(cls.name.text)) declared.set(cls.name.text, cls);
+  }
+  const circles = /* @__PURE__ */ new Map();
+  const parentOf = (cls) => {
+    if (cls.parent === void 0 || circles.has(cls)) return void 0;
+    return declared.get(cls.parent.text);
+  };
+  for (const cls of declared.values()) {
+    const path = [cls];
+    const seen = new Set(path);
+    for (let next = parentOf(cls); next !== void 0; next = parentOf(next)) {
+      if (seen.has(next)) {
+        const circle = path.slice(path.indexOf(next));
+        let closer = circle[0];
+        for (const member2 of circle) {
+          if (member2.line > closer.line) closer = member2;
+        }
+        const at = circle.indexOf(closer);
+        circles.set(closer, [...circle.slice(at), ...circle.slice(0, at)]);
+        break;
+      }
+      path.push(next);
+      seen.add(next);
+    }
+  }
+  const ancestors = (cls) => {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set([cls]);
+    for (let next = parentOf(cls); next !== void 0; next = parentOf(next)) {
+      if (seen.has(next)) break;
+      out.push(next);
+      seen.add(next);
+    }
+    return out;
+  };
+  const find = (cls, matches) => {
+    for (const from of ancestors(cls)) {
+      const field = from.fields.find(matches);
+      if (field !== void 0) return { field, from };
+    }
+    return void 0;
+  };
+  return {
+    ancestors,
+    inherited: (cls, fieldName) => find(cls, (field) => field.name.text === fieldName),
+    inheritedIdentifier: (cls) => find(cls, (field) => field.identifier),
+    circle: (cls) => circles.get(cls)
+  };
+}
+function sameField(child, inheritedField) {
+  return meaning(child) === meaning(inheritedField);
+}
+var meaning = (field) => JSON.stringify([
+  field.name.text,
+  field.identifier,
+  typeMeaning(field),
+  field.system?.text,
+  field.joinsTo === void 0 ? void 0 : [field.joinsTo.className.text, field.joinsTo.fieldName.text],
+  field.description,
+  field.note
+]);
+function typeMeaning(field) {
+  const type = field.type;
+  if (type === void 0) return void 0;
+  switch (type.kind) {
+    case "primitive":
+      return [type.kind, type.name, type.many];
+    case "class":
+    case "unknown":
+      return [type.kind, type.name.text, type.many];
+    case "enum":
+      return [type.kind, type.values.map((v) => v.text), type.many];
+  }
+}
+
 // src/parse.ts
 var isWs = (c) => c === " " || c === "	";
 var trimWs = (s) => s.replace(/^[ \t]+/, "").replace(/[ \t]+$/, "");
@@ -21,7 +100,7 @@ function primitiveFor(word) {
   return Object.hasOwn(PRIMITIVES, word) ? PRIMITIVES[word] : void 0;
 }
 var FIELD_ORDER = "name, `*`, `: type`, `@System`, `= Class.field`, then `#` and `?`";
-var CLASS_ORDER = "name, `@System`, `~ Class`, then `#` and `?`";
+var CLASS_ORDER = "name, `< Parent`, `@System`, `~ Class`, then `#` and `?`";
 function parse(source) {
   const classes = [];
   const diagnostics = [];
@@ -108,7 +187,11 @@ function splitTrailer(text) {
   return trailer;
 }
 var WORD = /[\p{L}\p{N}_-]+/uy;
-var OPERATORS = ["*", ":", "@", "~", "=", ".", "|", "["];
+function wordAt(text, i) {
+  WORD.lastIndex = i;
+  return WORD.exec(text)?.[0];
+}
+var OPERATORS = ["*", ":", "@", "~", "=", ".", "|", "<", ",", "["];
 function tokenize(head) {
   const tokens = [];
   let i = 0;
@@ -118,11 +201,10 @@ function tokenize(head) {
       i++;
       continue;
     }
-    WORD.lastIndex = i;
-    const word = WORD.exec(head);
-    if (word !== null) {
-      tokens.push({ kind: "word", text: word[0], col: i, end: i + word[0].length });
-      i += word[0].length;
+    const word = wordAt(head, i);
+    if (word !== void 0) {
+      tokens.push({ kind: "word", text: word, col: i, end: i + word.length });
+      i += word.length;
       continue;
     }
     if (c === "[" && head[i + 1] === "]") {
@@ -170,6 +252,13 @@ function parseClassLine(text, line) {
     );
   }
   const node = { name: name(head, line), line };
+  const lt = peek(c);
+  if (lt?.kind === "<") {
+    take(c);
+    const parent = parseParent(c, lt);
+    if (!parent.ok) return parent;
+    node.parent = parent.value;
+  }
   const at = peek(c);
   if (at?.kind === "@") {
     take(c);
@@ -299,6 +388,31 @@ function parseFieldLine(text, line) {
   if (trailer.note !== void 0) node.note = trailer.note;
   return { ok: true, value: node };
 }
+function parseParent(c, lt) {
+  const parent = take(c);
+  if (parent === void 0 || parent.kind !== "word") {
+    return fail(
+      "E_UNPARSABLE",
+      "Expected a class name after `<`, e.g. `Jedi < Character`",
+      c.line,
+      parent ?? afterSpan(lt)
+    );
+  }
+  if (!CLASS_NAME.test(parent.text)) {
+    const message = Object.hasOwn(PRIMITIVES, parent.text) ? `\`${parent.text}\` is a primitive, not a class; a parent is a class` : `The class after \`<\` must be UpperCamelCase: \`${parent.text}\``;
+    return fail("E_BAD_NAME", message, c.line, parent);
+  }
+  const next = peek(c);
+  if (next?.kind === "," || next?.kind === "<") {
+    return fail(
+      "E_UNPARSABLE",
+      "A class has one parent; `<` takes a single class name",
+      c.line,
+      next
+    );
+  }
+  return { ok: true, value: name(parent, c.line) };
+}
 function parseSystem(c, at) {
   const system = take(c);
   if (system === void 0 || system.kind !== "word") {
@@ -407,36 +521,36 @@ function parseType(c, colon) {
     first
   );
 }
-function unexpected(token, line, kind, order) {
-  const modifiers = kind === "field" ? ["*", ":", "@", "="] : ["@", "~"];
-  if (modifiers.includes(token.kind)) {
+function unexpected(token2, line, kind, order) {
+  const modifiers = kind === "field" ? ["*", ":", "@", "="] : ["<", "@", "~"];
+  if (modifiers.includes(token2.kind)) {
     return fail(
       "E_UNPARSABLE",
-      `\`${token.text}\` is out of order; a ${kind} line reads: ${order}`,
+      `\`${token2.text}\` is out of order; a ${kind} line reads: ${order}`,
       line,
-      token
+      token2
     );
   }
-  if (token.text === "<") {
+  if (token2.kind === "<") {
     return fail(
       "E_UNPARSABLE",
-      "`<` is reserved for inheritance and not yet part of the language",
+      "`<` marks inheritance and belongs on the class line: `Child < Parent`",
       line,
-      token
+      token2
     );
   }
-  if (token.text === "?") {
+  if (token2.text === "?") {
     return fail(
       "E_UNPARSABLE",
       "`?` attached to a word is not a marker; a doubt needs whitespace before `?` and after it",
       line,
-      token
+      token2
     );
   }
-  if (token.text === "#") {
-    return fail("E_UNPARSABLE", "A description needs whitespace before `#`", line, token);
+  if (token2.text === "#") {
+    return fail("E_UNPARSABLE", "A description needs whitespace before `#`", line, token2);
   }
-  return fail("E_UNPARSABLE", `Unexpected \`${token.text}\` on a ${kind} line`, line, token);
+  return fail("E_UNPARSABLE", `Unexpected \`${token2.text}\` on a ${kind} line`, line, token2);
 }
 
 // src/resolve.ts
@@ -449,10 +563,14 @@ function resolve(doc) {
   };
   const classes = out.classes;
   const declared = new Set(classes.map((c) => c.name.text));
-  const warnings = [];
+  const found = [];
   const undeclared = /* @__PURE__ */ new Map();
+  const tree = inheritance(classes);
   const warn = (code, message, at) => {
-    warnings.push({ severity: "warning", code, message, line: at.line, col: at.col, end: at.end });
+    found.push({ severity: "warning", code, message, line: at.line, col: at.col, end: at.end });
+  };
+  const error = (code, message, at) => {
+    found.push({ severity: "error", code, message, line: at.line, col: at.col, end: at.end });
   };
   const reference = (name2) => {
     if (declared.has(name2.text)) return true;
@@ -473,9 +591,25 @@ function resolve(doc) {
         cls.name
       );
     }
+    const parent = cls.parent;
+    if (parent !== void 0) {
+      reference(parent);
+      const circle = tree.circle(cls);
+      if (circle !== void 0) {
+        const through = circle.slice(1).map((member2) => `\`${member2.name.text}\``);
+        const path = through.length === 0 ? "" : ` through ${through.join(", ")}`;
+        error(
+          "E_INHERITANCE_CYCLE",
+          `class \`${cls.name.text}\` inherits from itself${path}; this \`<\` is not carried`,
+          parent
+        );
+        cls.parent = void 0;
+      }
+    }
     if (cls.similarTo !== void 0) reference(cls.similarTo);
     const firstField = /* @__PURE__ */ new Map();
-    let identifier;
+    const inheritedIdentifier = tree.inheritedIdentifier(cls);
+    let identifier = inheritedIdentifier?.field;
     for (const field of cls.fields) {
       const earlierField = firstField.get(field.name.text);
       if (earlierField === void 0) firstField.set(field.name.text, field);
@@ -489,14 +623,23 @@ function resolve(doc) {
       if (field.identifier) {
         if (identifier === void 0) identifier = field;
         else {
+          const from = identifier === inheritedIdentifier?.field ? ` inherits the identifier \`${identifier.name.text}\` from class \`${inheritedIdentifier.from.name.text}\`, line` : ` already has the identifier \`${identifier.name.text}\` on line`;
           warn(
             "W_MULTIPLE_IDENTIFIERS",
-            `\`*\` on \`${field.name.text}\` is ignored: class \`${cls.name.text}\` already has the identifier \`${identifier.name.text}\` on line ${identifier.line}`,
+            `\`*\` on \`${field.name.text}\` is ignored: class \`${cls.name.text}\`${from} ${identifier.line}`,
             field.identifierAt ?? field.name
           );
           field.identifier = false;
         }
       }
+      const replaced = tree.inherited(cls, field.name.text);
+      if (replaced !== void 0 && sameField(field, replaced.field)) {
+        warn(
+          "W_REDUNDANT_OVERRIDE",
+          `field \`${field.name.text}\` is identical to the one inherited from class \`${replaced.from.name.text}\` on line ${replaced.field.line}`,
+          field.name
+        );
+      }
       if (field.type?.kind === "unknown") {
         const word = field.type.name.text;
         const suggestion = closestTypeWord(word);
@@ -534,8 +677,8 @@ function resolve(doc) {
     }
   }
   const present2 = new Set(out.diagnostics.map(key));
-  for (const w of warnings) {
-    if (!present2.has(key(w))) out.diagnostics.push(w);
+  for (const d of found) {
+    if (!present2.has(key(d))) out.diagnostics.push(d);
   }
   out.diagnostics.sort((a, b) => a.line - b.line);
   out.undeclared = [...undeclared.values()].map((n) => ({ ...n }));
@@ -566,6 +709,7 @@ function copyField(f) {
 }
 function copyClass(c) {
   const out = { ...c, name: copyName(c.name), fields: c.fields.map(copyField) };
+  if (c.parent !== void 0) out.parent = copyName(c.parent);
   if (c.system !== void 0) out.system = copyName(c.system);
   if (c.similarTo !== void 0) out.similarTo = copyName(c.similarTo);
   return out;
@@ -744,6 +888,7 @@ function buildClass(cls, mappingPrefix, enums) {
   const { node, fields } = cls;
   const out = {};
   if (node.description !== void 0) out.description = node.description;
+  if (node.parent !== void 0) out.is_a = node.parent.text;
   const annotations = {};
   if (node.system !== void 0) annotations.system = node.system.text;
   if (node.note !== void 0) annotations.note = node.note;
@@ -826,6 +971,7 @@ function toMermaid(doc, opts) {
   }
   for (const cls of resolved.classes) {
     const from = cls.name.text;
+    if (cls.parent !== void 0) lines.push(`  ${cls.parent.text} <|-- ${from}`);
     if (cls.similarTo !== void 0) lines.push(`  ${from} ..> ${cls.similarTo.text} : similar`);
     for (const field of cls.fields) {
       const type = field.type;
@@ -932,7 +1078,7 @@ function toSkiss(doc) {
 `;
 }
 function classBlock(cls) {
-  const head = cls.name.text + (cls.system === void 0 ? "" : ` @${cls.system.text}`) + (cls.similarTo === void 0 ? "" : ` ~ ${cls.similarTo.text}`);
+  const head = cls.name.text + (cls.parent === void 0 ? "" : ` < ${cls.parent.text}`) + (cls.system === void 0 ? "" : ` @${cls.system.text}`) + (cls.similarTo === void 0 ? "" : ` ~ ${cls.similarTo.text}`);
   return [withTrailer(head, cls), ...cls.fields.map(fieldLine)].join("\n");
 }
 function fieldLine(field) {
@@ -986,7 +1132,14 @@ var PRIMITIVE_RANGE = {
   uri: "uri",
   uriorcurie: "uri"
 };
-var CLASS_KEYS = /* @__PURE__ */ new Set(["description", "annotations", "close_mappings", "attributes", "slots"]);
+var CLASS_KEYS = /* @__PURE__ */ new Set([
+  "description",
+  "is_a",
+  "annotations",
+  "close_mappings",
+  "attributes",
+  "slots"
+]);
 var SLOT_KEYS = /* @__PURE__ */ new Set(["description", "annotations", "range", "multivalued", "identifier"]);
 var CLASS_TAGS = /* @__PURE__ */ new Set(["system", "note", "undeclared"]);
 var SLOT_TAGS = /* @__PURE__ */ new Set(["system", "note", "joins_to"]);
@@ -1029,7 +1182,7 @@ function fromLinkML(schema) {
   for (const key2 of Object.keys(classDefs)) {
     const names = /* @__PURE__ */ new Map();
     const taken = /* @__PURE__ */ new Set();
-    for (const slot of slotKeysOf(asRecord(get(classDefs, key2)) ?? {})) {
+    for (const slot of fieldKeysOf(key2)) {
       names.set(slot, unique(toFieldName(slot), taken));
     }
     fieldNames.set(key2, names);
@@ -1099,6 +1252,12 @@ function fromLinkML(schema) {
       const note = oneLine(rawNote);
       if (note !== void 0) node.note = note;
     } else if (rawNote !== void 0) report("annotation", name2, notText("note", rawNote));
+    const parent = stringOf(get(def, "is_a"));
+    if (parent !== void 0) {
+      const parentName = Object.hasOwn(classDefs, parent) ? classNameOf(parent) : toClassName(parent);
+      node.parent = at0(parentName);
+      reference(name2, parent, parentName);
+    }
     const mappings = stringList(get(def, "close_mappings"));
     const first = mappings[0];
     const target = first === void 0 ? "" : localName(first);
@@ -1121,6 +1280,9 @@ function fromLinkML(schema) {
           }
         }
         const block = get(def, other);
+        if (other === "is_a" && present(block) && stringOf(block) === void 0) {
+          report("is_a", name2, `${shown(block)} is not a class name`);
+        }
         if (other === "attributes" && present(block) && asRecord(block) === void 0) {
           report("attributes", name2, `${shown(block)} is not a map`);
         }
@@ -1135,10 +1297,12 @@ function fromLinkML(schema) {
           report("slot_usage", name2);
           continue;
         }
+        const written = slotKeysOf(def);
+        const inherited = inheritedSlots(key2);
         for (const slot of Object.keys(usage)) {
-          if (fieldNames.get(key2)?.has(slot) === true) {
+          if (written.includes(slot)) {
             report("slot_usage", `${name2}.${fieldNameOf(key2, slot)}`);
-          } else {
+          } else if (!inherited.has(slot)) {
             report("slot_usage", name2, `\`${slot}\` is inherited and not in the sketch`);
           }
         }
@@ -1146,9 +1310,10 @@ function fromLinkML(schema) {
       }
       report(other, name2);
     }
-    for (const slot of slotKeysOf(def)) {
+    const own = slotKeysOf(def);
+    for (const slot of fieldKeysOf(key2)) {
       const attributes = asRecord(get(def, "attributes")) ?? {};
-      const rawSlot = Object.hasOwn(attributes, slot) ? get(attributes, slot) : get(slotDefs, slot);
+      const rawSlot = !own.includes(slot) ? get(asRecord(get(def, "slot_usage")) ?? {}, slot) : Object.hasOwn(attributes, slot) ? get(attributes, slot) : get(slotDefs, slot);
       const slotDef = asRecord(rawSlot);
       if (slotDef === void 0 && present(rawSlot)) {
         report("slot", `${name2}.${fieldNameOf(key2, slot)}`, "is not a slot definition");
@@ -1285,6 +1450,34 @@ function fromLinkML(schema) {
     report("narrowed", element, `\`${range}\` is not a Skiss type; it falls back to string`);
     return { kind: "unknown", name: at0(word), many };
   }
+  function parentKeyOf(classKey) {
+    const def = asRecord(get(classDefs, classKey)) ?? {};
+    const parent = stringOf(get(def, "is_a"));
+    if (parent === void 0 || !Object.hasOwn(classDefs, parent)) return void 0;
+    return parent;
+  }
+  function inheritedSlots(classKey) {
+    const out = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set([classKey]);
+    let key2 = parentKeyOf(classKey);
+    while (key2 !== void 0 && !seen.has(key2)) {
+      seen.add(key2);
+      for (const slot of slotKeysOf(asRecord(get(classDefs, key2)) ?? {})) out.add(slot);
+      key2 = parentKeyOf(key2);
+    }
+    return out;
+  }
+  function fieldKeysOf(classKey) {
+    const def = asRecord(get(classDefs, classKey)) ?? {};
+    const keys = slotKeysOf(def);
+    const usage = asRecord(get(def, "slot_usage"));
+    if (usage === void 0) return keys;
+    const inherited = inheritedSlots(classKey);
+    for (const slot of Object.keys(usage)) {
+      if (inherited.has(slot) && !keys.includes(slot)) keys.push(slot);
+    }
+    return keys;
+  }
   function listedSomewhere(slot) {
     for (const key2 of Object.keys(classDefs)) {
       const def = asRecord(get(classDefs, key2)) ?? {};
@@ -1443,6 +1636,204 @@ var nothing = (element, detail) => ({
   dropped: [{ kind: UNREADABLE, element, detail }]
 });
 
+// src/highlight.ts
+var TRAILING_WS = /[ \t]+$/;
+function tokenizeLine(line) {
+  const text = line.replace(TRAILING_WS, "");
+  const first = text[0];
+  if (first === void 0) {
+    return [];
+  }
+  if (first === "#") {
+    return [{ kind: "comment", from: 0, to: text.length }];
+  }
+  const { head, trailers } = splitTrailer2(text);
+  return [...headTokens(head, isWs(first)), ...trailers];
+}
+function splitTrailer2(text) {
+  let start = -1;
+  for (let i = 1; i < text.length; i++) {
+    if (!isWs(text[i - 1])) {
+      continue;
+    }
+    if (text[i] === "#" || isDoubtMarker(text, i)) {
+      start = i;
+      break;
+    }
+  }
+  if (start < 0) {
+    return { head: text, trailers: [] };
+  }
+  const head = text.slice(0, start);
+  if (text[start] === "?") {
+    return { head, trailers: [{ kind: "doubt", from: start, to: text.length }] };
+  }
+  let doubt = -1;
+  for (let i = start + 1; i < text.length; i++) {
+    if (isDoubtMarker(text, i)) {
+      doubt = i;
+      break;
+    }
+  }
+  if (doubt < 0) {
+    return { head, trailers: [{ kind: "description", from: start, to: text.length }] };
+  }
+  return {
+    head,
+    trailers: [
+      // The whitespace between the two belongs to neither.
+      {
+        kind: "description",
+        from: start,
+        to: text.slice(0, doubt).replace(TRAILING_WS, "").length
+      },
+      { kind: "doubt", from: doubt, to: text.length }
+    ]
+  };
+}
+function scan(head) {
+  const raws = [];
+  let i = 0;
+  while (i < head.length) {
+    const c = head[i] ?? "";
+    if (isWs(c)) {
+      i += 1;
+      continue;
+    }
+    const word = wordAt(head, i);
+    if (word !== void 0) {
+      raws.push({ text: word, from: i, to: i + word.length, word: true });
+      i += word.length;
+      continue;
+    }
+    if (c === "[" && head[i + 1] === "]") {
+      raws.push({ text: "[]", from: i, to: i + 2, word: false });
+      i += 2;
+      continue;
+    }
+    const ch = String.fromCodePoint(head.codePointAt(i) ?? 0);
+    raws.push({ text: ch, from: i, to: i + ch.length, word: false });
+    i += ch.length;
+  }
+  return raws;
+}
+var token = (kind, raw) => ({ kind, from: raw.from, to: raw.to });
+function headTokens(head, field) {
+  const raws = scan(head);
+  const tokens = [];
+  let i = 0;
+  const name2 = raws[0];
+  if (name2?.word === true && (field ? FIELD_NAME : CLASS_NAME).test(name2.text)) {
+    tokens.push(token(field ? "field" : "class", name2));
+    i = 1;
+  }
+  while (i < raws.length) {
+    const raw = raws[i];
+    i += 1;
+    if (raw === void 0 || raw.word) {
+      continue;
+    }
+    switch (raw.text) {
+      case "*":
+        tokens.push(token("marker", raw));
+        break;
+      case ":":
+        tokens.push(token("operator", raw));
+        i = typeTokens(raws, i, tokens);
+        break;
+      case "@":
+        tokens.push(token("operator", raw));
+        i = nameToken(raws, i, tokens, "system", SYSTEM_NAME);
+        break;
+      case "~":
+      case "<":
+        tokens.push(token("operator", raw));
+        i = nameToken(raws, i, tokens, "class", CLASS_NAME);
+        break;
+      case "=":
+        tokens.push(token("operator", raw));
+        i = joinTokens(raws, i, tokens);
+        break;
+      case "|":
+      case "[]":
+        tokens.push(token("operator", raw));
+        break;
+      default:
+        break;
+    }
+  }
+  return tokens;
+}
+function nameToken(raws, i, tokens, kind, shape) {
+  const raw = raws[i];
+  if (raw === void 0 || !raw.word) {
+    return i;
+  }
+  if (shape.test(raw.text)) {
+    tokens.push(token(kind, raw));
+  }
+  return i + 1;
+}
+function joinTokens(raws, start, tokens) {
+  let i = nameToken(raws, start, tokens, "class", CLASS_NAME);
+  const dot = raws[i];
+  if (dot === void 0 || dot.text !== "." || dot.word) {
+    return i;
+  }
+  tokens.push(token("operator", dot));
+  i += 1;
+  return nameToken(raws, i, tokens, "field", FIELD_NAME);
+}
+function typeTokens(raws, start, tokens) {
+  const first = raws[start];
+  if (first === void 0 || !first.word) {
+    return start;
+  }
+  const words = [first];
+  const operators = [];
+  let pipes = 0;
+  let i = start + 1;
+  while (raws[i]?.text === "|") {
+    const pipe = raws[i];
+    if (pipe === void 0) {
+      break;
+    }
+    operators.push(pipe);
+    pipes += 1;
+    i += 1;
+    const value = raws[i];
+    if (value === void 0 || !value.word) {
+      break;
+    }
+    words.push(value);
+    i += 1;
+  }
+  const many = raws[i];
+  if (many !== void 0 && many.text === "[]" && !many.word) {
+    operators.push(many);
+    i += 1;
+  }
+  const typed = pipes > 0 ? words.filter((word) => ENUM_VALUE.test(word.text)).map((word) => token("enum", word)) : nameTypeTokens(first);
+  tokens.push(
+    ...[...typed, ...operators.map((raw) => token("operator", raw))].sort(
+      (a, b) => a.from - b.from
+    )
+  );
+  return i;
+}
+function nameTypeTokens(word) {
+  if (primitiveFor(word.text) !== void 0) {
+    return [token("primitive", word)];
+  }
+  if (CLASS_NAME.test(word.text)) {
+    return [token("class", word)];
+  }
+  if (/^[a-z]/.test(word.text)) {
+    return [token("type", word)];
+  }
+  return [];
+}
+
 // src/import.ts
 import { parse as parseYAML } from "yaml";
 function importLinkML(text) {
@@ -1467,7 +1858,7 @@ function notYAML(error) {
 }
 
 // src/index.ts
-var VERSION = "0.4.0";
+var VERSION = "0.6.0";
 export {
   VERSION,
   compile,
@@ -1480,6 +1871,7 @@ export {
   serialize,
   toLinkML,
   toMermaid,
-  toSkiss
+  toSkiss,
+  tokenizeLine
 };
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eriknaslund/skiss",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "A text notation for sketching data models, compiled to LinkML",
   "type": "module",
   "license": "MIT",
@@ -41,7 +41,8 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.13",
-    "@types/node": "^24.0.0",
+    "@mermaid-js/mermaid-cli": "^11.17.0",
+    "@types/node": "^26.6.1",
     "jsdom": "^30.0.1",
     "mermaid": "^12.0.0",
     "tsup": "^8.5.1",