@citisen/litearea 0.1.0 → 0.2.0

package/dist/grammars.cjs

@@ -1,1228 +0,0 @@
-'use strict';
-
-// src/core/grammar.ts
-function defineGrammar(grammar) {
-  return grammar;
-}
-
-// src/core/format.ts
-var DEFAULT_LIST_LIMIT = 12;
-function fillTemplate(template, values) {
-  return String(template).replace(
-    /\{(\w+)\}/g,
-    (match, key) => Object.hasOwn(values, key) ? String(values[key]) : match
-  );
-}
-function listPhrase(items, options) {
-  const conjunction = options?.conjunction;
-  const limit = options?.limit ?? DEFAULT_LIST_LIMIT;
-  const shown = items.slice(0, limit);
-  const rest = items.length - shown.length;
-  if (shown.length === 0) return "";
-  if (shown.length === 1) {
-    return rest > 0 ? `${String(shown[0])} and ${String(rest)} more` : String(shown[0]);
-  }
-  if (shown.length === 2) {
-    const pair = `${String(shown[0])} ${conjunction} ${String(shown[1])}`;
-    return rest > 0 ? `${pair}, and ${String(rest)} more` : pair;
-  }
-  const head = shown.slice(0, -1).join(", ");
-  const tail = shown[shown.length - 1];
-  const phrase = `${head}, ${conjunction} ${String(tail)}`;
-  return rest > 0 ? `${phrase}, and ${String(rest)} more` : phrase;
-}
-
-// src/core/vocabulary.ts
-function defineVocabulary(spec) {
-  const caseSensitive = spec.caseSensitive === true;
-  const unknownScope = spec.unknownScope ?? "invalid";
-  const defaultScope = `vocabulary:${spec.id}`;
-  const unknownCode = spec.unknownCode ?? `vocabulary:${spec.id}`;
-  const unknownSeverity = spec.unknownSeverity ?? "error";
-  const fold = (word) => caseSensitive ? word : word.toLowerCase();
-  const memberOf = (word, allowed) => {
-    const needle = fold(word);
-    return allowed.find((candidate) => fold(candidate) === needle);
-  };
-  const docOf = (word) => {
-    if (spec.docs === void 0) return void 0;
-    for (const [key, value] of Object.entries(spec.docs)) {
-      if (fold(key) !== fold(word)) continue;
-      return typeof value === "string" ? { body: value } : value;
-    }
-    return void 0;
-  };
-  return {
-    id: spec.id,
-    caseSensitive,
-    resolve: (context) => {
-      const words = typeof spec.words === "function" ? spec.words(context) : spec.words;
-      return Array.isArray(words) ? words : [];
-    },
-    has: (word, context) => {
-      const words = typeof spec.words === "function" ? spec.words(context) : spec.words;
-      return memberOf(word, Array.isArray(words) ? words : []) !== void 0;
-    },
-    scopeFor: (word) => {
-      if (typeof spec.scope === "function") return spec.scope(memberOf(word, [word]) ?? word);
-      return spec.scope ?? defaultScope;
-    },
-    unknownScope,
-    reject: (word, context) => {
-      if (spec.unknownMessage === void 0) return void 0;
-      const allowed = typeof spec.words === "function" ? spec.words(context) : spec.words;
-      const members = Array.isArray(allowed) ? allowed : [];
-      const message = typeof spec.unknownMessage === "function" ? spec.unknownMessage(word, members) : fillTemplate(spec.unknownMessage, {
-        word,
-        allowed: listPhrase(members, { conjunction: "or" })
-      });
-      return { message, severity: unknownSeverity, code: unknownCode };
-    },
-    entryFor: (word) => docOf(word),
-    format: (word) => spec.format === void 0 ? word : spec.format(word)
-  };
-}
-
-// src/grammars/dshFont.ts
-var FONT_WEIGHT_WORDS = {
-  thin: 100,
-  hairline: 100,
-  extralight: 200,
-  ultralight: 200,
-  light: 300,
-  book: 400,
-  normal: 400,
-  regular: 400,
-  roman: 400,
-  medium: 500,
-  demibold: 600,
-  semibold: 600,
-  bold: 700,
-  extrabold: 800,
-  ultrabold: 800,
-  black: 900,
-  heavy: 900,
-  extrablack: 900,
-  ultrablack: 900
-};
-var FONT_WEIGHT_SCALE = [100, 200, 300, 400, 500, 600, 700, 800, 900];
-var FONT_WEIGHT_LABELS = {
-  100: "thin",
-  200: "extralight",
-  300: "light",
-  400: "regular",
-  500: "medium",
-  600: "semibold",
-  700: "bold",
-  800: "extrabold",
-  900: "black"
-};
-var FONT_GENERIC_FAMILIES = [
-  "system-ui",
-  "sans-serif",
-  "serif",
-  "monospace",
-  "cursive",
-  "fantasy",
-  "math",
-  "emoji",
-  "fangsong",
-  "ui-sans-serif",
-  "ui-serif",
-  "ui-monospace",
-  "ui-rounded"
-];
-var FONT_COMMON_FAMILIES = [
-  "Inter",
-  "IBM Plex Sans",
-  "IBM Plex Mono",
-  "Noto Sans",
-  "Noto Sans SC",
-  "Noto Serif",
-  "Source Han Sans SC",
-  "Source Han Serif SC",
-  "JetBrains Mono",
-  "Fira Code",
-  "Fira Sans",
-  "Cascadia Code",
-  "Cascadia Mono",
-  "Maple Mono",
-  "Roboto",
-  "Roboto Mono",
-  "Open Sans",
-  "Lato",
-  "Montserrat",
-  "Poppins",
-  "Ubuntu",
-  "Ubuntu Mono",
-  "DejaVu Sans",
-  "DejaVu Sans Mono",
-  "Hack",
-  "Inconsolata",
-  "Iosevka",
-  "Comic Sans MS",
-  "PingFang SC",
-  "Hiragino Sans GB",
-  "Microsoft YaHei",
-  "Microsoft YaHei UI",
-  "Microsoft JhengHei",
-  "SimSun",
-  "SimHei",
-  "KaiTi",
-  "Segoe UI",
-  "Segoe UI Variable",
-  "Helvetica Neue",
-  "Arial",
-  "Consolas",
-  "Menlo",
-  "Monaco",
-  "SF Mono",
-  "Courier New",
-  "Times New Roman",
-  "Georgia"
-];
-var SCOPE = {
-  family: "family",
-  generic: "family.generic",
-  unknown: "family.unknown",
-  unclosed: "family.unclosed",
-  weight: "weight",
-  weightMissing: "weight.missing",
-  separator: "separator"
-};
-function fontWeightWord(weight) {
-  return FONT_WEIGHT_LABELS[weight] ?? String(weight);
-}
-function fontFaceWeights(styles) {
-  if (styles === void 0) return [];
-  const found = /* @__PURE__ */ new Set();
-  for (const style of styles) {
-    const text = String(style).toLowerCase().replace(/\b(semi|demi)\s+(?=[a-z])/g, "semi").replace(/\b(extra|ultra)\s+(?=[a-z])/g, "extra");
-    for (const word of text.split(/[^a-z]+/)) {
-      const weight = FONT_WEIGHT_WORDS[word];
-      if (weight !== void 0) found.add(weight);
-    }
-  }
-  return [...found].sort((left, right) => left - right);
-}
-function quoteFontFamily(family) {
-  const name = family.trim();
-  if (name === "") return "";
-  if (/^-?[A-Za-z][\w-]*$/.test(name)) return name;
-  return `"${name.replaceAll('"', "")}"`;
-}
-function isGenericName(name, generics) {
-  return generics.includes(name);
-}
-function splitEntries(source) {
-  const bounds = [];
-  let start = 0;
-  let quote = "";
-  for (let index = 0; index < source.length; index += 1) {
-    const char = source.charAt(index);
-    if (quote !== "") {
-      if (char === quote) quote = "";
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      quote = char;
-      continue;
-    }
-    if (char === ",") {
-      bounds.push({ from: start, to: index });
-      start = index + 1;
-    }
-  }
-  bounds.push({ from: start, to: source.length });
-  return bounds;
-}
-function dshFontQueryGrammar(options = {}) {
-  const CATALOGUE = options.catalogue ?? [];
-  const COMMON = options.commonFamilies ?? FONT_COMMON_FAMILIES;
-  const GENERICS = options.genericFamilies ?? FONT_GENERIC_FAMILIES;
-  const STYLES = options.styles ?? {};
-  const ENUMERATED = options.enumerated === true;
-  const SHIPPED_WEIGHT = options.shippedWeight;
-  const PHRASE_WORDS = options.phraseWords ?? 4;
-  const KNOWN = new Set(CATALOGUE.map((family) => family.toLowerCase()));
-  const SUGGESTION_SPACE = [.../* @__PURE__ */ new Set([...CATALOGUE, ...COMMON, ...GENERICS])];
-  const WEIGHT_ALTERNATION = Object.keys(FONT_WEIGHT_WORDS).join("|");
-  const FAMILY_VOCAB = defineVocabulary({
-    id: "family",
-    words: SUGGESTION_SPACE,
-    scope: SCOPE.family,
-    format: quoteFontFamily
-  });
-  const GENERIC_VOCAB = defineVocabulary({
-    id: "generic",
-    words: GENERICS,
-    scope: SCOPE.generic,
-    docs: Object.fromEntries(
-      GENERICS.map((name) => [
-        name,
-        {
-          detail: "a generic CSS family",
-          body: "Always valid, and only useful at the end of the list: it is what the browser falls back to when nothing before it resolves."
-        }
-      ])
-    )
-  });
-  defineVocabulary({
-    id: "weight",
-    words: Object.keys(FONT_WEIGHT_WORDS),
-    scope: SCOPE.weight,
-    unknownScope: SCOPE.weight,
-    docs: Object.fromEntries(
-      Object.entries(FONT_WEIGHT_WORDS).map(([word, weight]) => [
-        word,
-        { title: word, detail: `font-weight ${String(weight)}` }
-      ])
-    )
-  });
-  const readEntry = (source, bounds) => {
-    const raw = source.slice(bounds.from, bounds.to);
-    const trimmed = raw.trim();
-    const lead = trimmed === "" ? raw.length : raw.indexOf(trimmed);
-    const coreFrom = bounds.from + lead;
-    const core = trimmed;
-    const coreTo = coreFrom + core.length;
-    const problems = [];
-    const entry = {
-      from: bounds.from,
-      to: bounds.to,
-      coreFrom,
-      coreTo,
-      core,
-      quoted: false,
-      name: "",
-      nameFrom: coreFrom,
-      nameTo: coreTo,
-      word: void 0,
-      wordFrom: coreTo,
-      wordTo: coreTo,
-      kind: "empty"
-    };
-    if (core === "") return { entry, problems };
-    const quoteChar = core.charAt(0);
-    const quote = quoteChar === '"' || quoteChar === "'" ? quoteChar : "";
-    const lower = core.toLowerCase();
-    let lookUp = true;
-    if (quote !== "") {
-      entry.quoted = true;
-      const close = core.indexOf(quote, 1);
-      if (close < 0) {
-        entry.name = core.slice(1).trim();
-        entry.nameFrom = coreFrom + 1;
-        entry.kind = "family";
-        problems.push({
-          from: coreFrom,
-          to: coreTo,
-          message: "This quote is never closed, so everything after it is read as part of one family name.",
-          code: "unclosed-quote",
-          severity: "error"
-        });
-        return { entry, problems };
-      }
-      entry.name = core.slice(1, close);
-      entry.nameFrom = coreFrom + 1;
-      entry.nameTo = coreFrom + close;
-      const rest = core.slice(close + 1).trim();
-      if (rest !== "") {
-        const restFrom = coreTo - rest.length;
-        if (Object.hasOwn(FONT_WEIGHT_WORDS, rest.toLowerCase())) {
-          entry.word = rest.toLowerCase();
-          entry.wordFrom = restFrom;
-          entry.wordTo = coreTo;
-        } else {
-          problems.push({
-            from: restFrom,
-            to: coreTo,
-            message: `"${rest}" follows a quoted family name but is neither a weight nor part of it, so it is ignored.`,
-            code: "trailing-text",
-            severity: "error"
-          });
-          lookUp = false;
-        }
-      }
-      entry.kind = "family";
-    } else if (isGenericName(lower, GENERICS) || KNOWN.has(lower)) {
-      entry.name = core;
-      entry.kind = isGenericName(lower, GENERICS) ? "generic" : "family";
-    } else if (Object.hasOwn(FONT_WEIGHT_WORDS, lower)) {
-      entry.kind = "weight";
-      entry.word = lower;
-      entry.wordFrom = coreFrom;
-      entry.wordTo = coreTo;
-    } else {
-      const cut = lower.lastIndexOf(" ");
-      const tail = cut > 0 ? lower.slice(cut + 1) : "";
-      if (cut > 0 && Object.hasOwn(FONT_WEIGHT_WORDS, tail)) {
-        entry.word = tail;
-        entry.wordFrom = coreFrom + cut + 1;
-        entry.wordTo = coreTo;
-        entry.name = core.slice(0, cut).trim();
-        entry.nameTo = entry.nameFrom + entry.name.length;
-      } else {
-        entry.name = core;
-      }
-      entry.kind = "family";
-    }
-    const nameLower = entry.name.trim().toLowerCase();
-    const generic = nameLower !== "" && isGenericName(nameLower, GENERICS);
-    const catalogued = nameLower !== "" && KNOWN.has(nameLower);
-    if (lookUp && nameLower !== "" && !generic && !catalogued && ENUMERATED) {
-      entry.kind = "unknown";
-      problems.push({
-        from: entry.nameFrom,
-        to: entry.nameFrom + entry.name.length,
-        message: `"${entry.name}" is not in this machine's font list. It is still written, and the browser will fall back to whatever comes after it.`,
-        code: "unknown-family",
-        severity: "warning"
-      });
-    } else if (generic) {
-      entry.kind = "generic";
-    }
-    return { entry, problems };
-  };
-  return defineGrammar({
-    id: "dsh-font-query",
-    name: "dsh-font font query",
-    // A hyphen belongs to a name (`-apple-system`, `Helvetica Neue` has spaces and
-    // is reached by the phrase rule instead), and `.` deliberately does not: no
-    // family name in this vocabulary contains one, and leaving it out keeps a
-    // stray `Inter.` from being read as a single unknown name.
-    wordChars: /[\p{L}\p{N}_-]/u,
-    rules: [
-      // ── quoted names, before anything can split them ───────────────────
-      {
-        kind: "match",
-        pattern: /"[^"\n]*"|'[^'\n]*'/,
-        // The scope is decided by what is INSIDE the quotes: a quoted generic is
-        // still a generic, and a quoted name the machine does not have is still
-        // worth painting as unknown.
-        scope: (match) => quotedScope(match.text, KNOWN, GENERICS, ENUMERATED)
-      },
-      {
-        kind: "match",
-        pattern: /["'][^\n]*/,
-        scope: SCOPE.unclosed
-      },
-      { kind: "match", scope: SCOPE.separator, pattern: /,/ },
-      // ── a weight word, but only where a weight may stand ──────────────
-      // A weight is the LAST word of an entry, so the rule looks ahead for a comma
-      // or the end of a line. Without that lookahead `Book` in `Book Antiqua`
-      // would be painted as a weight. `prevNot` stops it matching the tail of a
-      // longer word.
-      //
-      // The scope is decided from the ANALYSIS rather than from the characters,
-      // which is the one place this grammar needs that: `weight` and
-      // `weightMissing` are the same word, and only the machine knows which one it
-      // is. A rule may look at `match.state` precisely so that a semantic
-      // judgement does not have to become a second highlighter.
-      {
-        kind: "match",
-        pattern: new RegExp(`(?:${WEIGHT_ALTERNATION})(?=\\s*(?:,|$))`, "im"),
-        when: { prevNot: "\\w" },
-        scope: (match) => {
-          const state = match.state;
-          if (state.weight === void 0 || state.effective < 0) return SCOPE.weight;
-          const family = state.families[state.effective] ?? "";
-          const faces = fontFaceWeights(lookupStyles(STYLES, family));
-          if (faces.length === 0 || faces.includes(state.weight)) return SCOPE.weight;
-          return SCOPE.weightMissing;
-        }
-      },
-      // ── the catalogue, longest phrase first ──────────────────────────
-      // The generics come first because they are ALSO in the suggestion space,
-      // and a generic painted as an installed family would say the wrong thing
-      // about a word whose whole point is that it names no particular font.
-      { kind: "words", words: GENERIC_VOCAB },
-      {
-        kind: "words",
-        words: FAMILY_VOCAB,
-        phrase: { max: PHRASE_WORDS }
-      },
-      // ── anything else is a name the reader has not seen ──────────────
-      // `unknown` when the catalogue is authoritative, because then the browser
-      // really will fall through; plain `family` when it is only a suggestion
-      // list, because the parser has no business doubting the user.
-      {
-        kind: "match",
-        pattern: /[^\s,]+/,
-        scope: ENUMERATED ? SCOPE.unknown : SCOPE.family
-      }
-    ],
-    fallbackScope: "text",
-    // ── what the query means ──────────────────────────────────────────────
-    analyze: (text) => {
-      const entries = [];
-      const problems = [];
-      for (const bounds of splitEntries(text)) {
-        const read = readEntry(text, bounds);
-        entries.push(read.entry);
-        problems.push(...read.problems);
-      }
-      const families = [];
-      let weight;
-      let weightWord;
-      let sawWeight = false;
-      for (const entry of entries) {
-        if (entry.name.trim() !== "") families.push(entry.name.trim());
-        if (entry.word !== void 0) {
-          if (!sawWeight) {
-            sawWeight = true;
-            weight = FONT_WEIGHT_WORDS[entry.word];
-            weightWord = entry.word;
-          } else {
-            problems.push({
-              from: entry.wordFrom,
-              to: entry.wordTo,
-              message: `The weight is stated more than once. The first one is used and this "${entry.word}" is ignored.`,
-              code: "duplicate-weight",
-              severity: "warning"
-            });
-          }
-        }
-      }
-      let effective = -1;
-      if (families.length > 0) {
-        if (!ENUMERATED) {
-          effective = 0;
-        } else {
-          for (let index = 0; index < families.length; index += 1) {
-            const lower = (families[index] ?? "").toLowerCase();
-            if (isGenericName(lower, GENERICS) || KNOWN.has(lower)) {
-              effective = index;
-              break;
-            }
-          }
-        }
-      }
-      if (weight !== void 0 && effective >= 0) {
-        const family = families[effective] ?? "";
-        const faces = fontFaceWeights(lookupStyles(STYLES, family));
-        if (faces.length > 0 && !faces.includes(weight)) {
-          const entry = entries.find((candidate) => candidate.word !== void 0);
-          if (entry !== void 0) {
-            problems.push({
-              from: entry.wordFrom,
-              to: entry.wordTo,
-              message: `"${family}" has no ${String(weight)} face, so the browser will synthesise one. It does have ${faces.join(", ")}.`,
-              code: "missing-weight",
-              severity: "warning"
-            });
-          }
-        }
-      }
-      if (families.length > 0 && !families.some((family) => isGenericName(family.toLowerCase(), GENERICS))) {
-        problems.push({
-          from: text.length,
-          to: text.length,
-          message: "No generic family at the end, so a name that fails to resolve has nothing to fall back to. Adding one, such as `sans-serif`, is free.",
-          code: "no-generic-fallback",
-          severity: "info"
-        });
-      }
-      return { entries, families, effective, weight, weightWord, problems };
-    },
-    validate: (context) => {
-      for (const problem of context.state.problems) {
-        context.report({
-          from: problem.from,
-          to: problem.to,
-          message: problem.message,
-          code: problem.code,
-          severity: problem.severity
-        });
-      }
-    },
-    // ── the family in effect, marked rather than recoloured ───────────────
-    // It is a decoration and not a scope because it depends on the machine, not on
-    // the characters: the same text means something else on a computer with
-    // different fonts, and re-lexing the document whenever the catalogue changed
-    // would be the wrong shape of work.
-    decorate: (_text, state) => {
-      const decorations = [];
-      if (state.effective < 0) return decorations;
-      const family = state.families[state.effective] ?? "";
-      const target = state.entries.find((candidate) => candidate.name.trim() === family);
-      if (target !== void 0) {
-        decorations.push({
-          from: target.nameFrom,
-          to: target.nameFrom + target.name.length,
-          kind: "effective",
-          title: `in effect: ${family}`
-        });
-      }
-      return decorations;
-    },
-    // ── what can come next ────────────────────────────────────────────────
-    compose: [
-      {
-        id: "family",
-        // The whole query is entries, so this source is always eligible; the
-        // entry under the caret decides what it replaces.
-        when: () => true,
-        range: (context) => entryRange(context.state, context.caret),
-        items: (context) => {
-          const entry = entryAt(context.state.entries, context.caret);
-          const core = entry?.core ?? "";
-          entry?.quoted === true;
-          const inner = unquote(core);
-          const carried = entry?.word;
-          const needle = carried === void 0 ? inner.trim() : inner.slice(0, -carried.length).trim();
-          const exact = findExact(SUGGESTION_SPACE, needle);
-          const headFrom = entry?.coreFrom ?? context.word.from;
-          const head = unquote(context.text.slice(headFrom, Math.max(context.word.from, headFrom))).trim();
-          const atBoundary = entry !== void 0 && context.caret <= entry.coreFrom && exact !== void 0;
-          const familyInEntry = exact ?? findExact(SUGGESTION_SPACE, head);
-          const atFamilyEnd = entry === void 0 || context.caret >= entry.wordFrom;
-          const weightRows = [];
-          if (familyInEntry !== void 0 && !atBoundary && atFamilyEnd) {
-            const detected = fontFaceWeights(lookupStyles(STYLES, familyInEntry));
-            const pool = detected.length > 0 ? detected : [...FONT_WEIGHT_SCALE];
-            const typedWord = context.word.prefix.toLowerCase();
-            for (const value of pool) {
-              const word = fontWeightWord(value);
-              if (typedWord !== "" && !word.startsWith(typedWord)) continue;
-              weightRows.push({
-                label: `${familyInEntry} ${word}`,
-                insert: quoteFontFamily(familyInEntry) + (value === SHIPPED_WEIGHT ? "" : ` ${word}`),
-                kind: "weight",
-                detail: `font-weight ${String(value)}`,
-                documentation: value === SHIPPED_WEIGHT ? "The weight this axis already uses, so picking it takes the word away rather than spelling out a value nobody chose." : void 0,
-                // A weight's position is decided by the SCALE and not by the length of
-                // its label, which is what the zero-padded key is for: without it the
-                // shortest word would lead, so `bold` would sit above the shipped
-                // `regular` and the list would look shuffled. The weight the entry
-                // already states outranks all of them, so an Enter that accepts the top
-                // row re-applies what is written.
-                sortText: word === carried ? "0" : `1${String(value).padStart(3, "0")}`
-              });
-            }
-          }
-          const familyRows = [];
-          for (const name of SUGGESTION_SPACE) {
-            const generic = isGenericName(name.toLowerCase(), GENERICS);
-            familyRows.push({
-              label: name,
-              // A completion never drops a weight the entry already states: the
-              // word travels with the pick, so swapping the family does not quietly
-              // reset the weight.
-              insert: quoteFontFamily(name) + (carried === void 0 ? "" : ` ${carried}`),
-              mode: atBoundary ? "before" : "replace",
-              // A comma invites the next fallback. Only after a family, never after
-              // a weight, which completes the entry instead of starting one.
-              append: atBoundary || lastEntry(context.state, context.caret) ? ", " : "",
-              kind: generic ? "generic" : "family",
-              detail: generic ? "generic family" : KNOWN.has(name.toLowerCase()) ? "installed" : "suggested",
-              // After the weights when weights lead, which is the whole reason a
-              // grammar gets to name the group: `2` sorts above `1xxx` and below `0`.
-              sortText: weightRows.length > 0 ? "2" : "0"
-            });
-          }
-          const rows = weightRows.length > 0 ? [...weightRows, ...familyRows] : familyRows;
-          if (needle !== "" && exact === void 0 && !isGenericName(needle.toLowerCase(), GENERICS)) {
-            rows.push({
-              label: inner,
-              insert: inner,
-              kind: "custom",
-              detail: "as typed",
-              documentation: "Written exactly as it stands. A name the browser does not have is still a valid declaration: it is what lets a stack work on a machine this one cannot see.",
-              sortText: "3"
-            });
-          }
-          return rows;
-        }
-      }
-    ],
-    // ── what a thing is ───────────────────────────────────────────────────
-    describe: (context) => {
-      const token = context.token;
-      if (token === void 0) return void 0;
-      const state = context.state;
-      const entry = entryAt(state.entries, context.offset);
-      if (token.scope === SCOPE.separator) return void 0;
-      if (token.scope === SCOPE.weight || token.scope === SCOPE.weightMissing) {
-        const word = token.text.toLowerCase();
-        const value = FONT_WEIGHT_WORDS[word];
-        const family = state.effective >= 0 ? state.families[state.effective] : void 0;
-        if (value === void 0) return { title: token.text };
-        const faces2 = family === void 0 ? [] : fontFaceWeights(lookupStyles(STYLES, family));
-        return {
-          title: `${word} \u2014 font-weight ${String(value)}`,
-          detail: entry?.name === "" ? "applies to the whole axis" : `applies to ${family ?? "the first family"}`,
-          body: faces2.length === 0 ? `${family ?? "This family"} was not read, so whether it has a ${String(value)} face is unknown.` : faces2.includes(value) ? `${family ?? "This family"} has this face.` : `${family ?? "This family"} has no ${String(value)} face, so the browser will synthesise one.`
-        };
-      }
-      if (token.scope === SCOPE.generic) {
-        return {
-          title: token.text,
-          detail: "a generic CSS family",
-          body: "Always valid, and only useful at the end of the list: it is what the browser falls back to when nothing before it resolves."
-        };
-      }
-      if (token.scope === SCOPE.unclosed) {
-        return {
-          title: token.text,
-          detail: "unclosed quote",
-          body: "The closing quote is missing, so this and everything after it are read as one family name. A font family containing a quote character has to be written with the other quote style, because backslash escapes are deliberately not interpreted."
-        };
-      }
-      if (entry !== void 0 && entry.kind === "unknown") {
-        return {
-          title: entry.name,
-          detail: "not installed here",
-          body: "Still a valid declaration: it is written to the setting, and the browser falls through to the next family in the list when it cannot resolve. Reordering it to the end of the list is what the fallbacks are for."
-        };
-      }
-      const entryDoc = FAMILY_VOCAB.entryFor(token.text);
-      const installed = KNOWN.has(token.text.toLowerCase());
-      const faces = fontFaceWeights(lookupStyles(STYLES, token.text));
-      return {
-        title: token.text,
-        detail: installed ? "installed" : "not read on this machine",
-        body: entryDoc?.body ?? (faces.length > 0 ? `Faces read from this machine: ${faces.join(", ")}.` : "This family has no faces recorded, so its weights are unknown rather than absent.")
-      };
-    }
-  });
-}
-function quotedScope(text, known, generics, enumerated) {
-  const quote = text.charAt(0);
-  const inner = text.length >= 2 && text.endsWith(quote) ? text.slice(1, -1) : text.slice(1);
-  const lower = inner.trim().toLowerCase();
-  if (lower === "") return SCOPE.family;
-  if (generics.includes(lower)) return SCOPE.generic;
-  if (known.has(lower)) return SCOPE.family;
-  return enumerated ? SCOPE.unknown : SCOPE.family;
-}
-function unquote(name) {
-  const text = String(name);
-  const quote = text.charAt(0);
-  if ((quote === '"' || quote === "'") && text.length >= 2 && text.endsWith(quote)) {
-    return text.slice(1, -1);
-  }
-  return text;
-}
-function entryAt(entries, offset) {
-  for (const entry of entries) {
-    if (offset >= entry.from && offset <= entry.to) return entry;
-  }
-  return entries[entries.length - 1];
-}
-function entryRange(state, caret) {
-  const entry = entryAt(state.entries, caret);
-  return entry === void 0 ? { from: caret, to: caret } : { from: entry.coreFrom, to: entry.coreTo };
-}
-function lastEntry(state, caret) {
-  const entry = entryAt(state.entries, caret);
-  return entry === void 0 || entry === state.entries[state.entries.length - 1];
-}
-function findExact(names, needle) {
-  const lower = needle.toLowerCase();
-  return names.find((name) => name.toLowerCase() === lower);
-}
-function lookupStyles(styles, family) {
-  if (Object.hasOwn(styles, family)) return styles[family];
-  const lower = family.toLowerCase();
-  for (const [name, faces] of Object.entries(styles)) {
-    if (name.toLowerCase() === lower) return faces;
-  }
-  return void 0;
-}
-var DSH_FONT_INFO_CODES = ["no-generic-fallback"];
-
-// src/core/text.ts
-function lineStarts(source) {
-  const starts = [0];
-  for (let index = 0; index < source.length; index += 1) {
-    const code = source.charCodeAt(index);
-    if (code === 10) {
-      starts.push(index + 1);
-    } else if (code === 13) {
-      if (source.charCodeAt(index + 1) === 10) index += 1;
-      starts.push(index + 1);
-    }
-  }
-  return starts;
-}
-
-// src/grammars/dshSentry.ts
-var DEFAULT_STATES = ["running", "waiting", "approval", "done"];
-var DEFAULT_SHAPES = ["circle", "rounded", "square", "none"];
-var DEFAULT_MOTIONS = ["still", "turn", "blink", "flush"];
-var DEFAULT_PATTERNS = [];
-var DEFAULT_COLORS = {
-  blue: "#4d6bfe",
-  amber: "#f59e0b",
-  green: "#22c55e",
-  red: "#ef4444",
-  purple: "#8b5cf6",
-  gray: "#8b8f97",
-  dark: "#23262c",
-  light: "#eef0f3"
-};
-var DEFAULT_OPTIONS = ["shape", "color", "pattern", "motion", "speed", "bg"];
-var DEFAULT_SLOTS = ["shape", "color", "pattern", "motion", "speed"];
-var DEFAULT_LOOK = {
-  running: { shape: "circle", color: "blue", pattern: "none", motion: "turn", speed: 3 },
-  waiting: { shape: "rounded", color: "amber", pattern: "none", motion: "blink", speed: 1.1 },
-  approval: { shape: "rounded", color: "amber", pattern: "none", motion: "blink", speed: 1.9 },
-  done: { shape: "circle", color: "green", pattern: "none", motion: "flush", speed: 1.6 }
-};
-var SLOT_SCOPE = {
-  shape: "value.shape",
-  color: "value.color",
-  pattern: "value.pattern",
-  motion: "value.motion",
-  speed: "value.number"
-};
-var KEY_SLOT = {
-  shape: "shape",
-  color: "color",
-  bg: "color",
-  pattern: "pattern",
-  motion: "motion",
-  speed: "speed"
-};
-var COLOR_NAMES_OF = (colors) => Object.keys(colors);
-function closed(spec) {
-  return defineVocabulary({ ...spec, caseSensitive: true });
-}
-function dshSentryStyleGrammar(options = {}) {
-  const STATES = options.states ?? DEFAULT_STATES;
-  const SHAPES = options.shapes ?? DEFAULT_SHAPES;
-  const MOTIONS = options.motions ?? DEFAULT_MOTIONS;
-  const PATTERNS = options.patterns ?? DEFAULT_PATTERNS;
-  const COLORS = options.colors ?? DEFAULT_COLORS;
-  const COLOR_NAMES = COLOR_NAMES_OF(COLORS);
-  const OPTIONS = options.options ?? DEFAULT_OPTIONS;
-  const LOOK = options.defaults ?? DEFAULT_LOOK;
-  const SLOTS = DEFAULT_SLOTS;
-  const PATTERN_WORDS = PATTERNS.length > 0 ? PATTERNS : ["none"];
-  const STATE_VOCAB = closed({
-    id: "state",
-    words: STATES,
-    scope: "state",
-    unknownMessage: 'Unknown state "{word}" \u2014 this document understands {allowed}.',
-    docs: {
-      running: { detail: "a turn is in progress", body: "The agent is working and does not need anyone." },
-      waiting: { detail: "a question is waiting", body: "The agent asked something, and the turn is blocked until it is answered." },
-      approval: { detail: "a permission is waiting", body: "The agent requested an escalation or a plan review, and the turn is blocked on it." },
-      done: { detail: "the turn finished", body: "The agent stopped and left the tab alone." }
-    }
-  });
-  const SHAPE_VOCAB = closed({
-    id: "shape",
-    words: SHAPES,
-    scope: SLOT_SCOPE.shape,
-    docs: {
-      circle: { detail: "a full disc" },
-      rounded: { detail: "a rounded square" },
-      square: { detail: "a square with sharp corners" },
-      none: {
-        detail: "no background",
-        body: "The fish alone, on whatever the tab gives it. A bare `none` is a SHAPE and never a pattern: one word cannot mean two things."
-      }
-    }
-  });
-  const COLOR_VOCAB = closed({
-    id: "color",
-    words: COLOR_NAMES,
-    scope: SLOT_SCOPE.color,
-    docs: Object.fromEntries(Object.entries(COLORS).map(([name, hex]) => [name, { detail: hex }]))
-  });
-  const MOTION_VOCAB = closed({
-    id: "motion",
-    words: MOTIONS,
-    scope: SLOT_SCOPE.motion,
-    docs: {
-      still: { detail: "nothing moves" },
-      turn: { detail: "rotates", body: "speed is seconds per revolution." },
-      blink: { detail: "alternates", body: "speed is seconds per cycle." },
-      flush: { detail: "pulses", body: "speed is seconds per cycle." }
-    }
-  });
-  const PATTERN_VOCAB = closed({
-    id: "pattern",
-    words: PATTERN_WORDS,
-    scope: SLOT_SCOPE.pattern,
-    docs: {
-      none: {
-        detail: "carve nothing",
-        body: "Every dial-like pattern was tried on a real 16px favicon and read as noise, so `none` is the only pattern left. It is written as `pattern=none` and never as a bare word, because `none` is also a shape."
-      }
-    }
-  });
-  const KEY_DOCS = {
-    shape: { detail: "background shape", body: `One of ${SHAPES.join(", ")}.` },
-    color: { detail: "disc colour", body: `${COLOR_NAMES.join(", ")} \u2014 all presets, chosen so the fish stays legible.` },
-    pattern: { detail: "carved pattern", body: "Only `none` remains; write it as `pattern=none`." },
-    motion: { detail: "what moves", body: `One of ${MOTIONS.join(", ")}.` },
-    speed: { detail: "seconds per cycle", body: "A number: seconds per revolution for `turn`, seconds per cycle otherwise." },
-    bg: { detail: "an alias for color", body: "Kept so a document written against an earlier release still says what it means." }
-  };
-  const BY_SCOPE = /* @__PURE__ */ new Map([
-    ["state", STATE_VOCAB],
-    [SLOT_SCOPE.shape, SHAPE_VOCAB],
-    [SLOT_SCOPE.color, COLOR_VOCAB],
-    [SLOT_SCOPE.pattern, PATTERN_VOCAB],
-    [SLOT_SCOPE.motion, MOTION_VOCAB]
-  ]);
-  const VOCAB_FOR_KEY = {
-    shape: SHAPE_VOCAB,
-    color: COLOR_VOCAB,
-    bg: COLOR_VOCAB,
-    pattern: PATTERN_VOCAB,
-    motion: MOTION_VOCAB
-  };
-  const wordsForSlot = (slot) => {
-    if (slot === "shape") return SHAPES;
-    if (slot === "color" || slot === "bg") return COLOR_NAMES;
-    if (slot === "motion") return MOTIONS;
-    if (slot === "pattern") return PATTERN_WORDS;
-    return [];
-  };
-  const expectedList = (slot) => {
-    if (slot === "speed") return "a number of seconds, such as 3 or 1.1";
-    const words = wordsForSlot(slot);
-    if (words.length === 0) return `pattern=<name>`;
-    return words.join(", ");
-  };
-  const valueProblem = (key, value) => {
-    if (key === "speed") {
-      return Number.isFinite(Number.parseFloat(value)) ? void 0 : `"${value}" is not a speed \u2014 write a number of seconds, such as 3 or 1.1. The shipped rate is used instead.`;
-    }
-    if (VOCAB_FOR_KEY[key] === void 0) return void 0;
-    const words = wordsForSlot(key);
-    if (words.includes(value)) return void 0;
-    const noun = key === "bg" ? "preset colour" : key;
-    return `"${value}" is not a ${noun} \u2014 expected ${words.join(", ")}. The shipped default is used instead.`;
-  };
-  return defineGrammar({
-    id: "dsh-sentry-style",
-    name: "dsh-sentry style document",
-    // A decimal speed is one token because the number RULE says so, not because `.`
-    // is a word character. Leaving `.` out of the predicate stops a stray
-    // `circle.` from being read as one word, matching no shape, and earning a
-    // diagnostic about a word the user never typed.
-    wordChars: /[\p{L}\p{N}_]/u,
-    rules: [
-      { kind: "match", scope: "comment", pattern: /#[^\n]*/ },
-      // The first word on a line is a state or it is a mistake. `unknown: {}` asks
-      // for the vocabulary's own rejection, and this is the one place in the
-      // language where the lexical layer can be that sure: nothing else may stand
-      // at the head of a line, so there is no later rule to wait for.
-      {
-        kind: "words",
-        words: STATE_VOCAB,
-        when: { firstOnLine: true },
-        unknown: {}
-      },
-      // `shape=` — the key, seen from the `=` so it cannot also swallow a value.
-      { kind: "match", scope: "property", pattern: /[A-Za-z][\w-]*(?==)/ },
-      { kind: "match", scope: "operator", pattern: /=/ },
-      { kind: "match", scope: "separator", pattern: /,/ },
-      // Values. The sets are disjoint, so membership alone places a bare word, and
-      // none of these rules rejects: a rule that did would claim a word belonging
-      // to the next vocabulary down the list.
-      { kind: "words", words: SHAPE_VOCAB },
-      { kind: "words", words: COLOR_VOCAB },
-      { kind: "words", words: MOTION_VOCAB },
-      { kind: "match", scope: SLOT_SCOPE.speed, pattern: /\d+(?:\.\d+)?/ },
-      // Anything left is a word this language does not know. Painting it as invalid
-      // rather than as plain text makes a typo visible before the structural pass
-      // has even run, and that pass supplies the precise message.
-      { kind: "match", scope: "invalid", pattern: /\S+/ }
-    ],
-    fallbackScope: "text",
-    // ── what the document means ───────────────────────────────────────────
-    //
-    // This walk decides the slot filling AND records what went wrong, rather than
-    // leaving the second job to a second walk. They are the same decision: the only
-    // reason to know which slot is free is to say what a word that fits nothing
-    // should have been, and splitting them would mean two implementations of one
-    // rule — which is exactly how the editors this library replaces came to
-    // disagree with themselves.
-    analyze: (text) => {
-      const starts = lineStarts(text);
-      const lines = [];
-      const problems = [];
-      for (let number = 0; number < starts.length; number += 1) {
-        const from = starts[number] ?? 0;
-        const rawTo = starts[number + 1] ?? text.length;
-        let to = rawTo;
-        while (to > from && (text.charAt(to - 1) === "\n" || text.charAt(to - 1) === "\r")) to -= 1;
-        const raw = text.slice(from, to);
-        const comment = raw.indexOf("#");
-        const body = comment === -1 ? raw : raw.slice(0, comment);
-        const words = [];
-        const wordPattern = /[^\s,]+/g;
-        let match;
-        while ((match = wordPattern.exec(body)) !== null) {
-          words.push({
-            text: match[0],
-            from: from + match.index,
-            to: from + match.index + match[0].length
-          });
-        }
-        const line = {
-          number,
-          state: void 0,
-          known: true,
-          words,
-          slots: {},
-          keys: [],
-          pendingKey: void 0
-        };
-        lines.push(line);
-        const first = words[0];
-        if (first === void 0) continue;
-        line.state = first.text;
-        line.known = STATES.includes(first.text);
-        if (!line.known) continue;
-        const claim = (slot, value) => {
-          line.slots[slot] = value;
-        };
-        for (let index = 1; index < words.length; index += 1) {
-          const word = words[index];
-          if (word === void 0) continue;
-          const equals = word.text.indexOf("=");
-          const key = equals === -1 ? void 0 : word.text.slice(0, equals);
-          const value = equals === -1 ? void 0 : word.text.slice(equals + 1);
-          if (key !== void 0) {
-            line.keys.push(key);
-            const written = value ?? "";
-            if (written === "") {
-              line.pendingKey = key;
-              continue;
-            }
-            const complaint = valueProblem(key, written);
-            if (complaint !== void 0) {
-              problems.push({
-                from: word.from,
-                to: word.to,
-                message: complaint,
-                code: "bad-option-value",
-                severity: "warning"
-              });
-              continue;
-            }
-            const slot = KEY_SLOT[key];
-            if (slot !== void 0) claim(slot, written);
-            continue;
-          }
-          if (MOTIONS.includes(word.text)) {
-            claim("motion", word.text);
-            continue;
-          }
-          if (SHAPES.includes(word.text)) {
-            claim("shape", word.text);
-            continue;
-          }
-          if (COLOR_NAMES.includes(word.text)) {
-            claim("color", word.text);
-            continue;
-          }
-          if (PATTERNS.includes(word.text)) {
-            claim("pattern", word.text);
-            continue;
-          }
-          if (Number.isFinite(Number.parseFloat(word.text))) {
-            claim("speed", word.text);
-            continue;
-          }
-          const free = SLOTS.find((slot) => line.slots[slot] === void 0);
-          if (free === void 0) {
-            problems.push({
-              from: word.from,
-              to: word.to,
-              message: `"${word.text}" has nowhere to go \u2014 this line already names a shape, colour, pattern, motion, and speed.`,
-              code: "unexpected-value",
-              severity: "error"
-            });
-          } else {
-            problems.push({
-              from: word.from,
-              to: word.to,
-              message: `"${word.text}" is not a valid ${free} \u2014 expected ${expectedList(free)}.`,
-              code: "bad-value",
-              severity: "error"
-            });
-          }
-        }
-      }
-      return { lines, problems };
-    },
-    // ── what the tokens must be ───────────────────────────────────────────
-    // One declarative check, because "a key must be one it knows" is exactly the
-    // shape a check is for: a scope, an allowed set, and a message.
-    checks: [
-      {
-        code: "unknown-option",
-        scopes: ["property"],
-        allow: closed({ id: "option", words: [...OPTIONS, ...PATTERNS] }),
-        severity: "error",
-        message: 'Unknown option "{word}" \u2014 this document understands {allowed}.'
-      }
-    ],
-    validate: (context) => {
-      for (const problem of context.state.problems) {
-        context.report({
-          from: problem.from,
-          to: problem.to,
-          message: problem.message,
-          code: problem.code,
-          severity: problem.severity
-        });
-      }
-    },
-    // ── what can come next ────────────────────────────────────────────────
-    compose: [
-      {
-        id: "state",
-        // A state opens a line, so its list belongs at the head of one — and it has to
-        // stay offered while the state is being spelled, which is why this asks
-        // `firstWord` rather than `firstOnLine`. Asking the stricter question makes the
-        // list vanish after the first letter, which is precisely the "the completion
-        // feels unnatural" complaint this grammar exists to answer.
-        when: (context) => context.firstWord,
-        range: (context) => context.word,
-        items: () => STATES.map((state) => ({
-          label: state,
-          insert: state,
-          // A space is what the next word on the line needs. The engine will not
-          // add a second one if the document already has whitespace there.
-          append: " ",
-          kind: "state",
-          detail: STATE_VOCAB.entryFor(state)?.detail,
-          documentation: STATE_VOCAB.entryFor(state)?.body,
-          sortText: "0"
-        }))
-      },
-      {
-        id: "value",
-        when: (context) => {
-          const line = context.state.lines[context.line.number];
-          if (line === void 0 || line.state === void 0 || !line.known) return false;
-          const stateWord = line.words[0];
-          return stateWord !== void 0 && context.caret > stateWord.to;
-        },
-        range: (context) => context.word,
-        items: (context) => {
-          const line = context.state.lines[context.line.number];
-          const key = optionAtCaret(context.line.before);
-          if (key !== void 0 && key !== "") {
-            return valueItems(key, line);
-          }
-          const free = SLOTS.find((slot) => line?.slots[slot] === void 0);
-          const items = free === void 0 ? [] : valueItems(free, line);
-          for (const key2 of OPTIONS) {
-            if (line?.keys.includes(key2) === true) continue;
-            const doc = KEY_DOCS[key2];
-            items.push({
-              label: `${key2}=`,
-              insert: `${key2}=`,
-              kind: "property",
-              detail: doc?.detail,
-              documentation: doc?.body,
-              sortText: "1"
-            });
-          }
-          return items;
-        }
-      }
-    ],
-    // ── what a thing is ───────────────────────────────────────────────────
-    describe: (context) => {
-      const token = context.token;
-      if (token === void 0) return void 0;
-      if (token.scope === "comment") {
-        return { title: "comment", body: "Ignored by the parser. A `#` anywhere on a line starts one." };
-      }
-      if (token.scope === "property") {
-        const doc = KEY_DOCS[token.text];
-        return doc === void 0 ? void 0 : { title: token.text, detail: doc.detail, body: doc.body };
-      }
-      if (token.scope === "operator" || token.scope === "separator") return void 0;
-      if (token.scope === "invalid") {
-        return {
-          title: token.text,
-          detail: "not part of this language",
-          body: "Nothing here accepts this word: it is not a state, not one of the option keys, and not a value any slot recognises."
-        };
-      }
-      if (token.scope === SLOT_SCOPE.speed) {
-        return {
-          title: token.text,
-          detail: "seconds per cycle",
-          body: "Seconds per revolution for `turn`, seconds per cycle otherwise."
-        };
-      }
-      const entry = BY_SCOPE.get(token.scope)?.entryFor(token.text);
-      return entry === void 0 ? void 0 : { title: token.text, detail: entry.detail, body: entry.body };
-    }
-  });
-  function valueItems(slot, line) {
-    if (slot === "speed") {
-      const current = line?.state === void 0 ? void 0 : LOOK[line.state]?.speed;
-      const rates = [.../* @__PURE__ */ new Set([...Object.values(LOOK).map((look) => look.speed), 1, 2, 3])].sort(
-        (left, right) => left - right
-      );
-      return rates.map((rate) => ({
-        label: String(rate),
-        insert: String(rate),
-        kind: "number",
-        detail: current === rate ? "the shipped rate for this state" : "seconds per cycle",
-        sortText: current === rate ? "0" : "1"
-      }));
-    }
-    const words = wordsForSlot(slot);
-    if (words.length === 0) return [];
-    const scope = slot === "bg" ? SLOT_SCOPE.color : SLOT_SCOPE[slot];
-    const vocabulary = BY_SCOPE.get(scope);
-    const filled = line?.slots[KEY_SLOT[slot] ?? "shape"];
-    const noun = slot === "bg" ? "color" : slot;
-    return words.map((word) => {
-      const entry = vocabulary?.entryFor(word);
-      return {
-        label: word,
-        insert: word,
-        kind: "value",
-        detail: word === filled ? `the current ${noun}` : entry?.detail,
-        documentation: entry?.body,
-        sortText: word === filled ? "0" : "1"
-      };
-    });
-  }
-}
-function optionAtCaret(before) {
-  const match = /([A-Za-z][\w-]*)\s*=([^\s=]*)$/.exec(before);
-  return match?.[1];
-}
-var DSH_SENTRY_STATES = DEFAULT_STATES;
-var DSH_SENTRY_COLORS = DEFAULT_COLORS;
-var DSH_SENTRY_VOCABULARY = {
-  states: DEFAULT_STATES,
-  shapes: DEFAULT_SHAPES,
-  motions: DEFAULT_MOTIONS,
-  colors: DEFAULT_COLORS,
-  options: DEFAULT_OPTIONS
-};
-
-exports.DSH_FONT_INFO_CODES = DSH_FONT_INFO_CODES;
-exports.DSH_SENTRY_COLORS = DSH_SENTRY_COLORS;
-exports.DSH_SENTRY_STATES = DSH_SENTRY_STATES;
-exports.DSH_SENTRY_VOCABULARY = DSH_SENTRY_VOCABULARY;
-exports.FONT_COMMON_FAMILIES = FONT_COMMON_FAMILIES;
-exports.FONT_GENERIC_FAMILIES = FONT_GENERIC_FAMILIES;
-exports.FONT_WEIGHT_LABELS = FONT_WEIGHT_LABELS;
-exports.FONT_WEIGHT_SCALE = FONT_WEIGHT_SCALE;
-exports.FONT_WEIGHT_WORDS = FONT_WEIGHT_WORDS;
-exports.dshFontQueryGrammar = dshFontQueryGrammar;
-exports.dshSentryStyleGrammar = dshSentryStyleGrammar;
-exports.fontFaceWeights = fontFaceWeights;
-exports.fontWeightWord = fontWeightWord;
-exports.quoteFontFamily = quoteFontFamily;
-//# sourceMappingURL=grammars.cjs.map
-//# sourceMappingURL=grammars.cjs.map