@cosense-toolbox/lsp 0.1.0-beta.2

package/dist/tokens-D0NP_uLo.mjs

@@ -0,0 +1,312 @@
+import { Array, Match, Option, Order, pipe } from "effect";
+import { normalizeLineEndings, parse } from "@cosense-toolbox/parser";
+import { customDecorations } from "@cosense-toolbox/parser/extensions";
+import { visit } from "@cosense-toolbox/parser/utils";
+//#region src/tree.ts
+const leaf = (items) => ({
+	items,
+	descend: false
+});
+const branch = (items) => ({
+	items,
+	descend: true
+});
+/**
+* Everything `pick` takes from `tree`, in document order.
+*
+* The parser's `visit` hands nodes to a callback, so something has to hold what the callback
+* finds. That is kept to here: `pick` stays a pure function of one node.
+*/
+const gather = (tree, pick) => {
+	const found = [];
+	visit(tree, (node) => {
+		const { items, descend } = pick(node);
+		found.push(...items);
+		return descend ? void 0 : "skip";
+	});
+	return found;
+};
+//#endregion
+//#region src/tokens.ts
+/**
+* Cosense notation as LSP semantic tokens.
+*
+* These names are the ones this package reasons in, and they are not what goes on the wire.
+* A client announces the token types it knows at initialize and drops everything else —
+* some send the LSP's own list and nothing more — so `quote` would simply never be drawn.
+* LEGEND below is what is sent, and LSP_TYPE is the translation.
+*/
+const TOKEN_TYPES = [
+	"title",
+	"link",
+	"projectLink",
+	"externalLink",
+	"hashtag",
+	"code",
+	"codeBlock",
+	"formula",
+	"icon",
+	"quote",
+	"bold",
+	"italic",
+	"strike",
+	"underline",
+	"image",
+	"table",
+	"bold2",
+	"bold3",
+	"component",
+	"attribute",
+	"attributeValue",
+	"expression",
+	"frontmatter",
+	"notation"
+];
+/**
+* The legend sent to the client: the LSP's own token types, in its own order.
+*
+* Every entry is in the set a client is expected to understand, which is what makes the
+* colours appear without the reader configuring anything.
+*/
+const LEGEND = [
+	"namespace",
+	"type",
+	"function",
+	"variable",
+	"property",
+	"parameter",
+	"decorator",
+	"macro",
+	"keyword",
+	"string",
+	"number",
+	"comment"
+];
+/**
+* What each notation is drawn as. Chosen so that things a reader separates by eye land on
+* different entries: a link is not a tag, and a quote is not a heading. `bold` and its
+* louder siblings share one entry, because the LSP has no notion of weight and a theme
+* gives each type a single colour.
+*/
+const LSP_TYPE = {
+	title: "namespace",
+	link: "function",
+	projectLink: "function",
+	externalLink: "string",
+	icon: "function",
+	image: "string",
+	hashtag: "decorator",
+	code: "string",
+	codeBlock: "string",
+	formula: "number",
+	table: "property",
+	quote: "comment",
+	frontmatter: "comment",
+	component: "type",
+	attribute: "parameter",
+	attributeValue: "string",
+	expression: "variable",
+	bold: "keyword",
+	bold2: "keyword",
+	bold3: "keyword",
+	italic: "macro",
+	strike: "comment",
+	underline: "variable",
+	notation: "decorator"
+};
+/**
+* LEGEND with the names of `notations` after it, each once: the legend for a client that
+* accepts token types of the caller's own naming. The LSP's types keep their places.
+*/
+const legendOf = (notations) => Array.dedupe([...LEGEND, ...Array.map(notations, (notation) => notation.name)]);
+/** `parseOptions` that also read the markers of `notations` as decorations. */
+const withNotations = (parseOptions, notations) => Array.match(notations, {
+	onEmpty: () => parseOptions,
+	onNonEmpty: (added) => ({
+		...parseOptions,
+		extensions: [...parseOptions.extensions ?? [], customDecorations(Array.map(added, (notation) => notation.marker))]
+	})
+});
+/** Leaf inline nodes that map 1:1. Each sits on one line, so no splitting is needed. */
+const INLINE_TOKEN_TYPE = {
+	internalLink: "link",
+	externalLink: "externalLink",
+	projectLink: "projectLink",
+	hashtag: "hashtag",
+	inlineCode: "code",
+	image: "image",
+	icon: "icon",
+	formula: "formula"
+};
+/** Top to bottom, then left to right: the order the LSP encoding needs. */
+const BY_POSITION = Order.combine(Order.mapInput(Order.number, (token) => token.line), Order.mapInput(Order.number, (token) => token.char));
+const onlyIf = (condition, value) => condition ? Option.some(value) : Option.none();
+/** A token over `[from, to)` of one line. */
+const token = (type, line, from, to) => ({
+	line,
+	char: from,
+	length: to - from,
+	type
+});
+const spanToken = (type, position) => token(type, position.start.line, position.start.column, position.end.column);
+/** How many characters from `from` the `^`-anchored `pattern` takes; 0 when it takes none. */
+const matchLength = (pattern, text, from) => pipe(Option.fromNullable(pattern.exec(text.slice(from))), Option.match({
+	onNone: () => 0,
+	onSome: ([matched]) => matched.length
+}));
+/** Cosense sizes emphasis by asterisk count (`[*]`..`[*****]`); sizeLevel is 0-indexed. */
+const boldTokenType = (sizeLevel) => Match.value(sizeLevel).pipe(Match.when((level) => level >= 2, () => "bold3"), Match.when(1, () => "bold2"), Match.orElse(() => "bold"));
+/** Every decoration a run carries, since Cosense applies all of them: `[-* x]` is both. */
+const decorationTokenTypes = (node) => Array.getSomes([
+	onlyIf(node.underline, "underline"),
+	onlyIf(node.strike, "strike"),
+	onlyIf(node.italic, "italic"),
+	onlyIf(node.bold, boldTokenType(node.sizeLevel))
+]);
+const COMPONENT_LINE = /^\s*<\/?[A-Z][A-Za-z0-9_.]*(\s|\/?>)/;
+const TAG_OPEN = /^(\s*<\/?)([A-Z][A-Za-z0-9_.]*)/;
+const ATTRIBUTE_NAME = /^[A-Za-z_:][A-Za-z0-9_:.-]*/;
+const SPACE = /^\s*/;
+/** Where a quoted value opened at `from` ends: after its closing quote, or at the line's end. */
+const quotedEnd = (text, from) => pipe(text.indexOf(text.charAt(from), from + 1), Option.liftPredicate((close) => close >= 0), Option.match({
+	onNone: () => text.length,
+	onSome: (close) => close + 1
+}));
+/** Where `{ ... }` opened at `from` ends, counting nested braces: after its `}`, or the line's end. */
+const bracedEnd = (text, from) => pipe(text.slice(from).split(""), Array.scan(0, (depth, char) => char === "{" ? depth + 1 : char === "}" ? depth - 1 : depth), Array.drop(1), Array.findFirstIndex((depth) => depth === 0), Option.match({
+	onNone: () => text.length,
+	onSome: (index) => from + index + 1
+}));
+/** The attribute value that starts at `from`: its type and where it ends. */
+const valueAt = (text, from) => Match.value(text.charAt(from)).pipe(Match.when((char) => char === "\"" || char === "'", () => Option.some(["attributeValue", quotedEnd(text, from)])), Match.when("{", () => Option.some(["expression", bracedEnd(text, from)])), Match.orElse(() => Option.none()));
+/** `at` past any whitespace. */
+const skipSpace = (text, at) => at + matchLength(SPACE, text, at);
+/** Whether the tag closes at `at`, with `>` or `/>`, or the line ends there. */
+const closesAt = (text, at) => at >= text.length || text.startsWith(">", at) || text.startsWith("/>", at);
+/**
+* An attribute named over `[at, nameEnd)`: the name, then `=` and a value if one follows.
+* A name with no `=` after it stands alone, as JSX reads `<Dialog open>`.
+*/
+const attribute = (line, text, at, nameEnd) => {
+	const name = token("attribute", line, at, nameEnd);
+	const afterName = skipSpace(text, nameEnd);
+	return pipe(Option.liftPredicate(afterName, (equals) => text.charAt(equals) === "="), Option.map((equals) => skipSpace(text, equals + 1)), Option.match({
+		onNone: () => [[name], afterName],
+		onSome: (valueStart) => pipe(valueAt(text, valueStart), Option.match({
+			onNone: () => [[name], valueStart],
+			onSome: ([type, end]) => [[name, token(type, line, valueStart, end)], end]
+		}))
+	}));
+};
+/** One attribute from `from`, or None once the tag has closed. */
+const attributeStep = (line, text) => (from) => pipe(Option.liftPredicate(skipSpace(text, from), (at) => !closesAt(text, at)), Option.map((at) => pipe(Option.liftPredicate(at + matchLength(ATTRIBUTE_NAME, text, at), (end) => end > at), Option.match({
+	onNone: () => [[], at + 1],
+	onSome: (nameEnd) => attribute(line, text, at, nameEnd)
+}))));
+/**
+* The tag that opens a component line, read as JSX: its name, then each attribute and its
+* value, up to the `>` that closes it. Text after the tag is left alone; it is neither
+* Cosense notation nor part of the tag.
+*/
+const componentTokens = (line, text) => pipe(Option.fromNullable(TAG_OPEN.exec(text)), Option.map(([head, lead = "", name = ""]) => [token("component", line, lead.length, lead.length + name.length), ...Array.flatten(Array.unfold(head.length, attributeStep(line, text)))]), Option.getOrElse(() => []));
+/** The last line of the `---` fence around YAML at the very top, if the file opens with one. */
+const frontmatterEnd = (lines) => pipe(Option.liftPredicate(lines, (all) => all[0]?.trim() === "---"), Option.flatMap(Array.findFirstIndex((line, index) => index > 0 && line.trim() === "---")));
+/**
+* `frontmatterEnd`, or None when the caller reads no frontmatter: a Cosense page has none,
+* and a page whose title is `---` would otherwise lose its first lines to it.
+*/
+const fenceOf = (lines, frontmatter) => Option.flatMap(onlyIf(frontmatter, lines), frontmatterEnd);
+/** Each non-empty line from `first` to `last`, whole. */
+const lineSpans = (type, lines, first, last) => Array.filterMap(Array.range(first, last), (line) => pipe(Option.fromNullable(lines[line]), Option.filter((text) => text.length > 0), Option.map((text) => token(type, line, 0, text.length))));
+/** The line's text, when the file reads components and the line opens with a tag. */
+const componentLine = (page, line) => pipe(Option.fromNullable(page.lines[line]), Option.filter((text) => page.components && COMPONENT_LINE.test(text)));
+/** The `>` and spaces that open a quote line, from its indentation onwards. */
+const quoteToken = (page, node, line) => pipe(onlyIf(node.quote, page.lines[line] ?? ""), Option.map((text) => matchLength(/^[> ]*/, text, node.indent)), Option.filter((length) => length > 0), Option.map((length) => token("quote", line, node.indent, node.indent + length)));
+/** A token for each of `notations` whose marker opens the decoration. */
+const notationTokens = (notations, node, position) => Array.filterMap(notations, ({ marker, name }) => onlyIf(node.markers.includes(marker), {
+	line: position.start.line,
+	char: position.start.column,
+	length: position.end.column - position.start.column,
+	type: "notation",
+	name
+}));
+const nodeTokens = (page) => (node) => {
+	const lineOf = (position) => position.start.line + page.offset;
+	const shift = (position) => ({
+		start: {
+			...position.start,
+			line: position.start.line + page.offset
+		},
+		end: {
+			...position.end,
+			line: position.end.line + page.offset
+		}
+	});
+	return Match.value(node).pipe(Match.discriminators("type")({
+		title: (title) => leaf(pipe(componentLine(page, lineOf(title.position)), Option.match({
+			onNone: () => [spanToken("title", shift(title.position))],
+			onSome: (text) => componentTokens(lineOf(title.position), text)
+		}))),
+		codeBlock: (block) => leaf(lineSpans("codeBlock", page.lines, lineOf(block.position), block.position.end.line + page.offset)),
+		table: (table) => leaf(lineSpans("table", page.lines, lineOf(table.position), table.position.end.line + page.offset)),
+		line: (line) => pipe(componentLine(page, lineOf(line.position)), Option.match({
+			onSome: (text) => leaf(componentTokens(lineOf(line.position), text)),
+			onNone: () => branch(Option.toArray(quoteToken(page, line, lineOf(line.position))))
+		})),
+		decoration: (decoration) => branch([...decorationTokenTypes(decoration).map((type) => spanToken(type, shift(decoration.position))), ...notationTokens(page.notations, decoration, shift(decoration.position))])
+	}), Match.orElse((other) => branch(pipe(Option.fromNullable(INLINE_TOKEN_TYPE[other.type]), Option.map((type) => spanToken(type, shift(other.position))), Option.toArray))));
+};
+/** Pure text -> tokens. The LSP delta encoding lives in encodeTokens, so this stays testable. */
+const computeTokens = (text, options = {}) => {
+	const lines = normalizeLineEndings(text).split("\n");
+	const notations = options.notations ?? [];
+	const fence = fenceOf(lines, options.frontmatter ?? true);
+	const page = {
+		lines,
+		offset: Option.match(fence, {
+			onNone: () => 0,
+			onSome: (end) => end + 1
+		}),
+		components: options.components ?? false,
+		notations
+	};
+	const frontmatterTokens = Option.match(fence, {
+		onNone: () => [],
+		onSome: (end) => lineSpans("frontmatter", lines, 0, end)
+	});
+	const body = parse(lines.slice(page.offset).join("\n"), withNotations(options.parseOptions ?? {}, notations));
+	return pipe([...frontmatterTokens, ...gather(body, nodeTokens(page))], Array.filter((t) => t.length > 0), Array.sort(BY_POSITION));
+};
+/**
+* Each token's place in `legend`: a notation's own name when the legend has it, else the
+* LSP type its kind is drawn as.
+*/
+const legendIndex = (legend) => {
+	const placeOf = (type) => Option.liftPredicate(legend.indexOf(type), (index) => index >= 0);
+	const drawnAs = (token) => Option.getOrElse(placeOf(LSP_TYPE[token.type]), () => 0);
+	return (token) => Match.value(token).pipe(Match.when({ type: "notation" }, (notation) => Option.getOrElse(placeOf(notation.name), () => drawnAs(notation))), Match.orElse(drawnAs));
+};
+/**
+* LSP relative encoding: [deltaLine, deltaStartChar, length, tokenType, tokenModifiers]*.
+* `legend` is the one sent at initialize: LEGEND, or `legendOf(notations)`.
+*/
+const encodeTokens = (tokens, legend = LEGEND) => {
+	const indexOf = legendIndex(legend);
+	return pipe(Array.sort(tokens, BY_POSITION), Array.mapAccum({
+		line: 0,
+		char: 0
+	}, (previous, t) => [{
+		line: t.line,
+		char: t.char
+	}, [
+		t.line - previous.line,
+		t.line === previous.line ? t.char - previous.char : t.char,
+		t.length,
+		indexOf(t),
+		0
+	]]), ([, rows]) => Array.flatten(rows));
+};
+//#endregion
+export { encodeTokens as a, legendOf as c, gather as d, leaf as f, computeTokens as i, withNotations as l, LEGEND as n, fenceOf as o, TOKEN_TYPES as r, frontmatterEnd as s, COMPONENT_LINE as t, branch as u };
+
+//# sourceMappingURL=tokens-D0NP_uLo.mjs.map

