@hekana/prettier-plugin-sneferu 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,614 @@
+// src/parse.ts
+import { VOID_ELEMENTS } from "@hekana/sneferu-compiler";
+var SneferuSyntaxError = class extends Error {
+  loc;
+  constructor(message, src, offset) {
+    const before = src.slice(0, offset).split("\n");
+    const line3 = before.length;
+    const column = before[before.length - 1].length + 1;
+    super(`${message} (${line3}:${column})`);
+    this.loc = { start: { line: line3, column } };
+  }
+};
+function lex(src) {
+  const toks = [];
+  let i = 0;
+  let text = "";
+  let textStart = 0;
+  const fail = (m, at2 = i) => {
+    throw new SneferuSyntaxError(m, src, at2);
+  };
+  const flush = () => {
+    if (text) toks.push({ t: "text", v: text, start: textStart, end: i });
+    text = "";
+  };
+  const at = (s) => src.startsWith(s, i);
+  while (i < src.length) {
+    if (at("<!--")) {
+      flush();
+      const end = src.indexOf("-->", i);
+      if (end === -1) fail("unterminated <!-- comment");
+      toks.push({ t: "comment", v: src.slice(i, end + 3), start: i, end: end + 3 });
+      i = end + 3;
+      continue;
+    }
+    if (at("{{") || at("{%")) {
+      flush();
+      const isInterp = at("{{");
+      const end = src.indexOf(isInterp ? "}}" : "%}", i + 2);
+      if (end === -1) fail(`unterminated ${isInterp ? "{{" : "{%"}`);
+      const inner = src.slice(i + 2, end).trim();
+      toks.push(isInterp ? { t: "interp", src: inner, start: i, end: end + 2 } : { t: "dir", src: inner, start: i, end: end + 2 });
+      i = end + 2;
+      continue;
+    }
+    if (at("<hk-schema>")) {
+      flush();
+      const end = src.indexOf("</hk-schema>", i);
+      if (end === -1) fail("unterminated <hk-schema>");
+      const raw = src.slice(i + "<hk-schema>".length, end);
+      toks.push({ t: "schema", json: raw.trim(), raw, start: i, end: end + "</hk-schema>".length });
+      i = end + "</hk-schema>".length;
+      continue;
+    }
+    if (at("</")) {
+      const m = /^<\/([a-zA-Z][a-zA-Z0-9-]*)\s*>/.exec(src.slice(i));
+      if (m) {
+        flush();
+        toks.push({ t: "close", name: m[1], start: i, end: i + m[0].length });
+        i += m[0].length;
+        continue;
+      }
+    }
+    if (src[i] === "<" && /[a-zA-Z]/.test(src[i + 1] ?? "")) {
+      flush();
+      const start = i;
+      i++;
+      let name = "";
+      while (i < src.length && /[a-zA-Z0-9-]/.test(src[i])) name += src[i++];
+      const attrs = [];
+      let selfClosing = false;
+      let closed = false;
+      while (i < src.length) {
+        while (/\s/.test(src[i] ?? "")) i++;
+        if (at("/>")) {
+          selfClosing = true;
+          i += 2;
+          closed = true;
+          break;
+        }
+        if (src[i] === ">") {
+          i++;
+          closed = true;
+          break;
+        }
+        let aName = "";
+        while (i < src.length && /[^\s=/>"']/.test(src[i])) aName += src[i++];
+        if (!aName) fail(`unexpected '${src[i]}' in <${name}>`);
+        let value = null;
+        let quote = "";
+        if (src[i] === "=") {
+          i++;
+          const q = src[i];
+          if (q === '"' || q === "'") {
+            const end = src.indexOf(q, i + 1);
+            if (end === -1) fail(`unterminated value for ${aName}`);
+            value = src.slice(i + 1, end);
+            quote = q;
+            i = end + 1;
+          } else {
+            value = "";
+            while (i < src.length && /[^\s>]/.test(src[i])) value += src[i++];
+          }
+        }
+        attrs.push({ name: aName, value, quote });
+      }
+      if (!closed) fail(`unterminated tag <${name}>`, start);
+      toks.push({ t: "open", name, attrs, selfClosing, start, end: i });
+      continue;
+    }
+    if (!text) textStart = i;
+    text += src[i++];
+  }
+  flush();
+  return toks;
+}
+var keywordOf = (src) => src.split(/\s+/)[0] ?? "";
+function parse(src) {
+  const root = { type: "root", children: [], start: 0, end: src.length, source: src };
+  const stack = [{ kind: "root", body: root.children }];
+  const top = () => stack[stack.length - 1];
+  const fail = (m, at) => {
+    throw new SneferuSyntaxError(m, src, at);
+  };
+  for (const tok of lex(src)) {
+    switch (tok.t) {
+      case "text":
+        top().body.push({ type: "text", value: tok.v, start: tok.start, end: tok.end });
+        break;
+      case "comment":
+        top().body.push({ type: "comment", value: tok.v, start: tok.start, end: tok.end });
+        break;
+      case "interp":
+        top().body.push({ type: "interp", src: tok.src, start: tok.start, end: tok.end });
+        break;
+      case "schema":
+        top().body.push({ type: "schema", json: tok.json, raw: tok.raw, start: tok.start, end: tok.end });
+        break;
+      case "open": {
+        const node = { type: "element", name: tok.name, attrs: tok.attrs, selfClosing: tok.selfClosing, children: [], start: tok.start, end: tok.end, openEnd: tok.end, closeStart: tok.end };
+        top().body.push(node);
+        if (!tok.selfClosing && !VOID_ELEMENTS.has(tok.name.toLowerCase())) stack.push({ kind: "el", node, body: node.children });
+        break;
+      }
+      case "close": {
+        const f = top();
+        if (f.kind !== "el" || f.node.name.toLowerCase() !== tok.name.toLowerCase()) fail(`</${tok.name}> does not close the open ${f.kind === "el" ? `<${f.node.name}>` : f.kind === "root" ? "nothing" : `{% ${f.kind} %}`}`, tok.start);
+        const el = f.node;
+        el.end = tok.end;
+        el.closeStart = tok.start;
+        stack.pop();
+        break;
+      }
+      case "dir": {
+        const kw = keywordOf(tok.src);
+        if (kw === "if") {
+          const node = { type: "if", branches: [{ src: tok.src, body: [] }], endSrc: "", start: tok.start, end: tok.end };
+          top().body.push(node);
+          stack.push({ kind: "if", node, body: node.branches[0].body });
+        } else if (kw === "elsif" || kw === "else") {
+          const f = top();
+          if (f.kind !== "if") fail(`{% ${kw} %} outside {% if %}`, tok.start);
+          const n = f.node;
+          if (n.else) fail(`{% ${kw} %} after {% else %}`, tok.start);
+          if (kw === "elsif") {
+            const b = { src: tok.src, body: [] };
+            n.branches.push(b);
+            f.body = b.body;
+          } else {
+            n.else = { src: tok.src, body: [] };
+            f.body = n.else.body;
+          }
+        } else if (kw === "endif" || kw === "endfor") {
+          const f = top();
+          if (f.kind !== (kw === "endif" ? "if" : "for")) fail(`{% ${kw} %} has no matching opening tag`, tok.start);
+          const n = f.node;
+          n.endSrc = tok.src;
+          n.end = tok.end;
+          stack.pop();
+        } else if (kw === "for") {
+          const node = { type: "for", src: tok.src, body: [], endSrc: "", start: tok.start, end: tok.end };
+          top().body.push(node);
+          stack.push({ kind: "for", node, body: node.body });
+        } else {
+          top().body.push({ type: "directive", kw, src: tok.src, start: tok.start, end: tok.end });
+        }
+        break;
+      }
+    }
+  }
+  const open = top();
+  if (open.kind !== "root") fail(`${open.kind === "el" ? `<${open.node.name}>` : `{% ${open.kind} %}`} is never closed`, open.node.start);
+  return root;
+}
+
+// src/print.ts
+import { doc as doc2 } from "prettier";
+import { freeBeside, innerContext, isBlockLevel, VOID_ELEMENTS as VOID_ELEMENTS2, parseExpr as parseExpr2 } from "@hekana/sneferu-compiler";
+
+// src/expr.ts
+import { parseExpr, parseFor, splitArgs } from "@hekana/sneferu-compiler";
+var KEYWORDS = /* @__PURE__ */ new Set(["and", "or", "not"]);
+function tokenize(src) {
+  const out = [];
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i];
+    if (/\s/.test(c)) {
+      i++;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      const end = src.indexOf(c, i + 1);
+      if (end === -1) return void 0;
+      out.push({ k: "str", v: src.slice(i + 1, end), q: c });
+      i = end + 1;
+      continue;
+    }
+    const num = /^-?\d+(\.\d+)?/.exec(src.slice(i));
+    if (num && !/[A-Za-z_]/.test(src[i + num[0].length] ?? "")) {
+      out.push({ k: "num", v: num[0] });
+      i += num[0].length;
+      continue;
+    }
+    const id = /^[A-Za-z_][A-Za-z0-9_-]*/.exec(src.slice(i));
+    if (id) {
+      out.push({ k: "id", v: id[0] });
+      i += id[0].length;
+      continue;
+    }
+    const op = /^(==|!=|>=|<=|>|<)/.exec(src.slice(i));
+    if (op) {
+      out.push({ k: "op", v: op[0] });
+      i += op[0].length;
+      continue;
+    }
+    if (".[]()|:,".includes(c)) {
+      out.push({ k: "punc", v: c });
+      i++;
+      continue;
+    }
+    return void 0;
+  }
+  return out;
+}
+var isP = (t, v) => !!t && t.k === "punc" && t.v === v;
+function sep(p, c) {
+  if (c.k === "op" || p.k === "op" || isP(c, "|") || isP(p, "|")) return " ";
+  if (isP(c, ".") || isP(c, "]") || isP(c, ")") || isP(c, ",") || isP(c, ":") || isP(c, "[")) return "";
+  if (isP(p, ".") || isP(p, "[") || isP(p, "(")) return "";
+  if (isP(c, "(")) return p.k === "id" && !KEYWORDS.has(p.v) ? "" : " ";
+  return " ";
+}
+function printTokens(toks, quote) {
+  let out = "";
+  toks.forEach((t, i) => {
+    if (i > 0) out += sep(toks[i - 1], t);
+    if (t.k === "str") {
+      const q = t.v.includes(quote) ? t.q : quote;
+      out += q + t.v + q;
+    } else out += t.v;
+  });
+  return out;
+}
+var same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function formatExpr(src, quote) {
+  const before = parseExpr(src);
+  if (!before.expr) return src;
+  const toks = tokenize(src);
+  if (!toks) return src;
+  const out = printTokens(toks, quote);
+  return same(parseExpr(out), before) ? out : src;
+}
+function formatDirective(src, kw, quote) {
+  const arg = src.slice(kw.length).trim();
+  if (kw === "if" || kw === "elsif") return arg ? `${kw} ${formatExpr(arg, quote)}` : src;
+  if (kw === "else" || kw === "endif" || kw === "endfor") return arg ? src : kw;
+  if (kw === "for") {
+    const m = /^([A-Za-z_][A-Za-z0-9_]*)\s+in\s+(.+?)(?:\s+limit:\s*(\S+))?$/.exec(arg);
+    if (!m) return src;
+    const out = `for ${m[1]} in ${formatExpr(m[2], quote)}${m[3] !== void 0 ? ` limit: ${m[3]}` : ""}`;
+    return same(parseFor(out.slice(4)), parseFor(arg)) ? out : src;
+  }
+  if (kw === "render") {
+    const out = formatRender(arg, quote);
+    return out !== void 0 && same(renderMeaning(out.slice(0)), renderMeaning(arg)) ? `render ${out}` : src;
+  }
+  return src;
+}
+var RENDER = /^'([a-z0-9-]+)'\s*(?:,\s*(.*))?$/;
+var PAIR = /^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*(.+)$/;
+function renderMeaning(arg) {
+  const m = RENDER.exec(arg);
+  if (!m) return null;
+  return [m[1], splitArgs(m[2] ?? "").map((pair) => {
+    const pm = PAIR.exec(pair);
+    return pm ? [pm[1], parseExpr(pm[2])] : ["?", pair];
+  })];
+}
+function formatRender(arg, quote) {
+  const m = RENDER.exec(arg);
+  if (!m) return void 0;
+  const pairs = splitArgs(m[2] ?? "").map((pair) => {
+    const pm = PAIR.exec(pair);
+    return pm ? `${pm[1]}: ${formatExpr(pm[2], quote)}` : void 0;
+  });
+  if (pairs.some((p) => p === void 0)) return void 0;
+  return [`'${m[1]}'`, ...pairs].join(", ");
+}
+
+// src/json.ts
+import { doc } from "prettier";
+var { group, indent, line, softline, hardline, join } = doc.builders;
+function parseJson(src) {
+  let i = 0;
+  const ws = () => {
+    while (i < src.length && " 	\n\r".includes(src[i])) i++;
+  };
+  const str = () => {
+    const m = /^"(?:[^"\\\u0000-\u001f]|\\(?:["\\/bfnrt]|u[0-9a-fA-F]{4}))*"/.exec(src.slice(i));
+    if (!m) throw new Error("string");
+    i += m[0].length;
+    return m[0];
+  };
+  const value = () => {
+    ws();
+    const c = src[i];
+    if (c === "{") {
+      i++;
+      ws();
+      const props = [];
+      if (src[i] === "}") {
+        i++;
+        return { k: "obj", props };
+      }
+      for (; ; ) {
+        ws();
+        const key = str();
+        ws();
+        if (src[i++] !== ":") throw new Error(":");
+        props.push([key, value()]);
+        ws();
+        const d = src[i++];
+        if (d === "}") return { k: "obj", props };
+        if (d !== ",") throw new Error(",");
+      }
+    }
+    if (c === "[") {
+      i++;
+      ws();
+      const items = [];
+      if (src[i] === "]") {
+        i++;
+        return { k: "arr", items };
+      }
+      for (; ; ) {
+        items.push(value());
+        ws();
+        const d = src[i++];
+        if (d === "]") return { k: "arr", items };
+        if (d !== ",") throw new Error(",");
+      }
+    }
+    if (c === '"') return { k: "raw", v: str() };
+    const m = /^(?:-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?|true|false|null)/.exec(src.slice(i));
+    if (!m) throw new Error("value");
+    i += m[0].length;
+    return { k: "raw", v: m[0] };
+  };
+  try {
+    JSON.parse(src);
+    const v = value();
+    ws();
+    return i === src.length ? v : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function print(j) {
+  if (j.k === "raw") return j.v;
+  if (j.k === "obj") {
+    if (j.props.length === 0) return "{}";
+    return ["{", indent([hardline, join([",", hardline], j.props.map(([k, v]) => [k, ": ", print(v)]))]), hardline, "}"];
+  }
+  if (j.items.length === 0) return "[]";
+  const items = j.items.map(print);
+  if (j.items.every((x) => x.k === "raw")) return group(["[", indent([softline, join([",", line], items)]), softline, "]"]);
+  return ["[", indent([hardline, join([",", hardline], items)]), hardline, "]"];
+}
+function jsonDoc(src) {
+  const j = parseJson(src);
+  return j ? print(j) : void 0;
+}
+
+// src/print.ts
+var { group: group2, indent: indent2, line: line2, softline: softline2, hardline: hardline2, fill, literalline } = doc2.builders;
+var { replaceEndOfLine } = doc2.utils;
+var WS_SPLIT = /([ \t\n\r\f]+)/;
+var IGNORE = /^<!--\s*prettier-ignore\s*-->$/;
+var isWord = (x) => !!x && "word" in x;
+var neighbor = (x) => x === null ? null : "word" in x ? { other: true } : x.node.type === "element" ? { el: x.node.name } : { other: true };
+var blockyNode = (n) => !!n && ["element", "if", "for", "directive", "schema"].includes(n.type);
+var blocky = (x) => !!x && "node" in x && blockyNode(x.node);
+var edgeBlocky = (x) => !!x && "node" in x && (x.node.type === "element" ? isBlockLevel(x.node.name) : blockyNode(x.node));
+var newGap = () => ({ ws: false, hidden: [], runs: [{ ws: false, newlines: 0 }] });
+function split(children) {
+  const items = [];
+  const gaps = [newGap()];
+  const gap = () => gaps[gaps.length - 1];
+  let ignoreNext = false;
+  const push = (it) => {
+    items.push(it);
+    gaps.push(newGap());
+  };
+  for (const n of children) {
+    if (n.type === "text") {
+      for (const part of n.value.split(WS_SPLIT)) {
+        if (part === "") continue;
+        if (/^[ \t\n\r\f]+$/.test(part)) {
+          const run = gap().runs[gap().runs.length - 1];
+          gap().ws = true;
+          run.ws = true;
+          run.newlines = Math.max(run.newlines, (part.match(/\n/g) ?? []).length);
+        } else {
+          push({ word: part });
+          ignoreNext = false;
+        }
+      }
+    } else if (n.type === "comment" || n.type === "schema") {
+      gap().hidden.push(n);
+      gap().runs.push({ ws: false, newlines: 0 });
+      if (n.type === "comment" && IGNORE.test(n.value)) ignoreNext = true;
+    } else {
+      push({ node: n, ignore: ignoreNext });
+      ignoreNext = false;
+    }
+  }
+  return { items, gaps };
+}
+function isFree(items, i, ctx, edges) {
+  const L = items[i - 1] ?? null;
+  const R = items[i] ?? null;
+  if (isWord(L) && isWord(R)) return false;
+  if (isWord(L)) return freeBeside(neighbor(R), ctx, edges);
+  if (isWord(R)) return freeBeside(neighbor(L), ctx, edges);
+  return freeBeside(neighbor(L), ctx, edges) || freeBeside(neighbor(R), ctx, edges);
+}
+var verbatim = (s) => replaceEndOfLine(s, literalline);
+function printList(children, ctx, edges, c) {
+  const { items, gaps } = split(children);
+  const parts = [];
+  let keepSpace = false;
+  gaps.forEach((g, i) => {
+    const L = items[i - 1] ?? null;
+    const R = items[i] ?? null;
+    const free = isFree(items, i, ctx, edges);
+    if (!free && g.ws) keepSpace = true;
+    g.runs.forEach((run, k) => {
+      const edge = L === null || R === null;
+      const near = (x) => edge && edges ? edgeBlocky(x) : blocky(x);
+      const left = k === 0 ? near(L) : blockyNode(g.hidden[k - 1]);
+      const right = k === g.runs.length - 1 ? near(R) : blockyNode(g.hidden[k]);
+      const inner = (k > 0 || L !== null) && (k < g.runs.length - 1 || R !== null);
+      const hard = inner && run.newlines >= 2 ? BLANK : hardline2;
+      let sep2;
+      if (free) sep2 = g.hidden.length || left || right ? hard : softline2;
+      else if (run.ws) sep2 = run.newlines > 0 && (left || right) ? hard : line2;
+      else sep2 = "";
+      parts.push(sep2);
+      if (k < g.hidden.length) parts.push(printNode(g.hidden[k], ctx, c));
+    });
+    if (R) parts.push(printItem(R, ctx, c));
+  });
+  return { parts, keepSpace };
+}
+var BLANK = [hardline2, hardline2];
+var isHard = (d) => d === hardline2 || d === BLANK;
+function layout(body) {
+  const out = [];
+  let run = [];
+  for (let i = 0; i < body.length; i++) {
+    if (i % 2 === 1 && isHard(body[i])) {
+      out.push(fill(run), body[i]);
+      run = [];
+    } else run.push(body[i]);
+  }
+  out.push(fill(run));
+  return out;
+}
+function wrapList({ parts, keepSpace }) {
+  if (parts.length === 1) return keepSpace ? " " : "";
+  return [indent2([parts[0], layout(parts.slice(1, -1))]), parts[parts.length - 1]];
+}
+function printItem(it, ctx, c) {
+  if ("word" in it) return it.word;
+  if (it.ignore) return verbatim(c.src.slice(it.node.start, it.node.end));
+  return printNode(it.node, ctx, c);
+}
+function printNode(n, ctx, c) {
+  switch (n.type) {
+    case "text":
+      return n.value;
+    case "comment":
+      return verbatim(n.value);
+    case "interp":
+      return `{{ ${formatExpr(n.src, c.quote)} }}`;
+    case "directive":
+      return `{% ${formatDirective(n.src, n.kw, c.quote)} %}`;
+    case "schema": {
+      const j = jsonDoc(n.json);
+      if (!j) return verbatim(`<hk-schema>${n.raw}</hk-schema>`);
+      return c.opts.indentSchema ? ["<hk-schema>", indent2([hardline2, j]), hardline2, "</hk-schema>"] : ["<hk-schema>", hardline2, j, hardline2, "</hk-schema>"];
+    }
+    case "if": {
+      const parts = [];
+      for (const b of n.branches) parts.push(`{% ${formatDirective(b.src, keywordOf(b.src), c.quote)} %}`, wrapList(printList(b.body, ctx, false, c)));
+      if (n.else) parts.push(`{% ${formatDirective(n.else.src, keywordOf(n.else.src), c.quote)} %}`, wrapList(printList(n.else.body, ctx, false, c)));
+      parts.push(`{% ${formatDirective(n.endSrc, keywordOf(n.endSrc), c.quote)} %}`);
+      return group2(parts);
+    }
+    case "for":
+      return group2([
+        `{% ${formatDirective(n.src, "for", c.quote)} %}`,
+        wrapList(printList(n.body, ctx, false, c)),
+        `{% ${formatDirective(n.endSrc, keywordOf(n.endSrc), c.quote)} %}`
+      ]);
+    case "element": {
+      const open = printOpenTag(n, c);
+      if (n.selfClosing || VOID_ELEMENTS2.has(n.name.toLowerCase())) return open;
+      const close = `</${n.name}>`;
+      const inner = innerContext(n.name, ctx);
+      if (inner === "raw") return [open, verbatim(c.src.slice(n.openEnd, n.closeStart)), close];
+      return group2([open, wrapList(printList(n.children, inner, true, c)), close]);
+    }
+  }
+}
+function printOpenTag(n, c) {
+  const attrs = n.attrs.map((a) => printAttr(a, c));
+  if (attrs.length === 0) return n.selfClosing ? `<${n.name} />` : `<${n.name}>`;
+  return group2([`<${n.name}`, indent2([line2, join2(line2, attrs)]), n.selfClosing ? [line2, "/>"] : [softline2, ">"]]);
+}
+var join2 = doc2.builders.join;
+var same2 = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+var INTERP = /\{\{([\s\S]*?)\}\}/g;
+function attrMeaning(v) {
+  const parts = [];
+  let last = 0;
+  for (const m of v.matchAll(INTERP)) {
+    if (m.index > last) parts.push(v.slice(last, m.index));
+    parts.push(parseExpr2(m[1].trim()));
+    last = m.index + m[0].length;
+  }
+  if (last < v.length) parts.push(v.slice(last));
+  return parts;
+}
+function printAttr(a, c) {
+  if (a.value === null) return a.name;
+  const v = a.value;
+  const pref = c.opts.singleQuote ? "'" : '"';
+  const other = pref === '"' ? "'" : '"';
+  for (const q of [pref, other]) {
+    const nv = v.includes("{{") ? v.replace(INTERP, (_m, e) => `{{ ${formatExpr(e.trim(), q === '"' ? "'" : '"')} }}`) : v;
+    if (!nv.includes(q) && same2(attrMeaning(nv), attrMeaning(v))) return `${a.name}=${q}${nv}${q}`;
+  }
+  return `${a.name}=${a.quote}${v}${a.quote}`;
+}
+function print2(path, options2) {
+  const root = path.node;
+  const c = { src: root.source, opts: options2, quote: options2.sneferuSingleQuote ? "'" : '"' };
+  const { parts } = printList(root.children, "block", true, c);
+  if (parts.length === 1) return "";
+  return [layout(parts.slice(1, -1)), hardline2];
+}
+
+// src/index.ts
+var languages = [
+  { name: "Sneferu", parsers: ["sneferu"], extensions: [".sneferu"], vscodeLanguageIds: ["sneferu"] }
+];
+var parsers = {
+  sneferu: {
+    parse: (text) => parse(text),
+    astFormat: "sneferu-ast",
+    locStart: (n) => n.start,
+    locEnd: (n) => n.end
+  }
+};
+var printers = {
+  "sneferu-ast": { print: print2 }
+};
+var options = {
+  sneferuSingleQuote: {
+    type: "boolean",
+    category: "Sneferu",
+    default: true,
+    description: "Use single quotes for strings inside {{ }} and {% %} (a string that contains a single quote keeps double quotes)."
+  },
+  indentSchema: {
+    type: "boolean",
+    category: "Sneferu",
+    default: true,
+    description: "Indent the JSON inside <hk-schema> one level."
+  }
+};
+var defaultOptions = { printWidth: 120, tabWidth: 2 };
+var plugin = { languages, parsers, printers, options, defaultOptions };
+var index_default = plugin;
+export {
+  index_default as default,
+  defaultOptions,
+  languages,
+  options,
+  parse,
+  parsers,
+  printers
+};

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@hekana/prettier-plugin-sneferu",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Prettier plugin for Sneferu theme files (.sneferu)",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "prettier",
+    "prettier-plugin",
+    "sneferu",
+    "hekana",
+    "theme"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "dependencies": {
+    "@hekana/sneferu-compiler": "^0.2.0"
+  },
+  "peerDependencies": {
+    "prettier": "^3.0.0"
+  },
+  "devDependencies": {
+    "prettier": "^3.6.2",
+    "@hekana/sneferu-components": "^0.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://hekana.dev/guide/format-your-theme",
+  "author": "Hekana",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "typecheck": "tsc --noEmit"
+  }
 }