@cosense-toolbox/parser 0.1.0-beta.0

package/dist/index.mjs

@@ -0,0 +1,709 @@
+import { n as hasImageExtension, r as isImageUrl, t as asImageSrc } from "./image-url-eQ6X-oN0.mjs";
+import { Match, Option, pipe } from "effect";
+//#region src/core/position.ts
+const originOfLine = (line, offset) => ({
+	line,
+	column: 0,
+	offset
+});
+/** Origin を `by` 文字ぶん進める (部分文字列を再帰的に走査するときに使う)。 */
+const shiftOrigin = (origin, by) => ({
+	line: origin.line,
+	column: origin.column + by,
+	offset: origin.offset + by
+});
+const pointAt = (origin, index) => ({
+	line: origin.line,
+	column: origin.column + index,
+	offset: origin.offset + index
+});
+/** 走査対象の `[start, end)` が占める Position。end は exclusive。 */
+const spanAt = (origin, start, end) => ({
+	start: pointAt(origin, start),
+	end: pointAt(origin, end)
+});
+//#endregion
+//#region src/inline/constructs/bare-url.ts
+const URL_RE = /^https?:\/\/[^\s\]]+/i;
+/**
+* 角括弧で囲まれていない URL。常に外部リンクになり、画像 URL でも画像にはしない
+* (本家準拠。インライン画像になるのは `[https://.../x.png]` の角括弧つきのみ)。
+*/
+const bareUrlConstruct = (source, index) => {
+	const head = source[index];
+	if (head !== "h" && head !== "H") return Option.none();
+	const match = source.slice(index).match(URL_RE);
+	if (!match) return Option.none();
+	const url = match[0];
+	return Option.some({
+		node: {
+			type: "externalLink",
+			label: url,
+			target: url
+		},
+		length: url.length
+	});
+};
+//#endregion
+//#region src/core/scan.ts
+/**
+* scan.ts — 記法の知識を持たない文字列走査のプリミティブ。
+*/
+/** 行頭の空白 (半角スペース / タブ / 全角スペース)。インデント判定の単一ソース。 */
+const LEADING_WHITESPACE_RE = /^[ \t　]*/;
+const leadingWhitespace = (s) => LEADING_WHITESPACE_RE.exec(s)?.[0] ?? "";
+/**
+* `openIdx` の `[` に対応する `]` の位置。深さを数えるので
+* `[* a [b] c]` のような入れ子でも外側の `]` を返す。対応が閉じなければ None。
+*/
+const findClosingBracket = (s, openIdx) => {
+	let depth = 0;
+	for (let i = openIdx; i < s.length; i++) {
+		const ch = s[i];
+		if (ch === "[") depth++;
+		else if (ch === "]") {
+			depth--;
+			if (depth === 0) return Option.some(i);
+		}
+	}
+	return Option.none();
+};
+/** `#` がタグの開始位置か (行頭、または直前が空白)。単語の途中の `#` を除くため。 */
+const isTagBoundary = (s, index) => {
+	if (index === 0) return true;
+	const prev = s[index - 1];
+	return prev === " " || prev === "	" || prev === "　";
+};
+//#endregion
+//#region src/inline/bracket-rules/decoration.ts
+/** 先頭の装飾記号の run と、空白を挟んだ中身。 */
+const DECORATION_RE = /^([*/\-_]+)\s+([\s\S]+)$/;
+const MAX_SIZE_LEVEL = 4;
+/**
+* `[* 太字]` `[/ 斜体]` `[- 打消し]` `[_ 下線]` とその複合 (`[-/ x]`)。
+*
+* 中身はリンクやアイコンとして再帰的に解釈するが、**装飾の入れ子は不可**
+* (本家準拠)。そのため子の走査は allowDecoration=false で行う。
+* 例: `[* [* 太字]ですね]` の内側は装飾ではなく内部リンクになる。
+*/
+const decorationRule = (inner, ctx) => {
+	if (!ctx.allowDecoration) return Option.none();
+	const match = inner.match(DECORATION_RE);
+	if (!match) return Option.none();
+	const marks = match[1] ?? "";
+	const value = match[2] ?? "";
+	const stars = (marks.match(/\*/g) ?? []).length;
+	const valueOffset = inner.length - value.length;
+	return Option.some({
+		type: "decoration",
+		value,
+		bold: stars > 0,
+		italic: marks.includes("/"),
+		strike: marks.includes("-"),
+		underline: marks.includes("_"),
+		sizeLevel: Math.min(Math.max(stars - 1, 0), MAX_SIZE_LEVEL),
+		children: ctx.tokenize(value, shiftOrigin(ctx.innerOrigin, valueOffset), false)
+	});
+};
+//#endregion
+//#region src/inline/bracket-rules/formula.ts
+/** `[$ x^2]` — 中身は解釈せず生のまま返す (KaTeX 等に渡す想定)。 */
+const formulaRule = (inner) => inner.startsWith("$") ? Option.some({
+	type: "formula",
+	value: inner.slice(1).trim()
+}) : Option.none();
+//#endregion
+//#region src/inline/bracket-rules/icon.ts
+const ICON_RE = /^(.+)\.icon(?:\*(\d+))?$/;
+const MIN_COUNT = 1;
+const MAX_COUNT = 20;
+/** `[user.icon]` と連打 `[user.icon*5]`。個数は 1..20 に収める (描画の暴走を防ぐため)。 */
+const iconRule = (inner) => {
+	const match = inner.match(ICON_RE);
+	if (!match) return Option.none();
+	const raw = match[2];
+	const count = raw ? Math.min(Math.max(Number.parseInt(raw, 10), MIN_COUNT), MAX_COUNT) : MIN_COUNT;
+	return Option.some({
+		type: "icon",
+		user: match[1] ?? "",
+		count
+	});
+};
+//#endregion
+//#region src/inline/bracket-rules/image-extension.ts
+/**
+* URL ではなく拡張子だけで画像と分かる中身 (`[a.png]`)。
+*
+* 装飾の中では画像にせずリンク扱いにする (本家準拠)。`[* [a.png]]` の内側は
+* 画像ではなく `a.png` というタイトルの内部リンクになる。
+*/
+const imageExtensionRule = (inner, ctx) => ctx.allowDecoration && hasImageExtension(inner) ? Option.some({
+	type: "image",
+	src: inner
+}) : Option.none();
+//#endregion
+//#region src/inline/bracket-rules/internal-link.ts
+/**
+* `[title]` — 他のどのルールにも当たらなかった角括弧は内部リンクになる。
+* 常に Some を返す catch-all なので、ルール配列の最後に置くこと。
+*/
+const internalLinkRule = (inner) => Option.some({
+	type: "internalLink",
+	label: inner,
+	target: inner
+});
+//#endregion
+//#region src/inline/bracket-rules/project-link.ts
+/**
+* `[/project/title]` — 別プロジェクトのページへのリンク。
+*
+* タイトルは `/` を含みうるので最初の `/` だけで分割する。
+* `[/project]` のようにタイトルが無い書き方も記法としては成立するので、
+* その場合は title を空文字にする (利用側が「プロジェクトそのものへのリンク」と判断できる)。
+*/
+const projectLinkRule = (inner) => {
+	if (!inner.startsWith("/")) return Option.none();
+	const rest = inner.slice(1);
+	const slash = rest.indexOf("/");
+	const project = slash < 0 ? rest : rest.slice(0, slash);
+	const title = slash < 0 ? "" : rest.slice(slash + 1);
+	return Option.some({
+		type: "projectLink",
+		label: inner,
+		target: inner,
+		project,
+		title
+	});
+};
+//#endregion
+//#region src/inline/bracket-rules/url.ts
+const URLS_RE = /https?:\/\/[^\s\]]+/gi;
+/** 画像 URL が複数あるとき最後のものを採るのは本家の挙動。 */
+const lastImage = (urls) => {
+	const images = urls.filter(isImageUrl);
+	return Option.fromNullable(images[images.length - 1]);
+};
+/** 画像に添える遷移先。画像自身とは別の URL を優先し、無ければ先頭を使う。 */
+const linkFor = (urls, src) => Option.fromNullable(urls.find((url) => url !== src) ?? urls[0]);
+/**
+* 中身に URL を含む角括弧。本家の挙動に合わせて次の順で決める:
+*
+* 1. URL 以外の文字が残る → ラベル付き外部リンク。URL が画像でも文字リンクにする
+*    (`[ラベル https://x/a.png]` は画像にならない)。
+* 2. URL だけが 2 つ以上:
+*    - 画像 URL があれば「リンク付き画像」。画像が複数なら最後を表示し、それ以外の先頭をリンク先にする。
+*    - 画像が無ければ 先頭 = リンク先 / 2 番目 = 表示テキスト。
+* 3. URL が 1 つだけ → 画像なら画像、違えば裸の外部リンク。
+*/
+const urlRule = (inner) => {
+	const urls = inner.match(URLS_RE) ?? [];
+	if (urls.length === 0) return Option.none();
+	const label = urls.reduce((rest, url) => rest.replace(url, " "), inner).trim();
+	if (label !== "") return Option.some({
+		type: "externalLink",
+		label,
+		target: urls[0] ?? inner
+	});
+	if (urls.length >= 2) return Option.some(pipe(lastImage(urls), Option.match({
+		onSome: (src) => pipe(linkFor(urls, src), Option.match({
+			onNone: () => ({
+				type: "image",
+				src
+			}),
+			onSome: (link) => ({
+				type: "image",
+				src,
+				link
+			})
+		})),
+		onNone: () => ({
+			type: "externalLink",
+			label: urls[1] ?? urls[0] ?? "",
+			target: urls[0] ?? inner
+		})
+	})));
+	const only = urls[0] ?? inner;
+	return Option.some(pipe(Option.liftPredicate(only, isImageUrl), Option.match({
+		onSome: (src) => ({
+			type: "image",
+			src
+		}),
+		onNone: () => ({
+			type: "externalLink",
+			label: only,
+			target: only
+		})
+	})));
+};
+//#endregion
+//#region src/inline/bracket-rules/index.ts
+/** 中身に角括弧を含んでいても成立しうるルール。 */
+const bracketRules = [formulaRule, decorationRule];
+/**
+* 「単純ターゲット」のルール。中身に `[` / `]` を含むときは試さない (本家準拠)。
+* これにより `[[そうね] ですね]` の外側は記法にならず、先頭の `[` が素の文字になる。
+* 末尾の internalLinkRule は常に成立する catch-all。
+*/
+const simpleTargetRules = [
+	iconRule,
+	urlRule,
+	imageExtensionRule,
+	projectLinkRule,
+	internalLinkRule
+];
+//#endregion
+//#region src/inline/constructs/bracket.ts
+/** ルールを順に試す。ジェネレータにしているのは最初に成立した時点で残りを評価しないため。 */
+function* attempts$1(rules, inner, ctx) {
+	for (const rule of rules) yield rule(inner, ctx);
+}
+const parseInner = (inner, ctx) => pipe(Option.firstSomeOf(attempts$1(ctx.bracketRules, inner, ctx)), Option.orElse(() => Option.firstSomeOf(attempts$1(bracketRules, inner, ctx))), Option.orElse(() => inner.includes("[") || inner.includes("]") ? Option.none() : Option.firstSomeOf(attempts$1(simpleTargetRules, inner, ctx))));
+/**
+* `[...]` 全般。閉じ括弧は深さを数えて探すので `[* a [b] c]` でも外側で閉じる。
+*
+* 中身が空 (`[]` / `[ ]`) のときと、どのルールにも当たらなかったときは None を返す。
+* 呼び出し側は先頭の `[` を素の文字として 1 文字進めるので、内側が改めて走査される。
+*/
+const bracketConstruct = (source, index, ctx) => {
+	if (source[index] !== "[") return Option.none();
+	return pipe(findClosingBracket(source, index), Option.flatMap((end) => {
+		const inner = source.slice(index + 1, end);
+		if (inner.trim() === "") return Option.none();
+		const innerCtx = {
+			...ctx,
+			innerOrigin: shiftOrigin(ctx.origin, index + 1)
+		};
+		return pipe(parseInner(inner, innerCtx), Option.map((node) => ({
+			node,
+			length: end + 1 - index
+		})));
+	}));
+};
+//#endregion
+//#region src/inline/constructs/hashtag.ts
+/** タグ名に使えない文字。空白と角括弧と `#` 自身で終わる。 */
+const TAG_NAME_RE = /^[^\s[\]#]+/;
+/** `#tag`。行頭または空白の直後でだけ成立する (単語の途中の `#` を拾わないため)。 */
+const hashtagConstruct = (source, index) => {
+	if (source[index] !== "#" || !isTagBoundary(source, index)) return Option.none();
+	const match = source.slice(index + 1).match(TAG_NAME_RE);
+	if (!match) return Option.none();
+	const value = match[0];
+	return Option.some({
+		node: {
+			type: "hashtag",
+			value
+		},
+		length: value.length + 1
+	});
+};
+//#endregion
+//#region src/inline/constructs/inline-code.ts
+/** バッククォートで囲んだインラインコード。閉じるバッククォートが無ければ成立しない。 */
+const inlineCodeConstruct = (source, index) => {
+	if (source[index] !== "`") return Option.none();
+	const end = source.indexOf("`", index + 1);
+	if (end < 0) return Option.none();
+	return Option.some({
+		node: {
+			type: "inlineCode",
+			value: source.slice(index + 1, end)
+		},
+		length: end + 1 - index
+	});
+};
+//#endregion
+//#region src/inline/constructs/strong-bracket.ts
+/**
+* `[[...]]` — 本家の strong。`]]` で閉じるときだけ成立する
+* (深さは数えない。`[[a] b]` のようなケースは bracketConstruct 側で処理される)。
+*
+* 中身が画像 URL なら大きい画像、そうでなければ太字装飾になる。
+*/
+const strongBracketConstruct = (source, index, ctx) => {
+	if (source[index] !== "[" || source[index + 1] !== "[") return Option.none();
+	const end = source.indexOf("]]", index + 2);
+	if (end < 0) return Option.none();
+	const inner = source.slice(index + 2, end);
+	const length = end + 2 - index;
+	if (isImageUrl(inner)) {
+		const node = {
+			type: "image",
+			src: inner,
+			large: true
+		};
+		return Option.some({
+			node,
+			length
+		});
+	}
+	return Option.some({
+		node: {
+			type: "decoration",
+			value: inner,
+			bold: true,
+			italic: false,
+			strike: false,
+			underline: false,
+			sizeLevel: 0,
+			children: ctx.tokenize(inner, shiftOrigin(ctx.origin, index + 2), false)
+		},
+		length
+	});
+};
+//#endregion
+//#region src/inline/constructs/index.ts
+const inlineConstructs = [
+	strongBracketConstruct,
+	bracketConstruct,
+	inlineCodeConstruct,
+	hashtagConstruct,
+	bareUrlConstruct
+];
+//#endregion
+//#region src/inline/tokenize.ts
+/**
+* tokenize.ts — 行内の走査ループ。
+*
+* 1 文字ずつ進みながら construct を順に試し、成立したらノードにする。どれも成立しなければ
+* その 1 文字はテキストとして貯めておき、次にノードが出たところ (と末尾) でまとめて
+* text ノードにする。位置の付与はこのループだけが行う。
+*/
+/** 拡張のルールを既定のルールの前に並べる。拡張が既定の記法を上書きできるのはこの順序による。 */
+const resolveExtensions = (extensions) => {
+	if (extensions === void 0 || extensions.length === 0) return {
+		constructs: inlineConstructs,
+		bracketRules: []
+	};
+	const constructs = [];
+	const bracketRules = [];
+	for (const extension of extensions) {
+		if (extension.constructs) constructs.push(...extension.constructs);
+		if (extension.bracketRules) bracketRules.push(...extension.bracketRules);
+	}
+	return {
+		constructs: [...constructs, ...inlineConstructs],
+		bracketRules
+	};
+};
+/**
+* ノード本体に位置を与える。判別共用体へのスプレッドは TS が型を保てないため
+* ここだけキャストする (position 以外のフィールドは触っていない)。
+*/
+const withPosition = (node, position) => ({
+	...node,
+	position
+});
+/** ジェネレータにしているのは、最初に成立した時点で残りのルールを評価しないため。 */
+function* attempts(constructs, source, index, ctx) {
+	for (const construct of constructs) yield construct(source, index, ctx);
+}
+const firstMatch = (constructs, source, index, ctx) => Option.firstSomeOf(attempts(constructs, source, index, ctx));
+const scan = (source, origin, allowDecoration, rules) => {
+	const out = [];
+	const ctx = {
+		allowDecoration,
+		origin,
+		bracketRules: rules.bracketRules,
+		tokenize: (inner, innerOrigin, innerAllowDecoration) => scan(inner, innerOrigin, innerAllowDecoration, rules)
+	};
+	let textStart = 0;
+	let index = 0;
+	const flushText = (end) => {
+		if (end <= textStart) return;
+		out.push({
+			type: "text",
+			value: source.slice(textStart, end),
+			position: spanAt(origin, textStart, end)
+		});
+	};
+	while (index < source.length) {
+		const match = firstMatch(rules.constructs, source, index, ctx);
+		if (Option.isNone(match)) {
+			index++;
+			continue;
+		}
+		flushText(index);
+		const { node, length } = match.value;
+		out.push(withPosition(node, spanAt(origin, index, index + length)));
+		index += length;
+		textStart = index;
+	}
+	flushText(index);
+	return out;
+};
+const resolveOrigin = (origin) => ({
+	line: origin?.line ?? 0,
+	column: origin?.column ?? 0,
+	offset: origin?.offset ?? 0
+});
+/**
+* インライン記法をノード列に分解する。改行を含まない 1 行分の文字列を渡すこと。
+*
+* 記法として成立しなかった文字は text ノードにまとまる。空文字列では空配列を返す。
+*/
+const tokenizeInline = (source, options) => scan(source, resolveOrigin(options?.origin), options?.allowDecoration ?? true, resolveExtensions(options?.extensions));
+/**
+* 解決済みのルールで走査する内部向け入口。
+* 行ごとに `tokenizeInline` を呼ぶと拡張の解決が毎回走るので、それを避けたいときに使う。
+*/
+const tokenizeInlineWith = (source, origin, rules) => scan(source, origin, true, rules);
+//#endregion
+//#region src/block/classify.ts
+/**
+* classify.ts — 1 行が何の行かを判定する。インライン記法の中身には立ち入らない。
+*
+* 結果はタグ付きユニオンなので、行の種類を増やすと分岐している側が
+* exhaustive チェックで対応漏れを教えてくれる。
+*/
+const CODE_HEADER_RE = /^code:(.+)$/;
+const TABLE_HEADER_RE = /^table:(.+)$/;
+/** 引用記号と、その直後の空白 1 つ (あれば本文から除く)。 */
+const QUOTE_RE = /^>\s?/;
+const MONOSPACE_RE = /^[$%]/;
+const codeHeader = (rest, indent) => {
+	const match = rest.match(CODE_HEADER_RE);
+	return match ? Option.some({
+		_tag: "codeHeader",
+		indent,
+		filename: (match[1] ?? "").trimEnd()
+	}) : Option.none();
+};
+const tableHeader = (rest, indent) => {
+	const match = rest.match(TABLE_HEADER_RE);
+	return match ? Option.some({
+		_tag: "tableHeader",
+		indent,
+		name: (match[1] ?? "").trimEnd()
+	}) : Option.none();
+};
+const content = (rest, indent) => {
+	const quoteMark = rest.match(QUOTE_RE)?.[0] ?? "";
+	const body = rest.slice(quoteMark.length);
+	return {
+		_tag: "content",
+		indent,
+		quote: quoteMark !== "",
+		monospace: MONOSPACE_RE.test(body),
+		contentOffset: indent + quoteMark.length
+	};
+};
+/**
+* 行の役割を判定する。`code:` / `table:` は行の意味がページの文脈
+* (コードブロックの中かどうか) で変わるので、ここでは「ヘッダの形をしている」ことだけを見る。
+*/
+const classifyLine = (raw) => {
+	const indent = leadingWhitespace(raw).length;
+	const rest = raw.slice(indent);
+	return pipe(Option.firstSomeOf([codeHeader(rest, indent), tableHeader(rest, indent)]), Option.getOrElse(() => content(rest, indent)));
+};
+/** 行頭の空白の文字数。全角スペースも 1 文字として数える。 */
+const indentOf = (raw) => leadingWhitespace(raw).length;
+//#endregion
+//#region src/block/build.ts
+/**
+* build.ts — 行の並びをブロックに畳む。
+*
+* `code:` / `table:` は「ヘッダ行 + それより深いインデントの行」で 1 つのブロックになる。
+* この複数行のまとまりを作るのがここの仕事で、行の中身の解釈は注入された tokenize に任せる
+* (どの記法ルールを使うかを知らずに済むので、拡張入りのパーサーでもここは変わらない)。
+*/
+const lineOrigin = (line) => originOfLine(line.index, line.offset);
+const wholeLine = (line) => spanAt(lineOrigin(line), 0, line.text.length);
+/** インデントを `amount` 文字ぶん浅くする。空白より多くは削らない。 */
+const dedent = (text, amount) => text.slice(Math.min(amount, indentOf(text)));
+const titleBlock = (line, tokenize) => ({
+	type: "title",
+	value: line.text,
+	children: tokenize(line.text, lineOrigin(line)),
+	position: wholeLine(line)
+});
+const lineBlock = (line, role, tokenize) => ({
+	type: "line",
+	indent: role.indent,
+	quote: role.quote,
+	monospace: role.monospace,
+	children: tokenize(line.text.slice(role.contentOffset), {
+		line: line.index,
+		column: role.contentOffset,
+		offset: line.offset + role.contentOffset
+	}),
+	position: wholeLine(line)
+});
+const codeLine = (line, headerIndent) => ({
+	type: "codeLine",
+	value: dedent(line.text, headerIndent + 1),
+	position: wholeLine(line)
+});
+const tableCells = (line) => {
+	const indent = indentOf(line.text);
+	const origin = lineOrigin(line);
+	const cells = [];
+	let start = indent;
+	for (const value of line.text.slice(indent).split("	")) {
+		cells.push({
+			type: "tableCell",
+			value,
+			position: spanAt(origin, start, start + value.length)
+		});
+		start += value.length + 1;
+	}
+	return cells;
+};
+const tableRow = (line) => ({
+	type: "tableRow",
+	cells: tableCells(line),
+	position: wholeLine(line)
+});
+/** ヘッダより深いインデントが続く範囲の終端 (exclusive)。 */
+const bodyEnd = (lines, start, headerIndent) => {
+	let end = start;
+	while (end < lines.length) {
+		const line = lines[end];
+		if (line === void 0 || indentOf(line.text) <= headerIndent) break;
+		end++;
+	}
+	return end;
+};
+const blockPosition = (header, body) => ({
+	start: wholeLine(header).start,
+	end: wholeLine(body[body.length - 1] ?? header).end
+});
+const codeBlock = (header, body, filename, indent) => ({
+	type: "codeBlock",
+	filename,
+	indent,
+	lines: body.map((line) => codeLine(line, indent)),
+	position: blockPosition(header, body)
+});
+const tableBlock = (header, body, name, indent) => ({
+	type: "table",
+	name,
+	indent,
+	rows: body.map(tableRow),
+	position: blockPosition(header, body)
+});
+/**
+* 行の並びをブロックの並びに畳む。1 行目は無条件でタイトルになる
+* (Cosense ではタイトル行が `code:` や `table:` として解釈されることはない)。
+*/
+const buildBlocks = (lines, tokenize) => {
+	const blocks = [];
+	const head = lines[0];
+	if (head === void 0) return blocks;
+	blocks.push(titleBlock(head, tokenize));
+	let index = 1;
+	while (index < lines.length) {
+		const line = lines[index];
+		if (line === void 0) break;
+		index = Match.value(classifyLine(line.text)).pipe(Match.tag("codeHeader", (role) => {
+			const end = bodyEnd(lines, index + 1, role.indent);
+			blocks.push(codeBlock(line, lines.slice(index + 1, end), role.filename, role.indent));
+			return end;
+		}), Match.tag("tableHeader", (role) => {
+			const end = bodyEnd(lines, index + 1, role.indent);
+			blocks.push(tableBlock(line, lines.slice(index + 1, end), role.name, role.indent));
+			return end;
+		}), Match.tag("content", (role) => {
+			blocks.push(lineBlock(line, role, tokenize));
+			return index + 1;
+		}), Match.exhaustive);
+	}
+	return blocks;
+};
+/**
+* 1 行だけを通常行として組み立てる。
+* ページの文脈が無いので `code:` / `table:` ヘッダもブロックにはせず、通常行として扱う。
+*/
+const buildLineBlock = (line, tokenize) => {
+	const role = classifyLine(line.text);
+	return lineBlock(line, role._tag === "content" ? role : {
+		_tag: "content",
+		indent: role.indent,
+		quote: false,
+		monospace: false,
+		contentOffset: role.indent
+	}, tokenize);
+};
+//#endregion
+//#region src/parse.ts
+/**
+* parse.ts — ページ全文の入口。
+*/
+/**
+* CR / CRLF を LF に揃える。
+*
+* `parse` は必ずこれを通してから解析するので、報告される位置は**正規化後**の
+* 文字列を基準にする。CRLF のソースでは元のオフセットと 1 行につき 1 文字ずれる。
+*/
+const normalizeLineEndings = (source) => source.replace(/\r\n?/g, "\n");
+const toSourceLines = (source) => {
+	const lines = [];
+	let offset = 0;
+	for (const [index, text] of source.split("\n").entries()) {
+		lines.push({
+			index,
+			text,
+			offset
+		});
+		offset += text.length + 1;
+	}
+	return lines;
+};
+/**
+* ページ全文をパースする。**失敗しない**: どんな入力でも Page を返す。
+* 記法として成立しない部分は素のテキストになるだけで、エラーにはならない。
+*
+* 1 行目はタイトルとして扱われる (Cosense のページは 1 行目がタイトル)。
+*/
+const parse = (source, options) => {
+	const normalized = normalizeLineEndings(source);
+	const lines = toSourceLines(normalized);
+	const rules = resolveExtensions(options?.extensions);
+	const last = lines[lines.length - 1];
+	return {
+		type: "page",
+		children: buildBlocks(lines, (text, origin) => tokenizeInlineWith(text, origin, rules)),
+		position: {
+			start: {
+				line: 0,
+				column: 0,
+				offset: 0
+			},
+			end: {
+				line: last?.index ?? 0,
+				column: last?.text.length ?? 0,
+				offset: normalized.length
+			}
+		}
+	};
+};
+/**
+* 1 行だけを通常行としてパースする。
+*
+* `code:` / `table:` はページの文脈があって初めてブロックになるので、
+* ここでは通常行として扱う。
+*/
+const parseLine = (raw, options) => {
+	const rules = resolveExtensions(options?.extensions);
+	return buildLineBlock({
+		index: options?.line ?? 0,
+		text: raw,
+		offset: options?.offset ?? 0
+	}, (text, origin) => tokenizeInlineWith(text, origin, rules));
+};
+/**
+* 拡張を固定したパーサーを作る。同じ拡張で何度もパースするときに、
+* 呼び出しごとに options を渡さずに済む。
+*/
+const createParser = (options) => ({
+	parse: (source) => parse(source, options),
+	parseLine: (raw, lineOptions) => parseLine(raw, {
+		...lineOptions,
+		...options
+	})
+});
+//#endregion
+export { asImageSrc, createParser, isImageUrl, normalizeLineEndings, parse, parseLine, tokenizeInline };
+
+//# sourceMappingURL=index.mjs.map