package/dist/tokens-D0NP_uLo.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens-D0NP_uLo.mjs","names":["Arr"],"sources":["../src/tree.ts","../src/tokens.ts"],"sourcesContent":["import type { AnyNode } from \"@cosense-toolbox/parser\"\nimport { visit } from \"@cosense-toolbox/parser/utils\"\n\n/** What one node gives, and whether its children are read too. */\nexport interface Picked<A> {\n  readonly items: ReadonlyArray<A>\n  readonly descend: boolean\n}\n\nexport const leaf = <A>(items: ReadonlyArray<A>): Picked<A> => ({ items, descend: false })\n\nexport const branch = <A>(items: ReadonlyArray<A>): Picked<A> => ({ items, descend: true })\n\n/**\n * Everything `pick` takes from `tree`, in document order.\n *\n * The parser's `visit` hands nodes to a callback, so something has to hold what the callback\n * finds. That is kept to here: `pick` stays a pure function of one node.\n */\nexport const gather = <A>(tree: AnyNode, pick: (node: AnyNode) => Picked<A>): ReadonlyArray<A> => {\n  const found: A[] = []\n  visit(tree, (node) => {\n    const { items, descend } = pick(node)\n    found.push(...items)\n    return descend ? undefined : \"skip\"\n  })\n  return found\n}\n","import type {\n  AnyNode,\n  AnyNodeType,\n  Decoration,\n  NodeOfType,\n  ParseOptions,\n  Position,\n} from \"@cosense-toolbox/parser\"\nimport { normalizeLineEndings, parse } from \"@cosense-toolbox/parser\"\nimport { customDecorations } from \"@cosense-toolbox/parser/extensions\"\nimport { Array as Arr, Match, Option, Order, pipe } from \"effect\"\n\nimport { branch, gather, leaf, type Picked } from \"./tree\"\n\n/**\n * Cosense notation as LSP semantic tokens.\n *\n * These names are the ones this package reasons in, and they are not what goes on the wire.\n * A client announces the token types it knows at initialize and drops everything else —\n * some send the LSP's own list and nothing more — so `quote` would simply never be drawn.\n * LEGEND below is what is sent, and LSP_TYPE is the translation.\n */\nexport const TOKEN_TYPES = [\n  \"title\",\n  \"link\",\n  \"projectLink\",\n  \"externalLink\",\n  \"hashtag\",\n  \"code\",\n  \"codeBlock\",\n  \"formula\",\n  \"icon\",\n  \"quote\",\n  \"bold\",\n  \"italic\",\n  \"strike\",\n  \"underline\",\n  \"image\",\n  \"table\",\n  \"bold2\",\n  \"bold3\",\n  // `.csnx` only: a line that opens with a component tag. The tag's name, its attribute\n  // names, and the two kinds of value, as JSX reads them.\n  \"component\",\n  \"attribute\",\n  \"attributeValue\",\n  \"expression\",\n  // The YAML at the top of the file, which is not Cosense notation at all.\n  \"frontmatter\",\n  // A notation the caller defines (see `Notation`), such as `[! 注意]`. The token carries\n  // the name the caller gave it.\n  \"notation\",\n] as const\n\nexport type TokenType = (typeof TOKEN_TYPES)[number]\n\n/** Every token type but `notation`, whose tokens also carry a name. */\ntype BuiltinTokenType = Exclude<TokenType, \"notation\">\n\ninterface Span {\n  readonly line: number\n  readonly char: number\n  readonly length: number\n}\n\nexport type RawToken =\n  | (Span & { readonly type: BuiltinTokenType })\n  | (Span & { readonly type: \"notation\"; readonly name: string })\n\n/**\n * A notation the caller adds to Cosense's: a marker that opens a decoration, as `!` opens\n * `[! 注意]`, and the token type it is sent as. The marker is also taught to the parser, so\n * the bracket is not read as a link.\n */\nexport interface Notation {\n  readonly marker: string\n  readonly name: string\n}\n\n/**\n * The legend sent to the client: the LSP's own token types, in its own order.\n *\n * Every entry is in the set a client is expected to understand, which is what makes the\n * colours appear without the reader configuring anything.\n */\nexport const LEGEND = [\n  \"namespace\",\n  \"type\",\n  \"function\",\n  \"variable\",\n  \"property\",\n  \"parameter\",\n  \"decorator\",\n  \"macro\",\n  \"keyword\",\n  \"string\",\n  \"number\",\n  \"comment\",\n] as const\n\n/**\n * What each notation is drawn as. Chosen so that things a reader separates by eye land on\n * different entries: a link is not a tag, and a quote is not a heading. `bold` and its\n * louder siblings share one entry, because the LSP has no notion of weight and a theme\n * gives each type a single colour.\n */\nconst LSP_TYPE: Record<TokenType, (typeof LEGEND)[number]> = {\n  title: \"namespace\",\n  link: \"function\",\n  projectLink: \"function\",\n  externalLink: \"string\",\n  icon: \"function\",\n  image: \"string\",\n  hashtag: \"decorator\",\n  code: \"string\",\n  codeBlock: \"string\",\n  formula: \"number\",\n  table: \"property\",\n  quote: \"comment\",\n  frontmatter: \"comment\",\n  component: \"type\",\n  attribute: \"parameter\",\n  attributeValue: \"string\",\n  expression: \"variable\",\n  bold: \"keyword\",\n  bold2: \"keyword\",\n  bold3: \"keyword\",\n  italic: \"macro\",\n  strike: \"comment\",\n  underline: \"variable\",\n  // What a caller's notation is sent as when the legend has no type of its name.\n  notation: \"decorator\",\n}\n\n/**\n * LEGEND with the names of `notations` after it, each once: the legend for a client that\n * accepts token types of the caller's own naming. The LSP's types keep their places.\n */\nexport const legendOf = (notations: ReadonlyArray<Notation>): ReadonlyArray<string> =>\n  Arr.dedupe([...LEGEND, ...Arr.map(notations, (notation) => notation.name)])\n\n/** `parseOptions` that also read the markers of `notations` as decorations. */\nexport const withNotations = (\n  parseOptions: ParseOptions,\n  notations: ReadonlyArray<Notation>,\n): ParseOptions =>\n  Arr.match(notations, {\n    onEmpty: () => parseOptions,\n    onNonEmpty: (added): ParseOptions => ({\n      ...parseOptions,\n      extensions: [\n        ...(parseOptions.extensions ?? []),\n        customDecorations(Arr.map(added, (notation) => notation.marker)),\n      ],\n    }),\n  })\n\n/** Leaf inline nodes that map 1:1. Each sits on one line, so no splitting is needed. */\nconst INLINE_TOKEN_TYPE: Partial<Record<AnyNodeType, BuiltinTokenType>> = {\n  internalLink: \"link\",\n  externalLink: \"externalLink\",\n  projectLink: \"projectLink\",\n  hashtag: \"hashtag\",\n  inlineCode: \"code\",\n  image: \"image\",\n  icon: \"icon\",\n  formula: \"formula\",\n}\n\n/** Top to bottom, then left to right: the order the LSP encoding needs. */\nconst BY_POSITION: Order.Order<RawToken> = Order.combine(\n  Order.mapInput(Order.number, (token: RawToken) => token.line),\n  Order.mapInput(Order.number, (token: RawToken) => token.char),\n)\n\nconst onlyIf = <A>(condition: boolean, value: A): Option.Option<A> =>\n  condition ? Option.some(value) : Option.none()\n\n/** A token over `[from, to)` of one line. */\nconst token = (type: BuiltinTokenType, line: number, from: number, to: number): RawToken => ({\n  line,\n  char: from,\n  length: to - from,\n  type,\n})\n\nconst spanToken = (type: BuiltinTokenType, position: Position): RawToken =>\n  token(type, position.start.line, position.start.column, position.end.column)\n\n/** How many characters from `from` the `^`-anchored `pattern` takes; 0 when it takes none. */\nconst matchLength = (pattern: RegExp, text: string, from: number): number =>\n  pipe(\n    Option.fromNullable(pattern.exec(text.slice(from))),\n    Option.match({ onNone: () => 0, onSome: ([matched]) => matched.length }),\n  )\n\n// --- Emphasis ---------------------------------------------------------------------------\n\n/** Cosense sizes emphasis by asterisk count (`[*]`..`[*****]`); sizeLevel is 0-indexed. */\nconst boldTokenType = (sizeLevel: number): BuiltinTokenType =>\n  Match.value(sizeLevel).pipe(\n    Match.when(\n      (level) => level >= 2,\n      (): BuiltinTokenType => \"bold3\",\n    ),\n    Match.when(1, (): BuiltinTokenType => \"bold2\"),\n    Match.orElse((): BuiltinTokenType => \"bold\"),\n  )\n\n/** Every decoration a run carries, since Cosense applies all of them: `[-* x]` is both. */\nconst decorationTokenTypes = (node: Decoration): ReadonlyArray<BuiltinTokenType> =>\n  Arr.getSomes([\n    onlyIf(node.underline, \"underline\" as const),\n    onlyIf(node.strike, \"strike\" as const),\n    onlyIf(node.italic, \"italic\" as const),\n    onlyIf(node.bold, boldTokenType(node.sizeLevel)),\n  ])\n\n// --- Component lines (`.csnx`) ----------------------------------------------------------\n\nexport const COMPONENT_LINE = /^\\s*<\\/?[A-Z][A-Za-z0-9_.]*(\\s|\\/?>)/\nconst TAG_OPEN = /^(\\s*<\\/?)([A-Z][A-Za-z0-9_.]*)/\nconst ATTRIBUTE_NAME = /^[A-Za-z_:][A-Za-z0-9_:.-]*/\nconst SPACE = /^\\s*/\n\n/** Where a quoted value opened at `from` ends: after its closing quote, or at the line's end. */\nconst quotedEnd = (text: string, from: number): number =>\n  pipe(\n    text.indexOf(text.charAt(from), from + 1),\n    Option.liftPredicate((close) => close >= 0),\n    Option.match({ onNone: () => text.length, onSome: (close) => close + 1 }),\n  )\n\n/** Where `{ ... }` opened at `from` ends, counting nested braces: after its `}`, or the line's end. */\nconst bracedEnd = (text: string, from: number): number =>\n  pipe(\n    text.slice(from).split(\"\"),\n    Arr.scan(0, (depth, char) => (char === \"{\" ? depth + 1 : char === \"}\" ? depth - 1 : depth)),\n    // scan starts with the depth before any character; the rest line up with the characters.\n    Arr.drop(1),\n    Arr.findFirstIndex((depth) => depth === 0),\n    Option.match({ onNone: () => text.length, onSome: (index) => from + index + 1 }),\n  )\n\ntype ValueType = \"attributeValue\" | \"expression\"\n\n/** The attribute value that starts at `from`: its type and where it ends. */\nconst valueAt = (text: string, from: number): Option.Option<readonly [ValueType, number]> =>\n  Match.value(text.charAt(from)).pipe(\n    Match.when(\n      (char) => char === '\"' || char === \"'\",\n      () => Option.some([\"attributeValue\", quotedEnd(text, from)] as const),\n    ),\n    Match.when(\"{\", () => Option.some([\"expression\", bracedEnd(text, from)] as const)),\n    Match.orElse(() => Option.none()),\n  )\n\n/** The tokens of one attribute, and where the next may start. */\ntype Step = readonly [ReadonlyArray<RawToken>, number]\n\n/** `at` past any whitespace. */\nconst skipSpace = (text: string, at: number): number => at + matchLength(SPACE, text, at)\n\n/** Whether the tag closes at `at`, with `>` or `/>`, or the line ends there. */\nconst closesAt = (text: string, at: number): boolean =>\n  at >= text.length || text.startsWith(\">\", at) || text.startsWith(\"/>\", at)\n\n/**\n * An attribute named over `[at, nameEnd)`: the name, then `=` and a value if one follows.\n * A name with no `=` after it stands alone, as JSX reads `<Dialog open>`.\n */\nconst attribute = (line: number, text: string, at: number, nameEnd: number): Step => {\n  const name = token(\"attribute\", line, at, nameEnd)\n  const afterName = skipSpace(text, nameEnd)\n  return pipe(\n    Option.liftPredicate(afterName, (equals) => text.charAt(equals) === \"=\"),\n    Option.map((equals) => skipSpace(text, equals + 1)),\n    Option.match({\n      onNone: (): Step => [[name], afterName],\n      onSome: (valueStart): Step =>\n        pipe(\n          valueAt(text, valueStart),\n          Option.match({\n            onNone: (): Step => [[name], valueStart],\n            onSome: ([type, end]): Step => [[name, token(type, line, valueStart, end)], end],\n          }),\n        ),\n    }),\n  )\n}\n\n/** One attribute from `from`, or None once the tag has closed. */\nconst attributeStep =\n  (line: number, text: string) =>\n  (from: number): Option.Option<Step> =>\n    pipe(\n      Option.liftPredicate(skipSpace(text, from), (at) => !closesAt(text, at)),\n      Option.map((at) =>\n        pipe(\n          Option.liftPredicate(at + matchLength(ATTRIBUTE_NAME, text, at), (end) => end > at),\n          Option.match({\n            // Not a name: step over the character, since the tag may still go on after it.\n            onNone: (): Step => [[], at + 1],\n            onSome: (nameEnd) => attribute(line, text, at, nameEnd),\n          }),\n        ),\n      ),\n    )\n\n/**\n * The tag that opens a component line, read as JSX: its name, then each attribute and its\n * value, up to the `>` that closes it. Text after the tag is left alone; it is neither\n * Cosense notation nor part of the tag.\n */\nconst componentTokens = (line: number, text: string): ReadonlyArray<RawToken> =>\n  pipe(\n    Option.fromNullable(TAG_OPEN.exec(text)),\n    Option.map(([head, lead = \"\", name = \"\"]) => [\n      token(\"component\", line, lead.length, lead.length + name.length),\n      ...Arr.flatten(Arr.unfold(head.length, attributeStep(line, text))),\n    ]),\n    Option.getOrElse(() => []),\n  )\n\n// --- The page ---------------------------------------------------------------------------\n\n/** The last line of the `---` fence around YAML at the very top, if the file opens with one. */\nexport const frontmatterEnd = (lines: ReadonlyArray<string>): Option.Option<number> =>\n  pipe(\n    Option.liftPredicate(lines, (all) => all[0]?.trim() === \"---\"),\n    Option.flatMap(Arr.findFirstIndex((line, index) => index > 0 && line.trim() === \"---\")),\n  )\n\n/**\n * `frontmatterEnd`, or None when the caller reads no frontmatter: a Cosense page has none,\n * and a page whose title is `---` would otherwise lose its first lines to it.\n */\nexport const fenceOf = (\n  lines: ReadonlyArray<string>,\n  frontmatter: boolean,\n): Option.Option<number> => Option.flatMap(onlyIf(frontmatter, lines), frontmatterEnd)\n\n/** What the node visitor needs to know about the file around the parsed body. */\ninterface Page {\n  readonly lines: ReadonlyArray<string>\n  /** Lines before the body: the frontmatter, which the parser never sees. */\n  readonly offset: number\n  readonly components: boolean\n  readonly notations: ReadonlyArray<Notation>\n}\n\n/** Each non-empty line from `first` to `last`, whole. */\nconst lineSpans = (\n  type: BuiltinTokenType,\n  lines: ReadonlyArray<string>,\n  first: number,\n  last: number,\n): ReadonlyArray<RawToken> =>\n  Arr.filterMap(Arr.range(first, last), (line) =>\n    pipe(\n      Option.fromNullable(lines[line]),\n      Option.filter((text) => text.length > 0),\n      Option.map((text) => token(type, line, 0, text.length)),\n    ),\n  )\n\n/** The line's text, when the file reads components and the line opens with a tag. */\nconst componentLine = (page: Page, line: number): Option.Option<string> =>\n  pipe(\n    Option.fromNullable(page.lines[line]),\n    Option.filter((text) => page.components && COMPONENT_LINE.test(text)),\n  )\n\n/** The `>` and spaces that open a quote line, from its indentation onwards. */\nconst quoteToken = (page: Page, node: NodeOfType<\"line\">, line: number): Option.Option<RawToken> =>\n  pipe(\n    onlyIf(node.quote, page.lines[line] ?? \"\"),\n    Option.map((text) => matchLength(/^[> ]*/, text, node.indent)),\n    Option.filter((length) => length > 0),\n    Option.map((length) => token(\"quote\", line, node.indent, node.indent + length)),\n  )\n\n/** A token for each of `notations` whose marker opens the decoration. */\nconst notationTokens = (\n  notations: ReadonlyArray<Notation>,\n  node: Decoration,\n  position: Position,\n): ReadonlyArray<RawToken> =>\n  Arr.filterMap(notations, ({ marker, name }) =>\n    onlyIf(node.markers.includes(marker), {\n      line: position.start.line,\n      char: position.start.column,\n      length: position.end.column - position.start.column,\n      type: \"notation\" as const,\n      name,\n    }),\n  )\n\nconst nodeTokens =\n  (page: Page) =>\n  (node: AnyNode): Picked<RawToken> => {\n    const lineOf = (position: Position) => position.start.line + page.offset\n    const shift = (position: Position): Position => ({\n      start: { ...position.start, line: position.start.line + page.offset },\n      end: { ...position.end, line: position.end.line + page.offset },\n    })\n    return Match.value(node).pipe(\n      Match.discriminators(\"type\")({\n        // A page that opens with a component has no title line: the tag is what it is.\n        title: (title) =>\n          leaf(\n            pipe(\n              componentLine(page, lineOf(title.position)),\n              Option.match({\n                onNone: () => [spanToken(\"title\", shift(title.position))],\n                onSome: (text) => componentTokens(lineOf(title.position), text),\n              }),\n            ),\n          ),\n        codeBlock: (block) =>\n          leaf(\n            lineSpans(\n              \"codeBlock\",\n              page.lines,\n              lineOf(block.position),\n              block.position.end.line + page.offset,\n            ),\n          ),\n        table: (table) =>\n          leaf(\n            lineSpans(\n              \"table\",\n              page.lines,\n              lineOf(table.position),\n              table.position.end.line + page.offset,\n            ),\n          ),\n        // A component tag owns its line, so nothing on it is Cosense notation.\n        line: (line) =>\n          pipe(\n            componentLine(page, lineOf(line.position)),\n            Option.match({\n              onSome: (text) => leaf(componentTokens(lineOf(line.position), text)),\n              onNone: () => branch(Option.toArray(quoteToken(page, line, lineOf(line.position)))),\n            }),\n          ),\n        // Descend: a decoration can wrap a link or an image (`[* [page]]`), and that child\n        // needs its own token over the same span.\n        decoration: (decoration) =>\n          branch([\n            ...decorationTokenTypes(decoration).map((type) =>\n              spanToken(type, shift(decoration.position)),\n            ),\n            ...notationTokens(page.notations, decoration, shift(decoration.position)),\n          ]),\n      }),\n      Match.orElse((other) =>\n        branch(\n          pipe(\n            Option.fromNullable(INLINE_TOKEN_TYPE[other.type]),\n            Option.map((type) => spanToken(type, shift(other.position))),\n            Option.toArray,\n          ),\n        ),\n      ),\n    )\n  }\n\nexport interface ComputeTokensOptions {\n  /** `.csnx` also reads a line that is one component tag. `.csn` never does. */\n  readonly components?: boolean\n  /** How to parse: the site's notation extensions, so `[! 注意]` is not read as a link. */\n  readonly parseOptions?: ParseOptions\n  /** Notations the caller adds, each sent as a token of its own name (see `Notation`). */\n  readonly notations?: ReadonlyArray<Notation>\n  /**\n   * Whether a `---` fence on the first line opens YAML to skip (default: true). Off for\n   * Cosense pages, which have no frontmatter.\n   */\n  readonly frontmatter?: boolean\n}\n\n/** Pure text -> tokens. The LSP delta encoding lives in encodeTokens, so this stays testable. */\nexport const computeTokens = (text: string, options: ComputeTokensOptions = {}): RawToken[] => {\n  const lines = normalizeLineEndings(text).split(\"\\n\")\n  const notations = options.notations ?? []\n  // Frontmatter is YAML, so the Cosense parser must not see it: `---` would otherwise read\n  // as a strikethrough marker and the keys as plain text on the title line.\n  const fence = fenceOf(lines, options.frontmatter ?? true)\n  const page: Page = {\n    lines,\n    offset: Option.match(fence, { onNone: () => 0, onSome: (end) => end + 1 }),\n    components: options.components ?? false,\n    notations,\n  }\n\n  const frontmatterTokens = Option.match(fence, {\n    onNone: () => [],\n    onSome: (end) => lineSpans(\"frontmatter\", lines, 0, end),\n  })\n  const body = parse(\n    lines.slice(page.offset).join(\"\\n\"),\n    withNotations(options.parseOptions ?? {}, notations),\n  )\n\n  return pipe(\n    [...frontmatterTokens, ...gather(body, nodeTokens(page))],\n    Arr.filter((t) => t.length > 0),\n    Arr.sort(BY_POSITION),\n  )\n}\n\n/**\n * Each token's place in `legend`: a notation's own name when the legend has it, else the\n * LSP type its kind is drawn as.\n */\nconst legendIndex = (legend: ReadonlyArray<string>) => {\n  const placeOf = (type: string): Option.Option<number> =>\n    Option.liftPredicate(legend.indexOf(type), (index) => index >= 0)\n  const drawnAs = (token: RawToken) => Option.getOrElse(placeOf(LSP_TYPE[token.type]), () => 0)\n  return (token: RawToken): number =>\n    Match.value(token).pipe(\n      Match.when({ type: \"notation\" }, (notation) =>\n        Option.getOrElse(placeOf(notation.name), () => drawnAs(notation)),\n      ),\n      Match.orElse(drawnAs),\n    )\n}\n\n/**\n * LSP relative encoding: [deltaLine, deltaStartChar, length, tokenType, tokenModifiers]*.\n * `legend` is the one sent at initialize: LEGEND, or `legendOf(notations)`.\n */\nexport const encodeTokens = (\n  tokens: ReadonlyArray<RawToken>,\n  legend: ReadonlyArray<string> = LEGEND,\n): number[] => {\n  const indexOf = legendIndex(legend)\n  return pipe(\n    Arr.sort(tokens, BY_POSITION),\n    Arr.mapAccum({ line: 0, char: 0 }, (previous, t) => [\n      { line: t.line, char: t.char },\n      [\n        t.line - previous.line,\n        t.line === previous.line ? t.char - previous.char : t.char,\n        t.length,\n        indexOf(t),\n        0,\n      ],\n    ]),\n    ([, rows]) => Arr.flatten(rows),\n  )\n}\n"],"mappings":"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"}

