@riebeckite/plugin-dataview 0.0.1

package/dist/index.js

@@ -0,0 +1,1258 @@
+// index.ts
+import {
+  createStyleAsset,
+  definePlugin
+} from "@riebeckite/core";
+
+// src/remark.ts
+import { visit } from "unist-util-visit";
+
+// src/parse.ts
+var QUERY_TYPES = /* @__PURE__ */ new Set([
+  "list",
+  "table",
+  "task",
+  "calendar"
+]);
+var CLAUSE_PATTERN = /^(from|where|sort|group\s+by|limit)\b(.*)$/i;
+var FIELD_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*$/;
+var DataviewParseError = class extends Error {
+};
+function parseDataview(source) {
+  try {
+    return { status: "ok", spec: parseSpec(source) };
+  } catch (error) {
+    return {
+      status: "error",
+      message: error instanceof DataviewParseError ? error.message : error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function parseSpec(source) {
+  const lines = source.split(/\r?\n/);
+  const firstIndex = lines.findIndex((line) => line.trim().length > 0);
+  if (firstIndex < 0) {
+    throw new DataviewParseError("the dataview block is empty.");
+  }
+  const first = lines[firstIndex].trim();
+  const typeMatch = /^([A-Za-z]+)\b(.*)$/.exec(first);
+  if (!typeMatch) {
+    throw new DataviewParseError("a dataview block must start with a query type.");
+  }
+  const type = typeMatch[1].toLowerCase();
+  if (!QUERY_TYPES.has(type)) {
+    throw new DataviewParseError(
+      `unsupported query type \`${typeMatch[1]}\`; expected LIST, TABLE, TASK, or CALENDAR.`
+    );
+  }
+  const { headLines, clauses } = segment(lines.slice(firstIndex + 1));
+  const headText = [typeMatch[2].trim(), ...headLines].filter((part) => part.length > 0).join(" ").trim();
+  let columns = [];
+  let expression = null;
+  if (type === "table") {
+    columns = headText.length > 0 ? parseColumns(headText) : [{ field: "file.link" }];
+  } else if (type === "list" || type === "calendar") {
+    expression = headText.length > 0 ? headText : null;
+  } else if (headText.length > 0) {
+    throw new DataviewParseError("TASK does not accept a column or expression list.");
+  }
+  const fromText = takeClause(clauses, "from");
+  const whereText = takeClause(clauses, "where");
+  const sortText = takeClause(clauses, "sort");
+  const groupText = takeClause(clauses, "group by");
+  const limitText = takeClause(clauses, "limit");
+  return {
+    type,
+    columns,
+    expression,
+    from: fromText ? parseFrom(fromText) : null,
+    where: whereText ? parseExpression(whereText) : null,
+    sort: sortText ? parseSort(sortText) : [],
+    groupBy: groupText ? parseField(groupText, "GROUP BY") : null,
+    limit: limitText ? parseLimit(limitText) : null
+  };
+}
+function segment(lines) {
+  const headLines = [];
+  const clauses = [];
+  let current = null;
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (line.length === 0) continue;
+    const match = CLAUSE_PATTERN.exec(line);
+    if (match) {
+      const key = match[1].toLowerCase().replace(/\s+/g, " ");
+      const text = match[2].trim();
+      if (current) clauses.push(current);
+      current = { key, lines: text.length > 0 ? [text] : [] };
+      continue;
+    }
+    if (current) current.lines.push(line);
+    else headLines.push(line);
+  }
+  if (current) clauses.push(current);
+  return { headLines, clauses };
+}
+function takeClause(clauses, key) {
+  const matches = clauses.filter((clause) => clause.key === key);
+  if (matches.length === 0) return null;
+  if (matches.length > 1) {
+    throw new DataviewParseError(`the \`${key.toUpperCase()}\` clause appears more than once.`);
+  }
+  const text = matches[0].lines.join(" ").trim();
+  if (text.length === 0) {
+    throw new DataviewParseError(`the \`${key.toUpperCase()}\` clause is empty.`);
+  }
+  return text;
+}
+function parseColumns(text) {
+  const parts = splitTopLevel(text, ",");
+  if (parts.length === 0) return [{ field: "file.link" }];
+  return parts.map(parseColumn);
+}
+function parseColumn(part) {
+  const asMatch = /\s+as\s+([\s\S]+)$/i.exec(part);
+  let fieldPart = part;
+  let label;
+  if (asMatch && asMatch.index !== void 0) {
+    fieldPart = part.slice(0, asMatch.index).trim();
+    label = unquote(asMatch[1].trim());
+  }
+  if (fieldPart.length === 0) {
+    throw new DataviewParseError("a TABLE column is empty.");
+  }
+  const field = parseField(fieldPart, "TABLE column");
+  return label === void 0 ? { field } : { field, label };
+}
+function parseSort(text) {
+  return splitTopLevel(text, ",").map((part) => {
+    const match = /^(\S+)(?:\s+(asc|desc))?$/i.exec(part.trim());
+    if (!match) {
+      throw new DataviewParseError(`unsupported SORT term \`${part}\`.`);
+    }
+    return {
+      field: parseField(match[1], "SORT"),
+      order: match[2]?.toLowerCase() ?? "asc"
+    };
+  });
+}
+function parseLimit(text) {
+  const match = /^(\d+)$/.exec(text.trim());
+  if (!match) {
+    throw new DataviewParseError(`LIMIT expects a non-negative integer, received \`${text}\`.`);
+  }
+  return Number(match[1]);
+}
+function parseField(value, context) {
+  const field = value.trim();
+  if (!FIELD_PATTERN.test(field)) {
+    throw new DataviewParseError(`unsupported ${context} field \`${field}\`.`);
+  }
+  return field;
+}
+var FROM_TOKEN_PATTERN = /(\[\[[^\]]*\]\])|(#[^\s()]+)|("(?:[^"\\]|\\.)*")|('(?:[^'\\]|\\.)*')|(\()|(\))|(!|-)|([^\s()]+)/g;
+function parseFrom(text) {
+  const tokens = [];
+  FROM_TOKEN_PATTERN.lastIndex = 0;
+  for (let match = FROM_TOKEN_PATTERN.exec(text); match !== null; match = FROM_TOKEN_PATTERN.exec(text)) {
+    tokens.push(toFromToken(match));
+  }
+  if (tokens.length === 0) {
+    throw new DataviewParseError("the FROM clause is empty.");
+  }
+  const state = { tokens, index: 0 };
+  const node = parseFromOr(state);
+  if (state.index < tokens.length) {
+    throw new DataviewParseError("unexpected token in FROM.");
+  }
+  return node;
+}
+function toFromToken(match) {
+  const [raw, link, tag, doubleQuoted, singleQuoted, lparen, rparen, negate] = match;
+  if (link !== void 0) {
+    const value = link.slice(2, -2).split("|")[0].split("#")[0].trim();
+    if (value.length === 0) {
+      throw new DataviewParseError("a link source in FROM is empty.");
+    }
+    return { type: "source", source: { kind: "link", value } };
+  }
+  if (tag !== void 0) {
+    return { type: "source", source: { kind: "tag", value: tag.slice(1) } };
+  }
+  if (doubleQuoted !== void 0 || singleQuoted !== void 0) {
+    return {
+      type: "source",
+      source: { kind: "folder", value: unquote(raw.trim()) }
+    };
+  }
+  if (lparen !== void 0) return { type: "lparen" };
+  if (rparen !== void 0) return { type: "rparen" };
+  if (negate !== void 0) return { type: "not" };
+  const word = (raw ?? "").toLowerCase();
+  if (word === "and") return { type: "and" };
+  if (word === "or") return { type: "or" };
+  return { type: "source", source: { kind: "folder", value: raw.trim() } };
+}
+function parseFromOr(state) {
+  let node = parseFromAnd(state);
+  while (state.tokens[state.index]?.type === "or") {
+    state.index += 1;
+    node = { kind: "or", left: node, right: parseFromAnd(state) };
+  }
+  return node;
+}
+function parseFromAnd(state) {
+  let node = parseFromUnary(state);
+  for (; ; ) {
+    const token = state.tokens[state.index];
+    if (token?.type === "and") {
+      state.index += 1;
+      node = { kind: "and", left: node, right: parseFromUnary(state) };
+      continue;
+    }
+    if (token?.type === "source" || token?.type === "lparen" || token?.type === "not") {
+      node = { kind: "and", left: node, right: parseFromUnary(state) };
+      continue;
+    }
+    return node;
+  }
+}
+function parseFromUnary(state) {
+  const token = state.tokens[state.index];
+  if (!token) throw new DataviewParseError("unexpected end of FROM.");
+  if (token.type === "not") {
+    state.index += 1;
+    return { kind: "not", child: parseFromUnary(state) };
+  }
+  if (token.type === "lparen") {
+    state.index += 1;
+    const node = parseFromOr(state);
+    if (state.tokens[state.index]?.type !== "rparen") {
+      throw new DataviewParseError("unbalanced parentheses in FROM.");
+    }
+    state.index += 1;
+    return node;
+  }
+  if (token.type === "source") {
+    state.index += 1;
+    return { kind: "source", source: token.source };
+  }
+  throw new DataviewParseError("unexpected token in FROM.");
+}
+function parseExpression(text) {
+  const tokens = tokenizeExpression(text);
+  if (tokens.length === 0) {
+    throw new DataviewParseError("the WHERE clause is empty.");
+  }
+  const state = { tokens, index: 0 };
+  const node = parseOr(state);
+  if (state.index < tokens.length) {
+    throw new DataviewParseError("unexpected token in the WHERE expression.");
+  }
+  return node;
+}
+function tokenizeExpression(text) {
+  const tokens = [];
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === void 0) break;
+    if (/\s/.test(char)) {
+      index += 1;
+      continue;
+    }
+    const pair = text.slice(index, index + 2);
+    if (pair === ">=" || pair === "<=" || pair === "!=") {
+      tokens.push({ type: "op", value: pair });
+      index += 2;
+      continue;
+    }
+    if (char === "=" || char === ">" || char === "<") {
+      tokens.push({ type: "op", value: char });
+      index += 1;
+      continue;
+    }
+    if (char === "!") {
+      tokens.push({ type: "not" });
+      index += 1;
+      continue;
+    }
+    if (char === "(") {
+      tokens.push({ type: "lparen" });
+      index += 1;
+      continue;
+    }
+    if (char === ")") {
+      tokens.push({ type: "rparen" });
+      index += 1;
+      continue;
+    }
+    if (char === ",") {
+      tokens.push({ type: "comma" });
+      index += 1;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      const quoted = readQuoted(text, index);
+      tokens.push({ type: "string", value: quoted.value });
+      index = quoted.next;
+      continue;
+    }
+    if (/[0-9]/.test(char) || char === "-" && /[0-9]/.test(text[index + 1] ?? "")) {
+      const match = /^-?\d+(?:\.\d+)?/.exec(text.slice(index));
+      if (match) {
+        tokens.push({ type: "number", value: Number(match[0]) });
+        index += match[0].length;
+        continue;
+      }
+    }
+    if (/[A-Za-z_$]/.test(char)) {
+      const match = /^[A-Za-z_$][A-Za-z0-9_$.]*/.exec(text.slice(index));
+      if (match) {
+        tokens.push({ type: "word", value: match[0] });
+        index += match[0].length;
+        continue;
+      }
+    }
+    throw new DataviewParseError(`unexpected character \`${char}\` in WHERE.`);
+  }
+  return tokens;
+}
+function readQuoted(text, start) {
+  const quote = text[start];
+  let value = "";
+  let index = start + 1;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === void 0) break;
+    if (char === "\\" && index + 1 < text.length) {
+      value += text[index + 1];
+      index += 2;
+      continue;
+    }
+    if (char === quote) return { value, next: index + 1 };
+    value += char;
+    index += 1;
+  }
+  throw new DataviewParseError("unterminated string literal in WHERE.");
+}
+function parseOr(state) {
+  let node = parseAnd(state);
+  while (isWord(state.tokens[state.index], "or")) {
+    state.index += 1;
+    node = { kind: "or", left: node, right: parseAnd(state) };
+  }
+  return node;
+}
+function parseAnd(state) {
+  let node = parseUnary(state);
+  while (isWord(state.tokens[state.index], "and")) {
+    state.index += 1;
+    node = { kind: "and", left: node, right: parseUnary(state) };
+  }
+  return node;
+}
+function parseUnary(state) {
+  if (state.tokens[state.index]?.type === "not") {
+    state.index += 1;
+    return { kind: "not", operand: parseUnary(state) };
+  }
+  return parseComparison(state);
+}
+function parseComparison(state) {
+  const left = parsePrimary(state);
+  const token = state.tokens[state.index];
+  if (token?.type !== "op") return left;
+  state.index += 1;
+  return {
+    kind: "compare",
+    operator: token.value,
+    left,
+    right: parsePrimary(state)
+  };
+}
+function parsePrimary(state) {
+  const token = state.tokens[state.index];
+  if (!token) {
+    throw new DataviewParseError("unexpected end of the WHERE expression.");
+  }
+  if (token.type === "lparen") {
+    state.index += 1;
+    const node = parseOr(state);
+    if (state.tokens[state.index]?.type !== "rparen") {
+      throw new DataviewParseError("unbalanced parentheses in WHERE.");
+    }
+    state.index += 1;
+    return node;
+  }
+  if (token.type === "string" || token.type === "number") {
+    state.index += 1;
+    return { kind: "literal", value: token.value };
+  }
+  if (token.type === "word") {
+    const lower = token.value.toLowerCase();
+    if (lower === "true" || lower === "false") {
+      state.index += 1;
+      return { kind: "literal", value: lower === "true" };
+    }
+    if (lower === "null") {
+      state.index += 1;
+      return { kind: "literal", value: null };
+    }
+    if (state.tokens[state.index + 1]?.type === "lparen") {
+      return parseCall(state, lower);
+    }
+    state.index += 1;
+    return { kind: "field", path: token.value.split(".") };
+  }
+  throw new DataviewParseError("unexpected token in the WHERE expression.");
+}
+function parseCall(state, name) {
+  state.index += 2;
+  const args = [];
+  if (state.tokens[state.index]?.type !== "rparen") {
+    args.push(parseOr(state));
+    while (state.tokens[state.index]?.type === "comma") {
+      state.index += 1;
+      args.push(parseOr(state));
+    }
+  }
+  if (state.tokens[state.index]?.type !== "rparen") {
+    throw new DataviewParseError(`unbalanced parentheses in \`${name}()\`.`);
+  }
+  state.index += 1;
+  return { kind: "call", name, args };
+}
+function isWord(token, value) {
+  return token?.type === "word" && token.value.toLowerCase() === value;
+}
+function splitTopLevel(text, separator) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  let quote = null;
+  for (const char of text) {
+    if (quote) {
+      current += char;
+      if (char === quote) quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      current += char;
+      continue;
+    }
+    if (char === "(") depth += 1;
+    if (char === ")") depth = Math.max(0, depth - 1);
+    if (char === separator && depth === 0) {
+      parts.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  parts.push(current.trim());
+  return parts.filter((part) => part.length > 0);
+}
+function unquote(value) {
+  if (value.length >= 2) {
+    const first = value[0];
+    const last = value[value.length - 1];
+    if (first === '"' && last === '"' || first === "'" && last === "'") {
+      return value.slice(1, -1);
+    }
+  }
+  return value;
+}
+
+// src/placeholder.ts
+var DATAVIEW_ATTRIBUTE = "data-rr-dataview";
+function encodeDataviewSource(source) {
+  return encodeURIComponent(source);
+}
+function decodeDataviewSource(encoded) {
+  return decodeURIComponent(encoded);
+}
+function createDataviewPlaceholder(source) {
+  return `<div ${DATAVIEW_ATTRIBUTE}="${encodeDataviewSource(source)}"></div>`;
+}
+function createDataviewPlaceholderPattern() {
+  return new RegExp(
+    `<div\\b[^>]*\\b${DATAVIEW_ATTRIBUTE}="([^"]*)"[^>]*>\\s*</div>`,
+    "g"
+  );
+}
+
+// src/remark.ts
+var DATAVIEW_SOURCE = "@riebeckite/plugin-dataview";
+function remarkDataview(options = {}) {
+  const language = options.language ?? "dataview";
+  const unsupportedLanguage = `${language}js`;
+  return (tree, file) => {
+    visit(tree, "code", (node, index, parent) => {
+      if (node.lang === unsupportedLanguage) {
+        reportDataviewMessage(
+          file,
+          `DataviewJS blocks (\`${unsupportedLanguage}\`) are not supported; the block was left as code.`
+        );
+        return;
+      }
+      if (node.lang !== language) return;
+      if (!parent || index === void 0) return;
+      const parsed = parseDataview(node.value);
+      if (parsed.status === "error") {
+        reportDataviewMessage(
+          file,
+          `Unsupported dataview query: ${parsed.message}`
+        );
+      }
+      const html = {
+        type: "html",
+        value: createDataviewPlaceholder(node.value)
+      };
+      parent.children.splice(index, 1, html);
+    });
+  };
+}
+function reportDataviewMessage(file, message) {
+  const reporter = file?.message;
+  if (typeof reporter !== "function") return;
+  const diagnostic = reporter.call(file, message);
+  if (diagnostic && typeof diagnostic === "object") {
+    Object.assign(diagnostic, { source: DATAVIEW_SOURCE });
+  }
+}
+
+// src/evaluate.ts
+var DataviewEvaluationError = class extends Error {
+};
+function selectDataviewEntries(spec, manifest, defaultLimit) {
+  let entries = manifest.entries.filter(
+    (entry) => matchesDataviewFrom(spec.from, entry, manifest)
+  );
+  if (spec.where) {
+    entries = entries.filter(
+      (entry) => isTruthy(
+        evaluateDataviewExpression(spec.where, {
+          entry,
+          manifest
+        })
+      )
+    );
+  }
+  if (spec.sort.length > 0) {
+    entries = sortEntries(entries, spec.sort, manifest);
+  }
+  const limit = spec.limit ?? defaultLimit;
+  if (limit !== null) entries = entries.slice(0, limit);
+  if (spec.groupBy) {
+    return {
+      entries,
+      groups: groupEntries(entries, spec.groupBy, manifest),
+      grouped: true
+    };
+  }
+  return { entries, groups: [], grouped: false };
+}
+function matchesDataviewFrom(from, entry, manifest) {
+  if (!from) return true;
+  switch (from.kind) {
+    case "source":
+      return matchesSource(from.source, entry, manifest);
+    case "not":
+      return !matchesDataviewFrom(from.child, entry, manifest);
+    case "and":
+      return matchesDataviewFrom(from.left, entry, manifest) && matchesDataviewFrom(from.right, entry, manifest);
+    case "or":
+      return matchesDataviewFrom(from.left, entry, manifest) || matchesDataviewFrom(from.right, entry, manifest);
+    default:
+      return true;
+  }
+}
+function matchesSource(source, entry, manifest) {
+  switch (source.kind) {
+    case "tag": {
+      const wanted = stripHash(source.value).toLowerCase();
+      return entry.tags.some((tag) => tag.toLowerCase() === wanted);
+    }
+    case "folder": {
+      const folder = normalizeFolder(source.value);
+      if (folder.length === 0) return true;
+      return entry.slug === folder || entry.slug.startsWith(`${folder}/`);
+    }
+    case "link": {
+      const target = manifest.contentIndex.get(source.value.toLowerCase());
+      if (!target) return false;
+      const sources = manifest.incomingLinks.get(target) ?? [];
+      return sources.includes(entry.slug);
+    }
+    default:
+      return false;
+  }
+}
+function evaluateDataviewExpression(expression, scope) {
+  switch (expression.kind) {
+    case "literal":
+      return expression.value;
+    case "field":
+      return readDataviewField(scope.entry, expression.path, scope.manifest);
+    case "not":
+      return !isTruthy(evaluateDataviewExpression(expression.operand, scope));
+    case "and":
+      return isTruthy(evaluateDataviewExpression(expression.left, scope)) && isTruthy(evaluateDataviewExpression(expression.right, scope));
+    case "or":
+      return isTruthy(evaluateDataviewExpression(expression.left, scope)) || isTruthy(evaluateDataviewExpression(expression.right, scope));
+    case "compare":
+      return compareValues(
+        expression.operator,
+        evaluateDataviewExpression(expression.left, scope),
+        evaluateDataviewExpression(expression.right, scope)
+      );
+    case "call":
+      return callFunction(expression, scope);
+    default:
+      return void 0;
+  }
+}
+function callFunction(expression, scope) {
+  const args = expression.args.map(
+    (arg) => evaluateDataviewExpression(arg, scope)
+  );
+  switch (expression.name) {
+    case "contains":
+      return containsValue(args[0], args[1]);
+    case "date":
+      return toDataviewTime(args[0]);
+    case "number": {
+      const numeric = toNumber(args[0]);
+      return numeric === null ? null : numeric;
+    }
+    case "string":
+      return args[0] === void 0 || args[0] === null ? null : String(args[0]);
+    default:
+      throw new DataviewEvaluationError(
+        `unsupported function \`${expression.name}()\` in WHERE.`
+      );
+  }
+}
+function readDataviewField(entry, path, _manifest) {
+  if (path.length === 0) return void 0;
+  const [head, ...rest] = path;
+  if (head === "file") return readFileField(entry, rest);
+  if (rest.length === 0 && (head === "title" || head === "tags")) {
+    if (head === "title") return entry.title;
+    return entry.tags;
+  }
+  return readNested(entry.frontmatter, path);
+}
+function readFileField(entry, path) {
+  const field = path[0];
+  if (!field) return void 0;
+  switch (field) {
+    case "name":
+    case "title":
+      return entry.title;
+    case "slug":
+    case "path":
+      return entry.slug;
+    case "folder":
+      return folderOf(entry.slug);
+    case "link":
+    case "permalink":
+    case "url":
+      return entry.permalink;
+    case "tags":
+      return entry.tags;
+    case "date":
+      return entry.frontmatter.date ?? entry.frontmatter.created ?? entry.frontmatter.published ?? entry.frontmatter.updated;
+    case "created":
+      return entry.frontmatter.created;
+    case "updated":
+      return entry.frontmatter.updated;
+    case "published":
+      return entry.frontmatter.published;
+    default:
+      return void 0;
+  }
+}
+function readNested(value, path) {
+  let current = value;
+  for (const key of path) {
+    if (current === null || typeof current !== "object") return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function isTruthy(value) {
+  if (value === null || value === void 0) return false;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) && value !== 0;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (Array.isArray(value)) return value.length > 0;
+  if (value instanceof Date) return Number.isFinite(value.getTime());
+  return true;
+}
+function compareValues(operator, left, right) {
+  if (operator === "=") return looseEquals(left, right);
+  if (operator === "!=") return !looseEquals(left, right);
+  const order = compareOrder(left, right);
+  if (order === null) return false;
+  switch (operator) {
+    case ">":
+      return order > 0;
+    case "<":
+      return order < 0;
+    case ">=":
+      return order >= 0;
+    case "<=":
+      return order <= 0;
+  }
+}
+function looseEquals(left, right) {
+  if (left === null || left === void 0 || right === null || right === void 0) {
+    return (left ?? null) === (right ?? null);
+  }
+  const leftValue = left instanceof Date ? left.getTime() : left;
+  const rightValue = right instanceof Date ? right.getTime() : right;
+  if (typeof leftValue === "boolean" || typeof rightValue === "boolean") {
+    return leftValue === rightValue;
+  }
+  const leftNumber = toNumber(leftValue);
+  const rightNumber = toNumber(rightValue);
+  if (leftNumber !== null && rightNumber !== null) {
+    return leftNumber === rightNumber;
+  }
+  return String(leftValue).toLowerCase() === String(rightValue).toLowerCase();
+}
+function compareOrder(left, right) {
+  const leftValue = normalizeComparable(left);
+  const rightValue = normalizeComparable(right);
+  if (leftValue === null || rightValue === null) return null;
+  if (typeof leftValue === "number" && typeof rightValue === "number") {
+    return leftValue < rightValue ? -1 : leftValue > rightValue ? 1 : 0;
+  }
+  const leftText = String(leftValue).toLowerCase();
+  const rightText = String(rightValue).toLowerCase();
+  return leftText < rightText ? -1 : leftText > rightText ? 1 : 0;
+}
+function normalizeComparable(value) {
+  if (value === null || value === void 0) return null;
+  if (value instanceof Date) {
+    return Number.isFinite(value.getTime()) ? value.getTime() : null;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length > 0 && /^-?\d+(?:\.\d+)?$/.test(trimmed)) {
+      return Number(trimmed);
+    }
+    return value;
+  }
+  return String(value);
+}
+function containsValue(container, expected) {
+  if (container === null || container === void 0) return false;
+  if (Array.isArray(container)) {
+    return container.some((item) => looseTagEquals(item, expected));
+  }
+  if (typeof container === "string") {
+    if (expected === null || expected === void 0) return false;
+    return container.toLowerCase().includes(String(expected).toLowerCase());
+  }
+  return false;
+}
+function looseTagEquals(left, right) {
+  if (typeof left === "string" && typeof right === "string") {
+    return stripHash(left).toLowerCase() === stripHash(right).toLowerCase();
+  }
+  return looseEquals(left, right);
+}
+function toNumber(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (value instanceof Date) {
+    return Number.isFinite(value.getTime()) ? value.getTime() : null;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) return null;
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function toDataviewTime(value) {
+  if (value === null || value === void 0) return null;
+  if (value instanceof Date) {
+    return Number.isFinite(value.getTime()) ? value.getTime() : null;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return null;
+  const parsed = Date.parse(trimmed);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+function sortEntries(entries, sort, manifest) {
+  return [...entries].sort((left, right) => {
+    for (const key of sort) {
+      const path = key.field.split(".");
+      const leftValue = readDataviewField(left, path, manifest);
+      const rightValue = readDataviewField(right, path, manifest);
+      if (leftValue === void 0 && rightValue === void 0) continue;
+      if (leftValue === void 0) return 1;
+      if (rightValue === void 0) return -1;
+      const order = compareOrder(leftValue, rightValue);
+      if (order === null) continue;
+      if (order !== 0) return key.order === "desc" ? -order : order;
+    }
+    return 0;
+  });
+}
+function groupEntries(entries, field, manifest) {
+  const groups = /* @__PURE__ */ new Map();
+  const path = field.split(".");
+  for (const entry of entries) {
+    const key = formatGroupKey(readDataviewField(entry, path, manifest));
+    const bucket = groups.get(key) ?? [];
+    bucket.push(entry);
+    groups.set(key, bucket);
+  }
+  return [...groups.entries()].map(([key, bucket]) => ({
+    key,
+    entries: bucket
+  }));
+}
+function formatGroupKey(value) {
+  if (value === null || value === void 0) return "(none)";
+  if (value instanceof Date) {
+    return Number.isFinite(value.getTime()) ? value.toISOString().slice(0, 10) : "(none)";
+  }
+  if (Array.isArray(value)) return value.map((item) => String(item)).join(", ");
+  return String(value);
+}
+function stripHash(value) {
+  return value.startsWith("#") ? value.slice(1) : value;
+}
+function normalizeFolder(value) {
+  return value.trim().replace(/^\/+|\/+$/g, "");
+}
+function folderOf(slug) {
+  const index = slug.lastIndexOf("/");
+  return index < 0 ? "" : slug.slice(0, index);
+}
+
+// src/render.ts
+import {
+  escapeHtml,
+  escapeHtmlAttribute
+} from "@riebeckite/core";
+var DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+var TASK_ITEM_PATTERN = /<li class="task-list-item">\s*(?:<p>)?<input type="checkbox"([^>]*)>([\s\S]*?)(?:<\/p>)?\s*<\/li>/g;
+var LINK_FIELDS = /* @__PURE__ */ new Set([
+  "file.link",
+  "file.permalink",
+  "file.url",
+  "link",
+  "permalink",
+  "url"
+]);
+var TITLE_FIELDS = /* @__PURE__ */ new Set(["file.name", "file.title", "title", "name"]);
+var MONTH_NAMES = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var WEEKDAY_NAMES = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+function renderDataview(selection, spec, options, source) {
+  const className = options.className;
+  const body = renderBody(selection, spec, options);
+  const fallback = renderFallback(source, className, options.hideFallback);
+  return `<div class="${escapeHtmlAttribute(className)}" data-dataview data-dataview-type="${spec.type}">${body}${fallback}</div>`;
+}
+function renderDataviewError(message, source, options) {
+  const className = options.className;
+  const fallback = renderFallback(source, className, options.hideFallback);
+  return `<div class="${escapeHtmlAttribute(className)} ${escapeHtmlAttribute(`${className}--error`)}" data-dataview role="status"><p class="${escapeHtmlAttribute(`${className}__error`)}">${escapeHtml(message)}</p>${fallback}</div>`;
+}
+function renderBody(selection, spec, options) {
+  switch (spec.type) {
+    case "table":
+      return renderTable(selection, spec, options);
+    case "task":
+      return renderTasks(selection, options);
+    case "calendar":
+      return renderCalendar(selection, spec, options);
+    default:
+      return renderList(selection, spec, options);
+  }
+}
+function renderList(selection, spec, options) {
+  const className = options.className;
+  const sections = groupedSections(selection);
+  let output = "";
+  let total = 0;
+  for (const section of sections) {
+    if (section.entries.length === 0) continue;
+    const items = section.entries.map((entry) => {
+      const meta = spec.expression ? renderMeta(entry, spec.expression, className) : "";
+      return `<li class="${escapeHtmlAttribute(`${className}__item`)}">${renderEntryLink(entry, className)}${meta}</li>`;
+    }).join("");
+    total += section.entries.length;
+    output += `${renderGroupHeading(section.key, className)}<ul class="${escapeHtmlAttribute(`${className}__list`)}">${items}</ul>`;
+  }
+  return total === 0 ? renderEmpty(className) : output;
+}
+function renderTable(selection, spec, options) {
+  const className = options.className;
+  const columns = spec.columns.length > 0 ? spec.columns : [{ field: "file.link" }];
+  const sections = groupedSections(selection);
+  let rows = "";
+  let total = 0;
+  for (const section of sections) {
+    if (section.entries.length === 0) continue;
+    if (section.key !== null) {
+      rows += `<tr class="${escapeHtmlAttribute(`${className}__group-row`)}"><th class="${escapeHtmlAttribute(`${className}__group-cell`)}" colspan="${columns.length}">${escapeHtml(section.key)}</th></tr>`;
+    }
+    for (const entry of section.entries) {
+      total += 1;
+      const cells = columns.map(
+        (column) => `<td class="${escapeHtmlAttribute(`${className}__cell`)}">${renderColumnValue(entry, column, className)}</td>`
+      ).join("");
+      rows += `<tr class="${escapeHtmlAttribute(`${className}__row`)}">${cells}</tr>`;
+    }
+  }
+  if (total === 0) return renderEmpty(className);
+  const head = columns.map(
+    (column) => `<th class="${escapeHtmlAttribute(`${className}__heading`)}" scope="col">${escapeHtml(columnLabel(column))}</th>`
+  ).join("");
+  return `<table class="${escapeHtmlAttribute(`${className}__table`)}"><thead><tr>${head}</tr></thead><tbody>${rows}</tbody></table>`;
+}
+function renderTasks(selection, options) {
+  const className = options.className;
+  const sections = groupedSections(selection);
+  let output = "";
+  let total = 0;
+  for (const section of sections) {
+    const items = [];
+    for (const entry of section.entries) {
+      for (const task of extractTasks(entry)) {
+        items.push(renderTaskItem(task, entry, className));
+        total += 1;
+      }
+    }
+    if (items.length === 0) continue;
+    output += `${renderGroupHeading(section.key, className)}<ul class="${escapeHtmlAttribute(`${className}__tasks`)}">${items.join("")}</ul>`;
+  }
+  return total === 0 ? renderEmpty(className) : output;
+}
+function renderCalendar(selection, spec, options) {
+  const className = options.className;
+  const field = spec.expression ?? "date";
+  const path = field.split(".");
+  const dated = selection.entries.map((entry) => ({
+    entry,
+    time: toDataviewTime(readDataviewField(entry, path))
+  })).filter(
+    (item) => item.time !== null
+  );
+  if (dated.length === 0) return renderEmpty(className);
+  const latest = Math.max(...dated.map((item) => item.time));
+  const base = new Date(latest);
+  const year = base.getUTCFullYear();
+  const month = base.getUTCMonth();
+  const byDay = /* @__PURE__ */ new Map();
+  for (const item of dated) {
+    const date = new Date(item.time);
+    if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month) continue;
+    const day = date.getUTCDate();
+    const bucket = byDay.get(day) ?? [];
+    bucket.push(item.entry);
+    byDay.set(day, bucket);
+  }
+  const firstWeekday = new Date(Date.UTC(year, month, 1)).getUTCDay();
+  const daysInMonth = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+  const header = WEEKDAY_NAMES.map(
+    (name) => `<th class="${escapeHtmlAttribute(`${className}__calendar-weekday`)}" scope="col">${escapeHtml(name)}</th>`
+  ).join("");
+  const cells = [];
+  for (let index = 0; index < firstWeekday; index += 1) {
+    cells.push(
+      `<td class="${escapeHtmlAttribute(`${className}__calendar-cell ${className}__calendar-cell--empty`)}"></td>`
+    );
+  }
+  for (let day = 1; day <= daysInMonth; day += 1) {
+    const entries = byDay.get(day) ?? [];
+    const links = entries.map((entry) => renderEntryLink(entry, className)).join(" ");
+    cells.push(
+      `<td class="${escapeHtmlAttribute(`${className}__calendar-cell`)}"><span class="${escapeHtmlAttribute(`${className}__calendar-day`)}">${day}</span>${links ? `<span class="${escapeHtmlAttribute(`${className}__calendar-links`)}">${links}</span>` : ""}</td>`
+    );
+  }
+  while (cells.length % 7 !== 0) {
+    cells.push(
+      `<td class="${escapeHtmlAttribute(`${className}__calendar-cell ${className}__calendar-cell--empty`)}"></td>`
+    );
+  }
+  const rows = [];
+  for (let index = 0; index < cells.length; index += 7) {
+    rows.push(`<tr>${cells.slice(index, index + 7).join("")}</tr>`);
+  }
+  return `<table class="${escapeHtmlAttribute(`${className}__calendar`)}"><caption class="${escapeHtmlAttribute(`${className}__calendar-caption`)}">${escapeHtml(`${MONTH_NAMES[month]} ${year}`)}</caption><thead><tr>${header}</tr></thead><tbody>${rows.join("")}</tbody></table>`;
+}
+function groupedSections(selection) {
+  if (selection.grouped) {
+    return selection.groups.map((group) => ({
+      key: group.key,
+      entries: group.entries
+    }));
+  }
+  return [{ key: null, entries: selection.entries }];
+}
+function renderGroupHeading(key, className) {
+  if (key === null) return "";
+  return `<p class="${escapeHtmlAttribute(`${className}__group`)}">${escapeHtml(key)}</p>`;
+}
+function renderColumnValue(entry, column, className) {
+  return renderFieldValue(entry, column.field, className);
+}
+function renderMeta(entry, field, className) {
+  const value = renderFieldValue(entry, field.trim(), className);
+  if (!value) return "";
+  return ` <span class="${escapeHtmlAttribute(`${className}__meta`)}">${value}</span>`;
+}
+function renderFieldValue(entry, field, className) {
+  const normalized = field.trim();
+  if (LINK_FIELDS.has(normalized) || TITLE_FIELDS.has(normalized)) {
+    return renderEntryLink(entry, className);
+  }
+  if (normalized === "file.tags" || normalized === "tags") {
+    return renderTags(entry.tags, className);
+  }
+  const value = readDataviewField(entry, normalized.split("."));
+  return escapeHtml(formatValue(value));
+}
+function renderEntryLink(entry, className) {
+  return `<a class="${escapeHtmlAttribute(`${className}__link`)}" href="${escapeHtmlAttribute(entry.permalink)}">${escapeHtml(entry.title)}</a>`;
+}
+function renderTags(tags, className) {
+  return tags.map(
+    (tag) => `<span class="${escapeHtmlAttribute(`${className}__tag`)}">#${escapeHtml(tag)}</span>`
+  ).join(" ");
+}
+function extractTasks(entry) {
+  const tasks = [];
+  TASK_ITEM_PATTERN.lastIndex = 0;
+  for (let match = TASK_ITEM_PATTERN.exec(entry.html); match !== null; match = TASK_ITEM_PATTERN.exec(entry.html)) {
+    const attributes = match[1] ?? "";
+    const text = (match[2] ?? "").trim();
+    tasks.push({ checked: /\bchecked\b/.test(attributes), text });
+  }
+  return tasks;
+}
+function renderTaskItem(task, entry, className) {
+  const status = task.checked ? "x" : " ";
+  return `<li class="${escapeHtmlAttribute(`${className}__task`)}" data-task="${status}"><span class="${escapeHtmlAttribute(`${className}__task-text`)}">${task.text}</span> <a class="${escapeHtmlAttribute(`${className}__task-link`)}" href="${escapeHtmlAttribute(entry.permalink)}">${escapeHtml(entry.title)}</a></li>`;
+}
+function renderFallback(source, className, hideFallback) {
+  if (hideFallback) return "";
+  const trimmed = source.trim();
+  if (trimmed.length === 0) return "";
+  return `<details class="${escapeHtmlAttribute(`${className}__fallback`)}"><summary class="${escapeHtmlAttribute(`${className}__fallback-summary`)}">Dataview query</summary><pre class="${escapeHtmlAttribute(`${className}__fallback-code`)}"><code>${escapeHtml(trimmed)}</code></pre></details>`;
+}
+function renderEmpty(className) {
+  return `<p class="${escapeHtmlAttribute(`${className}__empty`)}">No matching content.</p>`;
+}
+function columnLabel(column) {
+  return column.label ?? column.field;
+}
+function formatValue(value) {
+  if (value === void 0 || value === null) return "";
+  if (value instanceof Date) return formatDate(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => formatValue(item)).join(", ");
+  }
+  if (typeof value === "string") {
+    return DATE_ONLY.test(value.trim()) ? value.trim() : value;
+  }
+  return String(value);
+}
+function formatDate(value) {
+  const time = value.getTime();
+  if (!Number.isFinite(time)) return "";
+  return value.toISOString().slice(0, 10);
+}
+
+// src/types.ts
+var DEFAULT_DATAVIEW_CLASS_NAME = "rb-dataview";
+var DEFAULT_DATAVIEW_LANGUAGE = "dataview";
+function resolveDataviewOptions(options = {}) {
+  const className = options.className?.trim();
+  const language = options.language?.trim();
+  const limit = options.limit;
+  return {
+    className: className ? className : DEFAULT_DATAVIEW_CLASS_NAME,
+    language: language ? language : DEFAULT_DATAVIEW_LANGUAGE,
+    hideFallback: options.hideFallback === true,
+    limit: typeof limit === "number" && Number.isFinite(limit) && limit >= 0 ? Math.floor(limit) : null
+  };
+}
+
+// src/runtime.ts
+var DATAVIEWJS_MARKER = "language-dataviewjs";
+var PLUGIN_NAME = "dataview";
+function createDataviewRuntime(options = {}) {
+  const resolved = resolveDataviewOptions(options);
+  const tracked = /* @__PURE__ */ new Map();
+  return {
+    track(slug, content) {
+      tracked.set(slug, content);
+    },
+    resolve(manifest, diagnostics) {
+      for (const entry of manifest.entries) {
+        if (!entry.html.includes(DATAVIEW_ATTRIBUTE) && !entry.html.includes(DATAVIEWJS_MARKER)) {
+          continue;
+        }
+        const html = replacePlaceholders(entry, manifest, resolved, diagnostics);
+        if (html === entry.html) continue;
+        entry.html = html;
+        const content = tracked.get(entry.slug);
+        if (content) content.html = html;
+      }
+    }
+  };
+}
+function replacePlaceholders(entry, manifest, options, diagnostics) {
+  if (entry.html.includes(DATAVIEWJS_MARKER)) {
+    diagnostics.push({
+      code: "dataview-unsupported-language",
+      severity: "warning",
+      pluginName: PLUGIN_NAME,
+      slug: entry.slug,
+      message: "DataviewJS (`dataviewjs`) blocks are not supported and were left as code blocks."
+    });
+  }
+  if (!entry.html.includes(DATAVIEW_ATTRIBUTE)) return entry.html;
+  const pattern = createDataviewPlaceholderPattern();
+  return entry.html.replace(pattern, (_match, encoded) => {
+    let source;
+    try {
+      source = decodeDataviewSource(encoded);
+    } catch (error) {
+      const message = `Dataview block in \`${entry.slug}\` could not be decoded (${formatError(error)}).`;
+      reportInvalid(entry, diagnostics, message);
+      return renderDataviewError(message, "", options);
+    }
+    const parsed = parseDataview(source);
+    if (parsed.status === "error") {
+      const message = `Dataview block in \`${entry.slug}\` ${parsed.message}`;
+      reportInvalid(entry, diagnostics, message);
+      return renderDataviewError(message, source, options);
+    }
+    try {
+      const selection = selectDataviewEntries(
+        parsed.spec,
+        manifest,
+        options.limit
+      );
+      return renderDataview(selection, parsed.spec, options, source);
+    } catch (error) {
+      const message = `Dataview block in \`${entry.slug}\` is unsupported: ${formatError(error)}`;
+      reportInvalid(entry, diagnostics, message);
+      return renderDataviewError(message, source, options);
+    }
+  });
+}
+function reportInvalid(entry, diagnostics, message) {
+  diagnostics.push({
+    code: "dataview-invalid",
+    severity: "error",
+    pluginName: PLUGIN_NAME,
+    slug: entry.slug,
+    message
+  });
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// index.ts
+function dataviewPlugin(options = {}) {
+  const language = options.language ?? "dataview";
+  const runtime = createDataviewRuntime(options);
+  return definePlugin({
+    name: "dataview",
+    options,
+    provides: ["content.dataview"],
+    validateOptions: validateDataviewOptions,
+    extendMarkdownPipeline: (pipeline) => {
+      pipeline.use(remarkDataview, { language });
+    },
+    onPostProcessed: (context) => {
+      runtime.track(context.slug, context.content);
+    },
+    onManifestCreated: (context) => {
+      runtime.resolve(context.manifest, context.diagnostics);
+    },
+    assets: [createStyleAsset("dataview")]
+  });
+}
+var dataview = dataviewPlugin;
+function validateDataviewOptions(options) {
+  if (!options) return [];
+  const issues = [];
+  if (options.className !== void 0 && (typeof options.className !== "string" || options.className.trim() === "")) {
+    issues.push({ path: "className", message: "Expected a non-empty string." });
+  }
+  if (options.language !== void 0 && (typeof options.language !== "string" || options.language.trim() === "")) {
+    issues.push({ path: "language", message: "Expected a non-empty string." });
+  }
+  if (options.hideFallback !== void 0 && typeof options.hideFallback !== "boolean") {
+    issues.push({ path: "hideFallback", message: "Expected a boolean." });
+  }
+  if (options.limit !== void 0 && (!Number.isFinite(options.limit) || options.limit < 0)) {
+    issues.push({
+      path: "limit",
+      message: "Expected a non-negative finite number."
+    });
+  }
+  return issues;
+}
+export {
+  DATAVIEW_ATTRIBUTE,
+  DEFAULT_DATAVIEW_CLASS_NAME,
+  DEFAULT_DATAVIEW_LANGUAGE,
+  DataviewEvaluationError,
+  DataviewParseError,
+  createDataviewPlaceholder,
+  createDataviewPlaceholderPattern,
+  dataview,
+  dataviewPlugin,
+  evaluateDataviewExpression,
+  isTruthy,
+  matchesDataviewFrom,
+  parseDataview,
+  readDataviewField,
+  remarkDataview,
+  renderDataview,
+  renderDataviewError,
+  resolveDataviewOptions,
+  selectDataviewEntries,
+  toDataviewTime
+};