package/dist/tokens.d.mts

@@ -0,0 +1,80 @@
+import { Option } from "effect";
+import { ParseOptions } from "@cosense-toolbox/parser";
+//#region src/tokens.d.ts
+/**
+ * Cosense notation as LSP semantic tokens.
+ *
+ * These names are the ones this package reasons in, and they are not what goes on the wire.
+ * A client announces the token types it knows at initialize and drops everything else —
+ * some send the LSP's own list and nothing more — so `quote` would simply never be drawn.
+ * LEGEND below is what is sent, and LSP_TYPE is the translation.
+ */
+declare const TOKEN_TYPES: readonly ["title", "link", "projectLink", "externalLink", "hashtag", "code", "codeBlock", "formula", "icon", "quote", "bold", "italic", "strike", "underline", "image", "table", "bold2", "bold3", "component", "attribute", "attributeValue", "expression", "frontmatter", "notation"];
+type TokenType = (typeof TOKEN_TYPES)[number];
+/** Every token type but `notation`, whose tokens also carry a name. */
+type BuiltinTokenType = Exclude<TokenType, "notation">;
+interface Span {
+  readonly line: number;
+  readonly char: number;
+  readonly length: number;
+}
+type RawToken = (Span & {
+  readonly type: BuiltinTokenType;
+}) | (Span & {
+  readonly type: "notation";
+  readonly name: string;
+});
+/**
+ * A notation the caller adds to Cosense's: a marker that opens a decoration, as `!` opens
+ * `[! 注意]`, and the token type it is sent as. The marker is also taught to the parser, so
+ * the bracket is not read as a link.
+ */
+interface Notation {
+  readonly marker: string;
+  readonly name: string;
+}
+/**
+ * The legend sent to the client: the LSP's own token types, in its own order.
+ *
+ * Every entry is in the set a client is expected to understand, which is what makes the
+ * colours appear without the reader configuring anything.
+ */
+declare const LEGEND: readonly ["namespace", "type", "function", "variable", "property", "parameter", "decorator", "macro", "keyword", "string", "number", "comment"];
+/**
+ * LEGEND with the names of `notations` after it, each once: the legend for a client that
+ * accepts token types of the caller's own naming. The LSP's types keep their places.
+ */
+declare const legendOf: (notations: ReadonlyArray<Notation>) => ReadonlyArray<string>;
+/** `parseOptions` that also read the markers of `notations` as decorations. */
+declare const withNotations: (parseOptions: ParseOptions, notations: ReadonlyArray<Notation>) => ParseOptions;
+declare const COMPONENT_LINE: RegExp;
+/** The last line of the `---` fence around YAML at the very top, if the file opens with one. */
+declare const frontmatterEnd: (lines: ReadonlyArray<string>) => Option.Option<number>;
+/**
+ * `frontmatterEnd`, or None when the caller reads no frontmatter: a Cosense page has none,
+ * and a page whose title is `---` would otherwise lose its first lines to it.
+ */
+declare const fenceOf: (lines: ReadonlyArray<string>, frontmatter: boolean) => Option.Option<number>;
+interface ComputeTokensOptions {
+  /** `.csnx` also reads a line that is one component tag. `.csn` never does. */
+  readonly components?: boolean;
+  /** How to parse: the site's notation extensions, so `[! 注意]` is not read as a link. */
+  readonly parseOptions?: ParseOptions;
+  /** Notations the caller adds, each sent as a token of its own name (see `Notation`). */
+  readonly notations?: ReadonlyArray<Notation>;
+  /**
+   * Whether a `---` fence on the first line opens YAML to skip (default: true). Off for
+   * Cosense pages, which have no frontmatter.
+   */
+  readonly frontmatter?: boolean;
+}
+/** Pure text -> tokens. The LSP delta encoding lives in encodeTokens, so this stays testable. */
+declare const computeTokens: (text: string, options?: ComputeTokensOptions) => RawToken[];
+/**
+ * LSP relative encoding: [deltaLine, deltaStartChar, length, tokenType, tokenModifiers]*.
+ * `legend` is the one sent at initialize: LEGEND, or `legendOf(notations)`.
+ */
+declare const encodeTokens: (tokens: ReadonlyArray<RawToken>, legend?: ReadonlyArray<string>) => number[];
+//#endregion
+export { COMPONENT_LINE, ComputeTokensOptions, LEGEND, Notation, RawToken, TOKEN_TYPES, TokenType, computeTokens, encodeTokens, fenceOf, frontmatterEnd, legendOf, withNotations };
+//# sourceMappingURL=tokens.d.mts.map

package/dist/tokens.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.mts","names":[],"sources":["../src/tokens.ts"],"mappings":";;;;;;;;;;;cAsBa;KAgCD,oBAAoB;;KAG3B,mBAAmB,QAAQ;UAEtB;WACC;WACA;WACA;;KAGC,YACP;WAAkB,MAAM;MACxB;WAAkB;WAA2B;;;;;;;UAOjC;WACN;WACA;;;;;;;;cASE;;;;;cAqDA,WAAY,WAAW,cAAc,cAAY;;cAIjD,gBACX,cAAc,cACd,WAAW,cAAc,cACxB;cA2EU,gBAAc;;cA2Gd,iBAAkB,OAAO,0BAAwB,OAAO;;;;;cAUxD,UACX,OAAO,uBACP,yBACC,OAAO;UAgIO;;WAEN;;WAEA,eAAe;;WAEf,YAAY,cAAc;;;;;WAK1B;;;cAIE,gBAAiB,cAAc,UAAS,yBAA4B;;;;;cAkDpE,eACX,QAAQ,cAAc,WACtB,SAAQ"}

package/dist/tokens.mjs

@@ -0,0 +1,2 @@
+import { a as encodeTokens, c as legendOf, i as computeTokens, l as withNotations, n as LEGEND, o as fenceOf, r as TOKEN_TYPES, s as frontmatterEnd, t as COMPONENT_LINE } from "./tokens-D0NP_uLo.mjs";
+export { COMPONENT_LINE, LEGEND, TOKEN_TYPES, computeTokens, encodeTokens, fenceOf, frontmatterEnd, legendOf, withNotations };

package/dist/workspace-DouAOZnK.mjs

@@ -0,0 +1,171 @@
+import { d as gather, f as leaf, o as fenceOf, t as COMPONENT_LINE, u as branch } from "./tokens-D0NP_uLo.mjs";
+import { normalizeForMatch } from "./completion.mjs";
+import { Array, Effect, Match, Option, Record, Schema, pipe } from "effect";
+import { normalizeLineEndings, parse } from "@cosense-toolbox/parser";
+import { customDecorations } from "@cosense-toolbox/parser/extensions";
+import { DiagnosticSeverity } from "vscode-languageserver/node";
+import { basename, extname, join, relative, resolve, sep } from "node:path";
+import { readFile, readdir } from "node:fs/promises";
+import { fileURLToPath, pathToFileURL } from "node:url";
+//#region src/diagnostics.ts
+/**
+* Links to pages no file holds.
+*
+* Only `[title]` links are checked. A tag names a tag page more often than a page, and a
+* `[/project/page]` link points outside the workspace; neither is expected to have a file.
+*/
+/** How loudly an unresolved link is reported, as the reader sets it. */
+const UnresolvedSeverity = Schema.Literal("off", "hint", "information", "warning", "error");
+/**
+* The severity a setting names, or `warning` for one that is missing or unknown: the build
+* warns about the same links by default (`unresolved: "warn"`).
+*/
+const severityOf = (setting) => Option.getOrElse(Schema.decodeUnknownOption(UnresolvedSeverity)(setting), () => "warning");
+/** The LSP's severity for a setting, or None for `off`. */
+const lspSeverity = (severity) => Match.value(severity).pipe(Match.when("off", () => Option.none()), Match.when("hint", () => Option.some(DiagnosticSeverity.Hint)), Match.when("information", () => Option.some(DiagnosticSeverity.Information)), Match.when("warning", () => Option.some(DiagnosticSeverity.Warning)), Match.when("error", () => Option.some(DiagnosticSeverity.Error)), Match.exhaustive);
+/**
+* Every `[title]` link in the body, with the line it is on in the file. The title line holds
+* no links, and neither does a `.csnx` component line.
+*/
+const linksIn = (text, { components = false, parseOptions = {}, frontmatter = true }) => {
+	const lines = normalizeLineEndings(text).split("\n");
+	const offset = Option.match(fenceOf(lines, frontmatter), {
+		onNone: () => 0,
+		onSome: (end) => end + 1
+	});
+	const isComponentLine = (line) => components && COMPONENT_LINE.test(lines[line + offset] ?? "");
+	return gather(parse(lines.slice(offset).join("\n"), parseOptions), (node) => Match.value(node).pipe(Match.when({ type: "title" }, () => leaf([])), Match.when({ type: "line" }, (line) => isComponentLine(line.position.start.line) ? leaf([]) : branch([])), Match.when({ type: "internalLink" }, (link) => branch([{
+		link,
+		line: link.position.start.line + offset
+	}])), Match.orElse(() => branch([]))));
+};
+/** A diagnostic for each `[title]` link in `text` whose page is not in `index`. */
+const unresolvedLinkDiagnostics = (index, text, options) => {
+	const withFile = new Set(Array.map(index.pages, (page) => normalizeForMatch(page.title)));
+	return pipe(lspSeverity(options.severity), Option.match({
+		onNone: () => [],
+		onSome: (severity) => pipe(linksIn(text, options), Array.filter(({ link }) => !withFile.has(normalizeForMatch(link.target))), Array.map(({ link, line }) => ({
+			range: {
+				start: {
+					line,
+					character: link.position.start.column
+				},
+				end: {
+					line,
+					character: link.position.end.column
+				}
+			},
+			severity,
+			source: "cosense",
+			code: "unresolved-link",
+			message: `リンク先のページが見つからない: [${link.target}]`
+		})))
+	}));
+};
+//#endregion
+//#region src/settings.ts
+const defaultSettings = {
+	sources: [],
+	decorations: [],
+	unresolvedLinks: "warning",
+	frontmatter: true
+};
+/** `schema`'s reading of `value`, or `fallback` when `value` is not of that shape. */
+const decodeOr = (schema, fallback) => (value) => Option.getOrElse(Schema.decodeUnknownOption(schema)(value), () => fallback);
+/** The options as an object, which the editor may send in any shape or not at all. */
+const OptionsObject = Schema.Record({
+	key: Schema.String,
+	value: Schema.Unknown
+});
+/**
+* The non-empty strings of a list. Anything else in it is dropped rather than failing the
+* whole list, and anything but a list counts as none.
+*/
+const stringsOf = (value) => Array.filter(decodeOr(Schema.Array(Schema.Unknown), [])(value), Schema.is(Schema.NonEmptyString));
+/**
+* Each setting read on its own, so one of the wrong shape falls back to its default
+* without taking the others with it.
+*/
+const settingsOf = (options) => {
+	const field = (key) => pipe(Schema.decodeUnknownOption(OptionsObject)(options), Option.flatMap(Record.get(key)), Option.getOrUndefined);
+	return {
+		sources: stringsOf(field("sources")),
+		decorations: stringsOf(field("decorations")),
+		unresolvedLinks: severityOf(field("unresolvedLinks")),
+		frontmatter: decodeOr(Schema.Boolean, defaultSettings.frontmatter)(field("frontmatter"))
+	};
+};
+/** How the pages are parsed, so the server reads notation as the site's build does. */
+const parseOptionsOf = ({ decorations }) => Array.match(decorations, {
+	onEmpty: () => ({}),
+	onNonEmpty: (markers) => ({ extensions: [customDecorations(markers)] })
+});
+//#endregion
+//#region src/workspace.ts
+const emptyIndex = { pages: [] };
+const PAGE_EXTENSIONS = [".csn", ".csnx"];
+const SKIP_DIRECTORIES = [
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	".next",
+	".astro",
+	".turbo",
+	".cache"
+];
+/** A directory's entries. One that cannot be read holds nothing, rather than failing the walk. */
+const entriesOf = (directory) => pipe(Effect.tryPromise(() => readdir(directory, { withFileTypes: true })), Effect.orElseSucceed(() => []));
+/** The page files one entry of `directory` holds: itself, what is under it, or none. */
+const filesAt = (directory, entry) => Match.value(entry).pipe(Match.when((dir) => dir.isDirectory() && Array.contains(SKIP_DIRECTORIES, dir.name), () => Effect.succeed([])), Match.when((dir) => dir.isDirectory(), () => pageFiles(join(directory, entry.name))), Match.when((file) => Array.contains(PAGE_EXTENSIONS, extname(file.name)), () => Effect.succeed([join(directory, entry.name)])), Match.orElse(() => Effect.succeed([])));
+/** Every page file under `directory`, depth-first, in the order the directory lists them. */
+const pageFiles = (directory) => pipe(entriesOf(directory), Effect.map(Array.filter((entry) => !entry.name.startsWith("."))), Effect.flatMap(Effect.forEach((entry) => filesAt(directory, entry))), Effect.map(Array.flatten));
+/** `text` past the leading `---` fence, which is YAML rather than a line of the page. */
+const withoutFrontmatter = (text) => pipe(Option.liftPredicate(text, (all) => all.startsWith("---\n")), Option.flatMap((all) => pipe(all.indexOf("\n---", 3), Option.liftPredicate((end) => end !== -1), Option.map((end) => all.slice(end + 4)))), Option.getOrElse(() => text));
+const firstLine = (text) => pipe(text.split("\n"), Array.map((line) => line.trim()), Array.findFirst((line) => line !== ""));
+/**
+* What the file calls itself: its first line.
+*
+* The frontmatter is skipped rather than read. Cosense has no notion of a title held apart
+* from the text — the first line *is* the title, and a link finds a page by it. A `title:`
+* that disagreed with the first line would name a page nobody can see, so it is ignored
+* here even though `metadata.ts` still prefers it.
+*
+* An empty file falls back to its name, so it stays linkable.
+*/
+const titleOf = (path, text, frontmatter) => pipe(text.replace(/\r\n?/g, "\n"), (normalized) => Option.getOrElse(Option.map(Option.liftPredicate(normalized, () => frontmatter), withoutFrontmatter), () => normalized), firstLine, Option.getOrElse(() => basename(path, extname(path))));
+/** `path` from `root`, with `/` between directories whatever the platform. */
+const locationOf = (root, path) => relative(root, path).split(sep).join("/");
+/** A file that cannot be read is left out rather than failing the rest. */
+const readPageFile = (root, path, { frontmatter = true }) => pipe(Effect.tryPromise(() => readFile(path, "utf8")), Effect.map((text) => Option.some({
+	page: {
+		title: titleOf(path, text, frontmatter),
+		uri: pathToFileURL(path).href,
+		location: locationOf(root, path)
+	},
+	path,
+	text
+})), Effect.orElseSucceed(() => Option.none()));
+/** The page files under one root. */
+const filesUnder = (options) => (root) => pipe(pageFiles(root), Effect.flatMap(Effect.forEach((path) => readPageFile(root, path, options))), Effect.map(Array.getSomes));
+/**
+* Every page file under `roots`. Roots may overlap (`src` and `src/content`), so a file
+* found twice is kept once, where it was first found.
+*/
+const readPageFiles = (roots, options = {}) => pipe(Effect.forEach(roots, filesUnder(options)), Effect.map((found) => Array.dedupeWith(Array.flatten(found), (a, b) => a.path === b.path)));
+/** The pages of `files`, as an index. */
+const indexOf = (files) => ({ pages: Array.map(files, (file) => file.page) });
+/** Read every page under `roots` and index it. */
+const readIndex = (roots, options = {}) => Effect.map(readPageFiles(roots, options), indexOf);
+/**
+* Where to read pages: each workspace folder, or each of `sources` under it when the reader
+* has set them. A folder that is not a `file://` URI has no files to read.
+*/
+const rootsOf = (folders, sources) => pipe(Array.filterMap(folders ?? [], ({ uri }) => Option.liftThrowable(fileURLToPath)(uri)), Array.flatMap((folder) => Array.match(sources, {
+	onEmpty: () => [folder],
+	onNonEmpty: (under) => Array.map(under, (source) => resolve(folder, source))
+})));
+//#endregion
+export { rootsOf as a, settingsOf as c, readPageFiles as i, severityOf as l, indexOf as n, defaultSettings as o, readIndex as r, parseOptionsOf as s, emptyIndex as t, unresolvedLinkDiagnostics as u };
+
+//# sourceMappingURL=workspace-DouAOZnK.mjs.map