@sushichan044/kg-core 0.9.4 → 0.10.0

package/dist/novel-composer-DRgsEA2s.mjs

@@ -1,2340 +0,0 @@
-import { c as ManuscriptResult, d as NamespacedId, f as ManuscriptRange, h as readonlyObject, i as OPENING_BRACKETS, m as readonlyArray, o as graphemeSegmenter, p as nonNegativeInteger, r as CLOSING_BRACKETS, t as questionOrExclamationSpacings } from "./question-or-exclamation-spacing-B5o23ZLf.mjs";
-import * as v from "valibot";
-import { eastAsianWidth } from "get-east-asian-width";
-const BoldAnnotation = { schema: readonlyObject({
-	kind: v.literal("bold"),
-	range: ManuscriptRange.schema
-}) };
-const EmphasisAnnotation = { schema: readonlyObject({
-	kind: v.literal("emphasis"),
-	range: ManuscriptRange.schema,
-	mark: v.string()
-}) };
-const ItalicAnnotation = { schema: readonlyObject({
-	kind: v.literal("italic"),
-	range: ManuscriptRange.schema
-}) };
-//#endregion
-//#region src/parser/annotation/ruby-annotation.ts
-const GroupRubyKindSchema = v.literal("group");
-const MonoRubyKindSchema = v.literal("mono");
-const JukugoRubyKindSchema = v.literal("jukugo");
-const RubyKindSchema = v.union([
-	GroupRubyKindSchema,
-	MonoRubyKindSchema,
-	JukugoRubyKindSchema
-]);
-const RubyReadingSchema = v.variant("kind", [
-	readonlyObject({
-		kind: GroupRubyKindSchema,
-		text: v.pipe(v.string(), v.nonEmpty())
-	}),
-	readonlyObject({
-		kind: MonoRubyKindSchema,
-		segments: v.pipe(v.array(v.pipe(v.string(), v.nonEmpty())), v.nonEmpty(), v.readonly())
-	}),
-	readonlyObject({
-		kind: JukugoRubyKindSchema,
-		segments: v.pipe(v.array(v.pipe(v.string(), v.nonEmpty())), v.nonEmpty(), v.readonly())
-	})
-]);
-const RubyAnnotationSchema = readonlyObject({
-	kind: v.literal("ruby"),
-	range: ManuscriptRange.schema,
-	reading: RubyReadingSchema
-});
-const RubyKind = { schema: RubyKindSchema };
-const RubyAnnotation = { schema: RubyAnnotationSchema };
-const ManuscriptAnnotation = {
-	schema: v.variant("kind", [
-		RubyAnnotation.schema,
-		BoldAnnotation.schema,
-		ItalicAnnotation.schema,
-		EmphasisAnnotation.schema
-	]),
-	/**
-	* Stable order for rendering: outermost span first, then by variant name.
-	*/
-	compare: (left, right) => left.range.source.start - right.range.source.start || left.range.source.end - right.range.source.end || left.kind.localeCompare(right.kind)
-};
-const ParsedGrapheme = { schema: readonlyObject({
-	value: v.string(),
-	range: ManuscriptRange.schema
-}) };
-//#endregion
-//#region src/parser/parsed-manuscript.ts
-const ParsedManuscriptSchema = readonlyObject({
-	source: v.string(),
-	displayText: v.string(),
-	graphemes: readonlyArray(ParsedGrapheme.schema),
-	annotations: readonlyArray(ManuscriptAnnotation.schema)
-});
-function rangeFits(range, manuscript) {
-	return range.source.end <= manuscript.source.length && range.display.end <= manuscript.displayText.length && range.graphemes.end <= manuscript.graphemes.length;
-}
-function hasValidRubyAssociations(manuscript) {
-	const ruby = manuscript.annotations.filter((annotation) => annotation.kind === "ruby");
-	return ruby.every((annotation, index) => {
-		const baseLength = annotation.range.graphemes.end - annotation.range.graphemes.start;
-		if (baseLength <= 0) return false;
-		if (annotation.reading.kind !== "group" && annotation.reading.segments.length !== baseLength) return false;
-		return ruby.slice(index + 1).every((other) => !ManuscriptRange.overlaps(annotation.range, other.range));
-	});
-}
-function isConsistent(manuscript, source) {
-	const joined = manuscript.graphemes.map(({ value }) => value).join("");
-	const sequential = manuscript.graphemes.every(({ range }, index) => range.graphemes.start === index && range.graphemes.end === index + 1 && rangeFits(range, manuscript));
-	return manuscript.source === source && manuscript.displayText === joined && sequential && manuscript.annotations.every(({ range }) => rangeFits(range, manuscript)) && hasValidRubyAssociations(manuscript);
-}
-const CONTRACT_MESSAGE = "parser output must contain consistent source, display, grapheme, and annotation ranges and valid ruby associations";
-const ParsedManuscript = {
-	schema: ParsedManuscriptSchema,
-	/**
-	* The parser contract as a schema: shape, plus the cross-field invariants that make the three
-	* coordinate systems line up. Annotations come out in a stable order regardless of parser.
-	*/
-	contractFor: (source) => v.pipe(ParsedManuscriptSchema, v.check((manuscript) => isConsistent(manuscript, source), CONTRACT_MESSAGE), v.transform((manuscript) => ({
-		...manuscript,
-		annotations: [...manuscript.annotations].sort(ManuscriptAnnotation.compare)
-	})))
-};
-//#endregion
-//#region src/appearance/font-preset-id.ts
-const FontPresetIdSchema = v.picklist(["mincho", "gothic"]);
-const FontPresetId = {
-	schema: FontPresetIdSchema,
-	is: (value) => v.is(FontPresetIdSchema, value)
-};
-//#endregion
-//#region src/appearance/font-size-pt.ts
-const RANGE = {
-	min: 6,
-	max: 24,
-	step: .5
-};
-const FontSizePtSchema = v.pipe(v.number(), v.finite(), v.minValue(RANGE.min), v.maxValue(RANGE.max), v.multipleOf(RANGE.step));
-const FontSizePt = {
-	schema: FontSizePtSchema,
-	range: RANGE,
-	is: (value) => v.is(FontSizePtSchema, value)
-};
-//#endregion
-//#region src/appearance/paper-size-id.ts
-const PaperSizeIdSchema = v.picklist([
-	"a4",
-	"a5",
-	"a6",
-	"jis-b5",
-	"jis-b6",
-	"shinsho"
-]);
-const PaperSizeId = {
-	schema: PaperSizeIdSchema,
-	is: (value) => v.is(PaperSizeIdSchema, value)
-};
-const ManuscriptAppearanceSettings = {
-	schema: readonlyObject({
-		paperSize: PaperSizeId.schema,
-		fontSizePt: FontSizePt.schema,
-		fontPreset: FontPresetId.schema
-	}),
-	defaults: {
-		paperSize: "a5",
-		fontSizePt: 9,
-		fontPreset: "mincho"
-	}
-};
-const LineOffset = {
-	schema: readonlyObject({
-		leading: nonNegativeInteger(),
-		trailing: nonNegativeInteger()
-	}),
-	total: (offset) => offset.leading + offset.trailing
-};
-//#endregion
-//#region src/composer/manuscript-offsets.ts
-const MAX_DOCUMENT_OFFSET = 1e4;
-const ManuscriptOffsets = {
-	schema: readonlyObject({
-		document: readonlyObject({
-			leading: nonNegativeInteger(MAX_DOCUMENT_OFFSET),
-			trailing: nonNegativeInteger(MAX_DOCUMENT_OFFSET)
-		}),
-		page: LineOffset.schema,
-		stage: LineOffset.schema
-	}),
-	defaults: {
-		document: {
-			leading: 0,
-			trailing: 0
-		},
-		page: {
-			leading: 0,
-			trailing: 0
-		},
-		stage: {
-			leading: 0,
-			trailing: 0
-		}
-	},
-	/**
-	* Stage offsets must leave at least one usable line in the stage.
-	*/
-	maxStageTotal: (flow) => Math.max(0, flow.linesPerStage - 1),
-	/**
-	* Page offsets must leave at least one usable line on the page, after stage offsets apply.
-	*/
-	maxPageTotal: (flow, stage) => Math.max(0, (flow.linesPerStage - LineOffset.total(stage)) * flow.stagesPerPage - 1)
-};
-//#endregion
-//#region src/composer/novel-flow-settings.ts
-const RANGES = {
-	lineLengthEm: {
-		min: 10,
-		max: 60
-	},
-	linesPerStage: {
-		min: 10,
-		max: 60
-	},
-	stagesPerPage: {
-		min: 1,
-		max: 3
-	}
-};
-const boundedCount = (bounds) => v.pipe(v.number(), v.finite(), v.integer(), v.minValue(bounds.min), v.maxValue(bounds.max));
-const NovelFlowSettings = {
-	schema: readonlyObject({
-		lineLengthEm: boundedCount(RANGES.lineLengthEm),
-		linesPerStage: boundedCount(RANGES.linesPerStage),
-		stagesPerPage: boundedCount(RANGES.stagesPerPage)
-	}),
-	ranges: RANGES,
-	defaults: {
-		lineLengthEm: 27,
-		linesPerStage: 23,
-		stagesPerPage: 2
-	}
-};
-//#endregion
-//#region src/composer/composition-settings.ts
-const NovelCompositionSettingsSchema = v.pipe(readonlyObject({
-	flow: NovelFlowSettings.schema,
-	offsets: ManuscriptOffsets.schema,
-	appearance: ManuscriptAppearanceSettings.schema
-}), v.check(({ flow, offsets }) => LineOffset.total(offsets.stage) <= ManuscriptOffsets.maxStageTotal(flow) && LineOffset.total(offsets.page) <= ManuscriptOffsets.maxPageTotal(flow, offsets.stage), "page or stage offsets leave no usable novel lines"));
-const NovelCompositionSettings = {
-	schema: NovelCompositionSettingsSchema,
-	defaults: {
-		flow: NovelFlowSettings.defaults,
-		offsets: ManuscriptOffsets.defaults,
-		appearance: ManuscriptAppearanceSettings.defaults
-	},
-	is: (value) => v.is(NovelCompositionSettingsSchema, value)
-};
-const InlineMeasurement = { schema: readonlyObject({ advanceEm: v.pipe(v.number(), v.finite(), v.minValue(0)) }) };
-function graphemeWidth(grapheme) {
-	let width = 1;
-	for (const character of grapheme) {
-		const codePoint = character.codePointAt(0);
-		if (codePoint !== void 0) width = Math.max(width, eastAsianWidth(codePoint, { ambiguousAsWide: true }));
-	}
-	return width / 2;
-}
-/**
-* Deterministic Japanese-context measurement in logical em units.
-*/
-const logicalInlineMeasurer = (request) => {
-	const { text } = request;
-	const width = [...graphemeSegmenter.segment(text)].reduce((total, { segment }) => total + graphemeWidth(segment), 0);
-	if (request.role === "ruby") return { advanceEm: width / 2 };
-	return { advanceEm: request.presentation === "upright" ? [...graphemeSegmenter.segment(text)].length : width };
-};
-//#endregion
-//#region src/composer/internal/japanese-typesetting-profile.ts
-/**
-* The JLReq character classes (文字クラス) this profile distinguishes. The bare `cl-NN` identifiers are
-* kept rather than descriptive names so the spacing and penalty tables below can be read side by
-* side with the tables in the specification.
-*
-* JLReq defines thirty classes. Math (cl-17, cl-18) and warichu brackets (cl-28, cl-29) are absent
-* because a novel is not set with them. The base-group classes are absent for a different reason: a
-* novel does carry ruby (cl-22, cl-23), but ruby is an annotation the composer positions
-* separately, and `JapaneseCharacter` cannot describe a base group at all — nor a reference mark
-* (cl-20) or a subscripted base (cl-21). A base character is therefore classified here as whatever
-* it is on its own, which for the kanji that usually carries ruby means cl-19.
-*
-* @see https://www.w3.org/TR/jlreq/#character_classes
-*/
-const japaneseCharacterClasses = [
-	"cl-01",
-	"cl-02",
-	"cl-03",
-	"cl-04",
-	"cl-05",
-	"cl-06",
-	"cl-07",
-	"cl-08",
-	"cl-09",
-	"cl-10",
-	"cl-11",
-	"cl-12",
-	"cl-13",
-	"cl-14",
-	"cl-15",
-	"cl-16",
-	"cl-19",
-	"cl-24",
-	"cl-25",
-	"cl-26",
-	"cl-27",
-	"cl-30"
-];
-const OPENING = /* @__PURE__ */ new Set(`${OPENING_BRACKETS}【〘〝｟«`);
-const CLOSING = /* @__PURE__ */ new Set(`${CLOSING_BRACKETS}】〙〟｠»`);
-const HYPHENS = /* @__PURE__ */ new Set("‐‑⁃–");
-const DIVIDING_PUNCTUATION = /* @__PURE__ */ new Set("！？‼⁇⁈⁉");
-const MIDDLE_DOTS = /* @__PURE__ */ new Set("・：；");
-const SMALL_KANA = /* @__PURE__ */ new Set("ァィゥェォッャュョヮヵヶぁぃぅぇぉっゃゅょゎゕゖ");
-const ITERATION_MARKS = /* @__PURE__ */ new Set("ヽヾゝゞ々〻");
-const INSEPARABLE = /* @__PURE__ */ new Set("—―…‥─〳〵");
-const PREFIXED_ABBREVIATIONS = /* @__PURE__ */ new Set("￥＄£#＃");
-const POSTFIXED_ABBREVIATIONS = /* @__PURE__ */ new Set("°′″％‰");
-const UNIT_SYMBOLS = /* @__PURE__ */ new Set("℃℉㎀㎁㎂㎃㎄㎅㎆㎇㎈㎉㎊㎋㎌㎍㎎㎏㎐㎑㎒㎓㎔㎕㎖㎗㎘㎙㎚㎛㎜㎝㎞㎟㎠㎡㎢");
-const GROUPED_NUMERAL = /^[0-9０-９]$/u;
-const HIRAGANA = /^\p{Script=Hiragana}$/u;
-const KATAKANA = /^\p{Script=Katakana}$/u;
-const WESTERN = /^[\p{Script=Latin}\p{Script=Greek}\p{Script=Cyrillic}]$/u;
-/**
-* Order matters: a character inside a tate-chu-yoko group is cl-30 (3.2.5) and an upright Latin
-* letter or Arabic numeral is cl-19 (3.2.4), whatever either would be on its own; anything left
-* unmatched is cl-19 too, the class JLReq reserves for kanji and the like.
-*
-* The quarter em 3.2.6 sets between Japanese and a Western character or numeral applies only to a
-* character rotated 90 degrees in vertical writing mode or mixed into horizontal writing mode —
-* 3.2.6 states that scope explicitly. A character set upright keeps its own rule, 3.2.4, which
-* reads it as a full-width monospace glyph classed with kanji and set solid against its neighbours,
-* the same as a tate-chu-yoko run's 3.2.5.
-*/
-function classify({ value, presentation }) {
-	if (presentation === "tate-chu-yoko") return "cl-30";
-	if (presentation === "upright") return "cl-19";
-	if (OPENING.has(value)) return "cl-01";
-	if (CLOSING.has(value)) return "cl-02";
-	if (HYPHENS.has(value)) return "cl-03";
-	if (DIVIDING_PUNCTUATION.has(value)) return "cl-04";
-	if (MIDDLE_DOTS.has(value)) return "cl-05";
-	if (value === "。" || value === "．") return "cl-06";
-	if (value === "、" || value === "，") return "cl-07";
-	if (INSEPARABLE.has(value)) return "cl-08";
-	if (ITERATION_MARKS.has(value)) return "cl-09";
-	if (value === "ー") return "cl-10";
-	if (SMALL_KANA.has(value)) return "cl-11";
-	if (PREFIXED_ABBREVIATIONS.has(value)) return "cl-12";
-	if (POSTFIXED_ABBREVIATIONS.has(value)) return "cl-13";
-	if (value === "　") return "cl-14";
-	if (HIRAGANA.test(value)) return "cl-15";
-	if (KATAKANA.test(value)) return "cl-16";
-	if (GROUPED_NUMERAL.test(value)) return "cl-24";
-	if (UNIT_SYMBOLS.has(value)) return "cl-25";
-	if (value === " ") return "cl-26";
-	if (WESTERN.test(value)) return "cl-27";
-	return "cl-19";
-}
-/**
-* The stages JLReq 3.8.3 spends inter-character space in, as glue priorities: the lower the number,
-* the earlier the paragraph optimizer takes it.
-*
-* JLReq puts the western word space first and the line-end reduction second; this profile swaps the
-* two, because a priority here says how visible an adjustment is rather than where 3.8.3's list
-* puts it. Priority 0 is capacity the paragraph optimizer spends for nothing, and a line that spent
-* only priority 0 reads as tightly set as an unadjusted one. That is true of the line end and of
-* nothing else: the half em after a closing bracket, full stop or comma — and the quarter em after
-* a middle dot — falls outside the text area once that character sits at the line end, so taking it
-* changes nothing on the page (3.1.9). A 欧文間隔 sits between two words the reader is looking at, so
-* narrowing it does change the page. Spending the invisible space first can only leave the word
-* spaces nearer their 三分アキ than JLReq's order would, never further from it.
-*
-* Stages two and three are one priority because a line has a single line end, so the two never
-* compete.
-*/
-const REDUCTION_STAGE = {
-	/**
-	* Stages 2 and 3: the space after a closing bracket, full stop, comma or middle dot at line end.
-	*/
-	lineEnd: 0,
-	/**
-	* Stage 1: the western word space, from its 三分アキ down to a 四分アキ.
-	*/
-	wordSpace: 1,
-	/**
-	* Stage 4: the quarter em on either side of a mid-line middle dot.
-	*/
-	middleDot: 2,
-	/**
-	* Stage 5: the half em before an opening bracket and after a closing bracket or comma.
-	*/
-	punctuation: 3,
-	/**
-	* Stage 6: the quarter em between Japanese and a numeral, unit symbol or western character.
-	*/
-	mixedText: 4
-};
-/**
-* The stages JLReq 3.8.4 adds inter-character space in, as glue priorities on the same reading as
-* {@link REDUCTION_STAGE}: the lower the number, the earlier the paragraph optimizer takes it. A
-* line is either reduced or expanded, never both, so the two scales never meet.
-*
-* Nothing here takes priority 0. Expanding is always visible, and priority 0 means an adjustment
-* the optimizer is charged nothing for.
-*/
-const EXPANSION_STAGE = {
-	/**
-	* Stage 1: the western word space, from its 三分アキ up to a 二分アキ.
-	*/
-	wordSpace: 1,
-	/**
-	* Stage 2: the quarter em between Japanese and a numeral, unit symbol or western character.
-	*/
-	mixedText: 2,
-	/**
-	* Stage 3: everywhere else 表6 admits, from solid up to a quarter em.
-	*/
-	solid: 3,
-	/**
-	* Stage 4: the unbounded remainder, spread equally across every colored or gray cell of 表6.
-	*/
-	final: 4
-};
-/**
-* 無印 in 表1 with no colour in 表6: the pair is set solid and line adjustment leaves it alone.
-*/
-const SOLID = {
-	kind: "glue",
-	naturalWidthEm: 0
-};
-/**
-* `1/4` in 表6: set solid, but line adjustment may open it up to a quarter em.
-*/
-const SOLID_EXPANDABLE = {
-	kind: "glue",
-	naturalWidthEm: 0,
-	stretch: {
-		priority: EXPANSION_STAGE.solid,
-		amountEm: .25,
-		granularity: "continuous"
-	}
-};
-/**
-* `1/2` in 表1 with `1/2-0` in 表3: a half em that line adjustment may take down to solid.
-*/
-const HALF = {
-	kind: "glue",
-	naturalWidthEm: .5,
-	shrink: {
-		priority: REDUCTION_STAGE.punctuation,
-		amountEm: .5,
-		granularity: "continuous"
-	}
-};
-/**
-* `1/2` in both tables: the half em exists but is not a reduction opportunity.
-*/
-const FIXED_HALF = {
-	kind: "glue",
-	naturalWidthEm: .5
-};
-/**
-* `1/4` in 表1 with `1/4-0` in 表3: a quarter em that may go down to solid.
-*/
-const QUARTER = {
-	kind: "glue",
-	naturalWidthEm: .25,
-	shrink: {
-		priority: REDUCTION_STAGE.middleDot,
-		amountEm: .25,
-		granularity: "continuous"
-	}
-};
-/**
-* `1/4` in both tables: the quarter em exists but is not a reduction opportunity.
-*/
-const FIXED_QUARTER = {
-	kind: "glue",
-	naturalWidthEm: .25
-};
-/**
-* `1/4-1/8` in 表3 with `1/4-1/2` in 表6: the Japanese-to-western quarter em, reducible to an eighth
-* and expandable to a half. 3.2.6 sets this only against a Western character rotated 90 degrees or
-* mixed into horizontal text (cl-27) and a numeral or unit symbol (cl-24, cl-25); an upright
-* Western character classifies as cl-19 instead and never reaches this constant.
-*/
-const MIXED_TEXT_QUARTER = {
-	kind: "glue",
-	naturalWidthEm: .25,
-	shrink: {
-		priority: REDUCTION_STAGE.mixedText,
-		amountEm: .125,
-		granularity: "continuous"
-	},
-	stretch: {
-		priority: EXPANSION_STAGE.mixedText,
-		amountEm: .25,
-		granularity: "continuous"
-	}
-};
-/**
-* The same quarter em where 表6 leaves it out of the expansion: between a unit symbol and the
-* quantity on either side of it.
-*/
-const UNIT_SYMBOL_QUARTER = {
-	kind: "glue",
-	naturalWidthEm: .25,
-	shrink: {
-		priority: REDUCTION_STAGE.mixedText,
-		amountEm: .125,
-		granularity: "continuous"
-	}
-};
-/**
-* 表1 注3 with 表3 注1: two middle dots meet, and their quarters go solid together.
-*/
-const TWO_QUARTERS = {
-	kind: "glue",
-	naturalWidthEm: .5,
-	shrink: {
-		priority: REDUCTION_STAGE.middleDot,
-		amountEm: .5,
-		granularity: "continuous"
-	}
-};
-/**
-* 表1 注5 with 表3 注2: a full stop's fixed half em plus the following middle dot's quarter.
-*/
-const FIXED_HALF_AND_QUARTER = {
-	kind: "glue",
-	naturalWidthEm: .75,
-	shrink: {
-		priority: REDUCTION_STAGE.middleDot,
-		amountEm: .25,
-		granularity: "continuous"
-	}
-};
-/**
-* 表1 注5 with 表3 注3: a comma's half em plus the following middle dot's quarter.
-*
-* 表3 spends the quarter at stage 4 and the half at stage 5, which one capacity cannot say. Both are
-* reducible to solid, so the total is right and only the order collapses — and `、・` is rare enough
-* that the order never shows.
-*/
-const HALF_AND_QUARTER = {
-	kind: "glue",
-	naturalWidthEm: .75,
-	shrink: {
-		priority: REDUCTION_STAGE.punctuation,
-		amountEm: .75,
-		granularity: "continuous"
-	}
-};
-/**
-* 分離禁止文字 repeated (a 2倍ダッシュ, a 2倍リーダ) must read as one continuous rule (3.1.10).
-*/
-const DASH_JOINT = {
-	kind: "kern",
-	naturalWidthEm: 0
-};
-/**
-* 欧文間隔（cl-26）の三分アキ. JLReq states the western word space as a third em by rule rather than by
-* measurement, and makes it the first space a line adjustment reaches for: down to a 四分アキ when the
-* line is over (3.8.3 a), up to a 二分アキ when it is short (3.8.4 a).
-*
-* The two capacities are written as differences from the limits rather than as `1/12` and `1/6`,
-* because a third of an em is not representable in binary while the limits JLReq states are: this
-* way `naturalWidthEm - shrink.amountEm` is exactly 0.25 and `naturalWidthEm + stretch.amountEm`
-* exactly 0.5.
-*/
-const WORD_SPACE = {
-	kind: "glue",
-	naturalWidthEm: 1 / 3,
-	shrink: {
-		priority: REDUCTION_STAGE.wordSpace,
-		amountEm: 1 / 3 - 1 / 4,
-		granularity: "continuous"
-	},
-	stretch: {
-		priority: EXPANSION_STAGE.wordSpace,
-		amountEm: 1 / 2 - 1 / 3,
-		granularity: "continuous"
-	}
-};
-/**
-* 表1 注13 と 表3 注4: a word space at a line head or a line end has no width and is no adjustment
-* opportunity, since the white would fall outside the text area where no reader can see it. 注13
-* adds ただし，この部分が移動し，これとは異なる配置になった場合は，欧文間隔（cl-26）の空き量を確保する — which is why the answer is given per
-* candidate line and not once per source line.
-*/
-const EDGE_WORD_SPACE = {
-	kind: "glue",
-	naturalWidthEm: 0
-};
-/**
-* The classes that take a quarter em against a numeral, unit symbol or western character rotated 90
-* degrees or mixed into horizontal text (3.2.6) — an upright western character classifies as cl-19
-* and is covered by the general kanji rows and columns instead. Dividing punctuation is on the list
-* in that direction only, because the space before a `？` or `！` is solid (3.1.6).
-*/
-const JAPANESE_BEFORE_WESTERN = [
-	"cl-04",
-	"cl-09",
-	"cl-10",
-	"cl-11",
-	"cl-15",
-	"cl-16",
-	"cl-19",
-	"cl-30"
-];
-const JAPANESE_AFTER_WESTERN = [
-	"cl-09",
-	"cl-10",
-	"cl-11",
-	"cl-15",
-	"cl-16",
-	"cl-19",
-	"cl-30"
-];
-const NUMERAL_UNIT_OR_WESTERN = [
-	"cl-24",
-	"cl-25",
-	"cl-27"
-];
-const PUNCTUATION_TAKING_SPACE_AFTER = [
-	"cl-02",
-	"cl-06",
-	"cl-07"
-];
-/**
-* 表6 の色付きの小間: the classes a solid pair may be opened up between at stage 3. Neither list holds a
-* bracket, a middle dot, a full stop, a comma, a hyphen, an ideographic space or a word space —
-* JLReq opens none of those — and only the left-hand list holds a numeral, unit symbol or western
-* character, since the space on their Japanese side belongs to stage 2 instead.
-*/
-const EXPANDABLE_BEFORE = [
-	"cl-08",
-	"cl-09",
-	"cl-10",
-	"cl-11",
-	"cl-12",
-	"cl-13",
-	"cl-15",
-	"cl-16",
-	"cl-19",
-	"cl-24",
-	"cl-25",
-	"cl-27",
-	"cl-30"
-];
-const EXPANDABLE_AFTER = [
-	"cl-08",
-	"cl-09",
-	"cl-10",
-	"cl-11",
-	"cl-12",
-	"cl-13",
-	"cl-15",
-	"cl-16",
-	"cl-19",
-	"cl-30"
-];
-/**
-* The gray, blue and pink cells of 表6: all pairs that join the fourth and final expansion stage.
-* The finite capacities above cover the blue and pink cells at stages three and two; once those
-* stages are exhausted, JLReq 3.8.4 d adds the remainder equally across every cell named here.
-*
-* A cl-08/cl-08 cell is blue only when the two characters are different kinds of mark (注4). This
-* profile cannot distinguish the two halves of one 2倍ダッシュ from different marks, so it keeps the
-* pair joined, as it already does for the finite third stage.
-*/
-const FINAL_EXPANSION_BASIC_AFTER = /* @__PURE__ */ new Set([
-	"cl-01",
-	"cl-08",
-	"cl-12",
-	"cl-13",
-	"cl-14",
-	"cl-15",
-	"cl-16",
-	"cl-19",
-	"cl-24",
-	"cl-25",
-	"cl-26",
-	"cl-27",
-	"cl-30"
-]);
-const FINAL_EXPANSION_WIDE_AFTER = /* @__PURE__ */ new Set([
-	...FINAL_EXPANSION_BASIC_AFTER,
-	"cl-09",
-	"cl-10",
-	"cl-11"
-]);
-const FINAL_EXPANSION_AFTER = new Map([
-	...[
-		"cl-02",
-		"cl-03",
-		"cl-04",
-		"cl-05",
-		"cl-06",
-		"cl-07",
-		"cl-14"
-	].map((left) => [left, FINAL_EXPANSION_BASIC_AFTER]),
-	...[
-		"cl-09",
-		"cl-10",
-		"cl-11",
-		"cl-13",
-		"cl-15",
-		"cl-16",
-		"cl-19",
-		"cl-30"
-	].map((left) => [left, FINAL_EXPANSION_WIDE_AFTER]),
-	["cl-08", new Set([...FINAL_EXPANSION_WIDE_AFTER].filter((characterClass) => characterClass !== "cl-08"))],
-	["cl-12", /* @__PURE__ */ new Set([
-		"cl-08",
-		"cl-09",
-		"cl-10",
-		"cl-11",
-		"cl-12",
-		"cl-13",
-		"cl-15",
-		"cl-16",
-		"cl-19",
-		"cl-25",
-		"cl-26",
-		"cl-27",
-		"cl-30"
-	])],
-	["cl-24", /* @__PURE__ */ new Set([
-		"cl-01",
-		"cl-08",
-		"cl-09",
-		"cl-10",
-		"cl-11",
-		"cl-12",
-		"cl-14",
-		"cl-15",
-		"cl-16",
-		"cl-19",
-		"cl-25",
-		"cl-26",
-		"cl-30"
-	])],
-	["cl-25", /* @__PURE__ */ new Set([
-		"cl-01",
-		"cl-08",
-		"cl-09",
-		"cl-10",
-		"cl-11",
-		"cl-12",
-		"cl-13",
-		"cl-14",
-		"cl-15",
-		"cl-16",
-		"cl-19",
-		"cl-24",
-		"cl-26",
-		"cl-30"
-	])],
-	["cl-26", new Set(japaneseCharacterClasses.filter((characterClass) => characterClass !== "cl-02"))],
-	["cl-27", /* @__PURE__ */ new Set([
-		"cl-01",
-		"cl-08",
-		"cl-09",
-		"cl-10",
-		"cl-11",
-		"cl-12",
-		"cl-13",
-		"cl-14",
-		"cl-15",
-		"cl-16",
-		"cl-19",
-		"cl-26",
-		"cl-30"
-	])]
-]);
-function canExpandAtFinalStage(left, right) {
-	if (left === "cl-14" || left === "cl-26" || left === "cl-27" || right === "cl-14" || right === "cl-26" || right === "cl-27") return false;
-	if (FINAL_EXPANSION_AFTER.get(left)?.has(right) !== true) return false;
-	return pairSpacing(left, right).naturalWidthEm === 0;
-}
-/**
-* The classes JLReq 3.1.2 sets on a half em rather than a full one.
-*/
-const HALF_EM_CLASSES = /* @__PURE__ */ new Set([
-	"cl-01",
-	"cl-02",
-	"cl-05",
-	"cl-06",
-	"cl-07"
-]);
-const PAIR_SPACING_TABLE = new Map([
-	{
-		left: "any",
-		right: "any",
-		spacing: SOLID
-	},
-	{
-		left: EXPANDABLE_BEFORE,
-		right: EXPANDABLE_AFTER,
-		spacing: SOLID_EXPANDABLE
-	},
-	{
-		left: [
-			"cl-08",
-			"cl-12",
-			"cl-13"
-		],
-		right: NUMERAL_UNIT_OR_WESTERN,
-		spacing: SOLID_EXPANDABLE
-	},
-	{
-		left: ["cl-08"],
-		right: ["cl-24", "cl-25"],
-		spacing: SOLID
-	},
-	{
-		left: ["cl-12"],
-		right: ["cl-24"],
-		spacing: SOLID
-	},
-	{
-		left: ["cl-24"],
-		right: ["cl-13"],
-		spacing: SOLID
-	},
-	{
-		left: [
-			"cl-09",
-			"cl-10",
-			"cl-11"
-		],
-		right: ["cl-08"],
-		spacing: SOLID
-	},
-	{
-		left: "any",
-		right: ["cl-01"],
-		spacing: HALF
-	},
-	{
-		left: "any",
-		right: ["cl-05"],
-		spacing: QUARTER
-	},
-	{
-		left: "any",
-		right: PUNCTUATION_TAKING_SPACE_AFTER,
-		spacing: SOLID
-	},
-	{
-		left: JAPANESE_BEFORE_WESTERN,
-		right: NUMERAL_UNIT_OR_WESTERN,
-		spacing: MIXED_TEXT_QUARTER
-	},
-	{
-		left: NUMERAL_UNIT_OR_WESTERN,
-		right: JAPANESE_AFTER_WESTERN,
-		spacing: MIXED_TEXT_QUARTER
-	},
-	{
-		left: ["cl-25"],
-		right: ["cl-24"],
-		spacing: UNIT_SYMBOL_QUARTER
-	},
-	{
-		left: ["cl-27"],
-		right: ["cl-25"],
-		spacing: UNIT_SYMBOL_QUARTER
-	},
-	{
-		left: ["cl-24"],
-		right: ["cl-25"],
-		spacing: FIXED_QUARTER
-	},
-	{
-		left: ["cl-02", "cl-07"],
-		right: "any",
-		spacing: HALF
-	},
-	{
-		left: ["cl-06"],
-		right: "any",
-		spacing: FIXED_HALF
-	},
-	{
-		left: ["cl-02"],
-		right: ["cl-05"],
-		spacing: QUARTER
-	},
-	{
-		left: ["cl-06"],
-		right: ["cl-05"],
-		spacing: FIXED_HALF_AND_QUARTER
-	},
-	{
-		left: ["cl-07"],
-		right: ["cl-05"],
-		spacing: HALF_AND_QUARTER
-	},
-	{
-		left: PUNCTUATION_TAKING_SPACE_AFTER,
-		right: PUNCTUATION_TAKING_SPACE_AFTER,
-		spacing: SOLID
-	},
-	{
-		left: ["cl-02"],
-		right: ["cl-14"],
-		spacing: SOLID
-	},
-	{
-		left: ["cl-05"],
-		right: "any",
-		spacing: QUARTER
-	},
-	{
-		left: ["cl-05"],
-		right: ["cl-05"],
-		spacing: TWO_QUARTERS
-	},
-	{
-		left: ["cl-01"],
-		right: "any",
-		spacing: SOLID
-	},
-	{
-		left: ["cl-01"],
-		right: ["cl-05"],
-		spacing: QUARTER
-	},
-	{
-		left: ["cl-14"],
-		right: "any",
-		spacing: SOLID
-	},
-	{
-		left: ["cl-14"],
-		right: ["cl-05"],
-		spacing: QUARTER
-	},
-	{
-		left: "any",
-		right: ["cl-26"],
-		spacing: SOLID
-	},
-	{
-		left: PUNCTUATION_TAKING_SPACE_AFTER,
-		right: ["cl-26"],
-		spacing: FIXED_HALF
-	},
-	{
-		left: ["cl-05"],
-		right: ["cl-26"],
-		spacing: FIXED_QUARTER
-	},
-	{
-		left: ["cl-26"],
-		right: "any",
-		spacing: SOLID
-	},
-	{
-		left: ["cl-26"],
-		right: ["cl-01"],
-		spacing: FIXED_HALF
-	},
-	{
-		left: ["cl-26"],
-		right: ["cl-05"],
-		spacing: FIXED_QUARTER
-	},
-	{
-		left: ["cl-08"],
-		right: ["cl-08"],
-		spacing: DASH_JOINT
-	}
-].flatMap(({ left, right, spacing }) => (left === "any" ? japaneseCharacterClasses : left).flatMap((leftClass) => (right === "any" ? japaneseCharacterClasses : right).map((rightClass) => [`${leftClass}/${rightClass}`, spacing]))));
-function pairSpacing(left, right) {
-	return PAIR_SPACING_TABLE.get(`${left}/${right}`) ?? SOLID;
-}
-/**
-* `null` removes the break opportunity outright rather than pricing it, because the three rules
-* below are prohibitions and not preferences.
-*
-* Line-end prohibition (行末禁則, JLReq 3.1.8): an opening bracket or a prefixed abbreviation may not
-* be the last character on a line, since it belongs to what follows it.
-*
-* Line-start prohibition (行頭禁則, JLReq 3.1.7): closing brackets, hyphens, dividing punctuation,
-* middle dots, full stops, commas, iteration marks, the prolonged sound mark, small kana and
-* postfixed abbreviations may not open a line.
-*
-* Unbreakable sequences (分割禁止, JLReq 3.1.10): a 分離禁止文字 followed by another one is a single mark set
-* over two ems and must not be split.
-*/
-function breakPenalty(left, right) {
-	if (left === "cl-01" || left === "cl-12") return null;
-	if (right === "cl-02" || right === "cl-03" || right === "cl-04" || right === "cl-05" || right === "cl-06" || right === "cl-07" || right === "cl-09" || right === "cl-10" || right === "cl-11" || right === "cl-13") return null;
-	if (left === "cl-08" && right === "cl-08") return null;
-	return 0;
-}
-const defaultJapaneseTypesettingProfile = {
-	classify,
-	/**
-	* Opening and closing brackets, full stops, commas and middle dots are set on a half em (JLReq
-	* 3.1.2); the space the pair table puts around them is what brings each back to a full em.
-	*
-	* A fullwidth glyph keeps drawing its ink where the font put it, so halving the advance alone
-	* would leave the ink outside the box. The offset pulls it back: an opening bracket draws in the
-	* trailing half of its em, a middle dot in the centre, and the rest in the leading half.
-	*/
-	boxMetrics: (characterClass, measuredAdvanceEm) => {
-		if (characterClass === "cl-26") return {
-			advanceEm: 0,
-			renderOffsetEm: 0
-		};
-		const advanceEm = HALF_EM_CLASSES.has(characterClass) ? Math.min(.5, measuredAdvanceEm) : measuredAdvanceEm;
-		const inkOverhangEm = measuredAdvanceEm - advanceEm;
-		return {
-			advanceEm,
-			renderOffsetEm: characterClass === "cl-01" ? -inkOverhangEm : characterClass === "cl-05" ? -inkOverhangEm / 2 : 0
-		};
-	},
-	pairSpacing,
-	spacingCharacter: (characterClass, position) => characterClass !== "cl-26" ? null : position === "mid-line" ? WORD_SPACE : EDGE_WORD_SPACE,
-	/**
-	* The white before an opening bracket at a line head. JLReq 3.1.5 pairs 改行行頭 with 折返し行頭 and lists
-	* three schemes for the two together: ① 全角アキ and 天付き, ② 全角半アキ and 二分アキ, ③ 二分アキ and 天付き. This
-	* profile takes ③, the scheme 講談社, 新潮社, 文藝春秋, 中央公論新社 and 筑摩書房 set novels with; ① is what JIS X
-	* 4051 and 岩波書店 use. A line of dialogue therefore starts one half em in when it opens a
-	* paragraph, and flush against the edge when the composer turned it over.
-	*
-	* The white is not shrinkable. 表3 excludes the line head from line adjustment altogether, and
-	* shrinking it is exactly what pushed a line-head bracket flush against the edge in #94.
-	*/
-	lineStartSpacing: (first, lineHead) => first === "cl-01" && lineHead === "paragraph-start" ? {
-		kind: "glue",
-		naturalWidthEm: .5
-	} : null,
-	/**
-	* The half em trailing a closing bracket, full stop or comma at the line end, and the quarter em
-	* trailing a middle dot there (JLReq 3.1.9). Priority 0: spending it changes nothing the reader
-	* can see.
-	*
-	* Both are all-or-nothing. 3.1.9 admits the full アキ or ベタ組 and forbids anything in between, so a
-	* line whose overflow is smaller than the アキ has to find the difference somewhere else — or break
-	* elsewhere. A line-end middle dot takes the quarter before it into the same amount (表3 注5).
-	*/
-	lineEndSpacing: (last) => last === "cl-02" || last === "cl-06" || last === "cl-07" ? {
-		spacing: {
-			kind: "glue",
-			naturalWidthEm: .5,
-			shrink: {
-				priority: REDUCTION_STAGE.lineEnd,
-				amountEm: .5,
-				granularity: "all-or-nothing"
-			}
-		},
-		absorbsPrecedingEm: 0
-	} : last === "cl-05" ? {
-		spacing: {
-			kind: "glue",
-			naturalWidthEm: .25,
-			shrink: {
-				priority: REDUCTION_STAGE.lineEnd,
-				amountEm: .25,
-				granularity: "all-or-nothing"
-			}
-		},
-		absorbsPrecedingEm: .25
-	} : null,
-	finalStretchPriority: EXPANSION_STAGE.final,
-	canExpandAtFinalStage,
-	breakPenalty,
-	/**
-	* Hanging punctuation (ぶら下げ組, JLReq 3.8.2) lets a full stop or comma sit outside the text area
-	* instead of forcing the line to be respaced. JLReq admits no other class for it.
-	*/
-	canHang: (characterClass) => characterClass === "cl-07" || characterClass === "cl-06"
-};
-//#endregion
-//#region src/composer/internal/paragraph-layout.ts
-const EPSILON = 1e-9;
-/**
-* Spending capacity at this priority changes nothing the reader can see.
-*/
-const FREE_SHRINK_PRIORITY = 0;
-/**
-* Interleave the two kinds onto one number so the allocator can key a plain `Map` without building
-* a string per boundary — this runs once per adjustment unit of every candidate line.
-*/
-function slotKey(slot) {
-	return slot.kind === "gap" ? slot.boundary * 2 : slot.index * 2 + 1;
-}
-function skipSourceGaps(atoms, start) {
-	let cursor = start;
-	while (atoms[cursor]?.sourceGap === true) cursor += 1;
-	return cursor;
-}
-function previousVisible(atoms, end) {
-	for (let index = end - 1; index >= 0; index -= 1) if (atoms[index]?.sourceGap === false) return index;
-}
-/**
-* Whether a shorter line ending somewhere inside `(contentStart, end)` was ever an option — checked
-* as a plain short-circuiting scan rather than building the boundary list first, since this runs
-* once per over-long candidate the optimizer considers.
-*/
-function hasEarlierBoundary(boundaryAllowed, contentStart, end) {
-	for (let boundary = contentStart + 1; boundary < end; boundary += 1) if (boundaryAllowed(boundary - 1, boundary)) return true;
-	return false;
-}
-function opportunities(atoms, classes, start, end, profile, lineHead) {
-	const result = [];
-	const firstClass = classes[start];
-	const startSpacing = firstClass === void 0 ? null : profile.lineStartSpacing(firstClass, lineHead);
-	if (startSpacing !== null) result.push({
-		slot: {
-			kind: "gap",
-			boundary: start
-		},
-		spacing: startSpacing,
-		finalStretch: false,
-		absorbsPrecedingEm: 0
-	});
-	for (let index = start; index < end; index += 1) {
-		const characterClass = classes[index];
-		if (characterClass === void 0 || atoms[index]?.sourceGap === true) continue;
-		const spacing = profile.spacingCharacter(characterClass, index === start || index === end - 1 ? "line-edge" : "mid-line");
-		if (spacing !== null) result.push({
-			slot: {
-				kind: "character",
-				index
-			},
-			spacing,
-			finalStretch: false,
-			absorbsPrecedingEm: 0
-		});
-	}
-	for (let right = start + 1; right < end; right += 1) {
-		const leftAtom = atoms[right - 1];
-		const rightAtom = atoms[right];
-		const leftClass = classes[right - 1];
-		const rightClass = classes[right];
-		if (leftAtom === void 0 || rightAtom === void 0 || leftClass === void 0 || rightClass === void 0 || leftAtom.sourceGap || rightAtom.sourceGap || !leftAtom.pairSpacingAfter) continue;
-		result.push({
-			slot: {
-				kind: "gap",
-				boundary: right
-			},
-			spacing: profile.pairSpacing(leftClass, rightClass),
-			finalStretch: profile.canExpandAtFinalStage(leftClass, rightClass),
-			absorbsPrecedingEm: 0
-		});
-	}
-	const lastClass = classes[end - 1];
-	const endSpacing = lastClass === void 0 ? null : profile.lineEndSpacing(lastClass);
-	if (endSpacing !== null) result.push({
-		slot: {
-			kind: "gap",
-			boundary: end
-		},
-		spacing: endSpacing.spacing,
-		finalStretch: false,
-		absorbsPrecedingEm: endSpacing.absorbsPrecedingEm
-	});
-	return result;
-}
-/**
-* Break the line's spaces into the indivisible amounts the line adjustment may spend.
-*
-* A line end the profile says absorbs the space before it claims that much of the preceding
-* boundary's capacity, and the two become one unit at the line-end stage — JLReq 3.8.3's third
-* stage, which is free. Whatever the preceding boundary has left over stays an opportunity of its
-* own stage, so the half em of a `、` before a line-end `・` is still spent where 3.8.3 puts it.
-*/
-function adjustmentUnits(values, adjustment) {
-	const select = (spacing) => adjustment === "shrink" ? spacing.shrink : spacing.stretch;
-	const units = [];
-	const straddle = values.find(({ absorbsPrecedingEm }) => absorbsPrecedingEm > 0);
-	let absorbedBoundary;
-	let absorbedEm = 0;
-	let absorbingBoundary;
-	const straddleSlot = straddle?.slot.kind === "gap" ? straddle.slot : void 0;
-	const straddleOwn = straddle === void 0 ? void 0 : select(straddle.spacing);
-	if (straddle !== void 0 && straddleSlot !== void 0 && straddleOwn !== void 0) {
-		const precedingBoundary = straddleSlot.boundary - 1;
-		const preceding = values.find(({ slot }) => slot.kind === "gap" && slot.boundary === precedingBoundary);
-		const availableEm = preceding === void 0 ? 0 : select(preceding.spacing)?.amountEm ?? 0;
-		absorbingBoundary = straddleSlot.boundary;
-		if (availableEm + EPSILON >= straddle.absorbsPrecedingEm) {
-			absorbedBoundary = precedingBoundary;
-			absorbedEm = straddle.absorbsPrecedingEm;
-			units.push({
-				parts: [{
-					slot: {
-						kind: "gap",
-						boundary: precedingBoundary
-					},
-					amountEm: absorbedEm
-				}, {
-					slot: straddleSlot,
-					amountEm: straddleOwn.amountEm
-				}],
-				priority: straddleOwn.priority,
-				amountEm: absorbedEm + straddleOwn.amountEm,
-				granularity: straddleOwn.granularity
-			});
-		}
-	}
-	for (const { slot, spacing } of values) {
-		if (slot.kind === "gap" && slot.boundary === absorbingBoundary) continue;
-		const own = select(spacing);
-		if (own === void 0) continue;
-		const claimedEm = slot.kind === "gap" && slot.boundary === absorbedBoundary ? absorbedEm : 0;
-		const amountEm = own.amountEm - claimedEm;
-		if (amountEm <= EPSILON) continue;
-		units.push({
-			parts: [{
-				slot,
-				amountEm
-			}],
-			priority: own.priority,
-			amountEm,
-			granularity: own.granularity
-		});
-	}
-	return units;
-}
-/**
-* Spend `amountEm` over the line's units of adjustment, stage by stage.
-*
-* Every stage of JLReq 3.8.3 and 3.8.4 is stated as 文字サイズ比で均等に — the English text of 3.8.3 a puts
-* it as "The same width reduction is applied to all spaces on the target line at the same time."
-* Within a stage the amount is therefore split in proportion to what each space can give, rather
-* than taken out of the earliest space until it runs dry. Across stages the order stays a
-* waterfall: a later stage is reached only once every stage before it is spent out. The composer
-* sets one character size, so a share of the stage's capacity is a share by character size. JLReq
-* 3.8.4's final stage has no upper bound: after the finite stages are full, the unresolved
-* remainder is added equally to every pair the profile admits, including the earlier-stage pairs.
-*
-* An all-or-nothing unit larger than what is still needed is skipped rather than partly spent, and
-* never revisited: `remaining` only falls, so a unit that did not fit at its own stage cannot fit
-* at a later one. One forward pass is therefore exact and no search over subsets is needed.
-*/
-function resolveSpacings(values, units, adjustment, amountEm, finalStretchPriority) {
-	const usedBySlot = /* @__PURE__ */ new Map();
-	let remaining = amountEm;
-	let priorityCost = 0;
-	let freeEm = 0;
-	let finalStretchPerSlotEm = 0;
-	const spend = (unit, fraction) => {
-		for (const { slot, amountEm: partEm } of unit.parts) {
-			const key = slotKey(slot);
-			usedBySlot.set(key, (usedBySlot.get(key) ?? 0) + partEm * fraction);
-		}
-		const spentEm = unit.amountEm * fraction;
-		priorityCost += spentEm * unit.priority;
-		if (unit.priority === FREE_SHRINK_PRIORITY) freeEm += spentEm;
-		remaining -= spentEm;
-	};
-	const stages = /* @__PURE__ */ new Map();
-	for (const unit of units) {
-		const stage = stages.get(unit.priority);
-		if (stage === void 0) stages.set(unit.priority, [unit]);
-		else stage.push(unit);
-	}
-	for (const priority of [...stages.keys()].sort((left, right) => left - right)) {
-		if (remaining <= EPSILON) break;
-		const stage = stages.get(priority) ?? [];
-		let stageCapacityEm = 0;
-		for (const unit of stage) if (unit.granularity === "continuous") stageCapacityEm += unit.amountEm;
-		else if (unit.amountEm <= remaining + EPSILON) spend(unit, 1);
-		if (stageCapacityEm <= EPSILON || remaining <= EPSILON) continue;
-		const fraction = Math.min(remaining, stageCapacityEm) / stageCapacityEm;
-		for (const unit of stage) if (unit.granularity === "continuous") spend(unit, fraction);
-	}
-	if (adjustment === "stretch" && remaining > EPSILON) {
-		let finalSlotCount = 0;
-		for (const { finalStretch } of values) if (finalStretch) finalSlotCount += 1;
-		if (finalSlotCount > 0) {
-			finalStretchPerSlotEm = remaining / finalSlotCount;
-			for (const { slot, finalStretch } of values) {
-				if (!finalStretch) continue;
-				const key = slotKey(slot);
-				usedBySlot.set(key, (usedBySlot.get(key) ?? 0) + finalStretchPerSlotEm);
-			}
-			priorityCost += remaining * finalStretchPriority;
-			remaining = 0;
-		}
-	}
-	return {
-		spacings: splitBySlot(values, (slot, spacing) => {
-			const used = usedBySlot.get(slotKey(slot)) ?? 0;
-			return adjustment === "shrink" ? spacing.naturalWidthEm - used : spacing.naturalWidthEm + used;
-		}),
-		priorityCost,
-		freeEm,
-		finalStretchPerSlotEm,
-		unabsorbedEm: Math.max(0, remaining)
-	};
-}
-function splitBySlot(values, widthOf) {
-	const pairSpacings = [];
-	const characterSpacings = [];
-	for (const { slot, spacing } of values) {
-		const resolved = {
-			kind: spacing.kind,
-			naturalWidthEm: spacing.naturalWidthEm,
-			widthEm: widthOf(slot, spacing)
-		};
-		if (slot.kind === "gap") pairSpacings.push({
-			boundary: slot.boundary,
-			...resolved
-		});
-		else characterSpacings.push({
-			index: slot.index,
-			...resolved
-		});
-	}
-	return {
-		pairSpacings,
-		characterSpacings
-	};
-}
-/**
-* The same spaces at the width the profile gives them, for a line no adjustment reaches.
-*/
-function naturalSpacings(values) {
-	return splitBySlot(values, (_slot, spacing) => spacing.naturalWidthEm);
-}
-/**
-* The same, minus the アキ the line end would have taken: a hanging character sits outside the text
-* area and the space that would have followed it goes with it.
-*/
-function hangingSpacings(values, end) {
-	const { pairSpacings, characterSpacings } = naturalSpacings(values);
-	return {
-		pairSpacings: pairSpacings.filter(({ boundary }) => boundary !== end),
-		characterSpacings
-	};
-}
-function candidate(atoms, classes, boxPrefixEm, start, end, lineLengthEm, profile) {
-	const contentStart = skipSourceGaps(atoms, start);
-	const suppressedIndexes = Array.from({ length: contentStart - start }, (_, index) => start + index);
-	const pairValues = opportunities(atoms, classes, contentStart, end, profile, start === 0 ? "paragraph-start" : "turned-over");
-	const naturalSizeEm = (boxPrefixEm[end] ?? 0) - (boxPrefixEm[contentStart] ?? 0) + pairValues.reduce((total, value) => total + value.spacing.naturalWidthEm, 0);
-	const terminal = skipSourceGaps(atoms, end) === atoms.length;
-	const overflow = naturalSizeEm - lineLengthEm;
-	const underflow = lineLengthEm - naturalSizeEm;
-	const units = adjustmentUnits(pairValues, overflow > 0 ? "shrink" : "stretch");
-	const capacity = units.reduce((total, { amountEm }) => total + amountEm, 0);
-	const freeShrinkCapacity = units.reduce((total, { priority, amountEm }) => total + (priority === FREE_SHRINK_PRIORITY ? amountEm : 0), 0);
-	const lastVisible = previousVisible(atoms, end);
-	const lastClass = lastVisible === void 0 ? void 0 : classes[lastVisible];
-	const lastAdvance = lastVisible === void 0 ? 0 : atoms[lastVisible]?.boxAdvanceEm ?? 0;
-	const trailingSpacing = pairValues.find(({ slot }) => slot.kind === "gap" && slot.boundary === end)?.spacing.naturalWidthEm ?? 0;
-	const hasFinalStretch = pairValues.some(({ finalStretch }) => finalStretch);
-	if (terminal && overflow <= EPSILON) return {
-		start,
-		contentStart,
-		end,
-		suppressedIndexes,
-		...naturalSpacings(pairValues),
-		inlineSizeEm: naturalSizeEm,
-		break: { kind: "paragraph-end" },
-		hangingIndex: null,
-		deformationRatio: 0,
-		priorityCost: 0
-	};
-	if (Math.abs(overflow) <= EPSILON) return {
-		start,
-		contentStart,
-		end,
-		suppressedIndexes,
-		...naturalSpacings(pairValues),
-		inlineSizeEm: naturalSizeEm,
-		break: { kind: "natural" },
-		hangingIndex: null,
-		deformationRatio: 0,
-		priorityCost: 0
-	};
-	const shrunk = overflow > 0 && overflow <= capacity + EPSILON ? resolveSpacings(pairValues, units, "shrink", overflow, profile.finalStretchPriority) : null;
-	if (shrunk !== null && shrunk.unabsorbedEm <= EPSILON) {
-		const chargeableCapacity = capacity - freeShrinkCapacity;
-		const chargeableShrink = Math.max(0, overflow - shrunk.freeEm);
-		return {
-			start,
-			contentStart,
-			end,
-			suppressedIndexes,
-			...shrunk.spacings,
-			inlineSizeEm: lineLengthEm,
-			break: { kind: "shrunk" },
-			hangingIndex: null,
-			deformationRatio: chargeableCapacity <= EPSILON ? 0 : chargeableShrink / chargeableCapacity,
-			priorityCost: shrunk.priorityCost
-		};
-	}
-	if (!terminal && overflow > 0 && lastVisible !== void 0 && lastClass !== void 0 && profile.canHang(lastClass) && naturalSizeEm - lastAdvance - trailingSpacing <= lineLengthEm + EPSILON) return {
-		start,
-		contentStart,
-		end,
-		suppressedIndexes,
-		...hangingSpacings(pairValues, end),
-		inlineSizeEm: naturalSizeEm - lastAdvance - trailingSpacing,
-		break: { kind: "hanging" },
-		hangingIndex: lastVisible,
-		deformationRatio: overflow / Math.max(lastAdvance, EPSILON),
-		priorityCost: 0
-	};
-	const stretched = !terminal && underflow > EPSILON && (underflow <= capacity + EPSILON || hasFinalStretch) ? resolveSpacings(pairValues, units, "stretch", underflow, profile.finalStretchPriority) : null;
-	if (stretched !== null && stretched.unabsorbedEm <= EPSILON) return {
-		start,
-		contentStart,
-		end,
-		suppressedIndexes,
-		...stretched.spacings,
-		inlineSizeEm: lineLengthEm,
-		break: { kind: "stretched" },
-		hangingIndex: null,
-		deformationRatio: stretched.finalStretchPerSlotEm > 0 ? 1 + stretched.finalStretchPerSlotEm : capacity === 0 ? 0 : underflow / capacity,
-		priorityCost: stretched.priorityCost
-	};
-	return {
-		start,
-		contentStart,
-		end,
-		suppressedIndexes,
-		...naturalSpacings(pairValues),
-		inlineSizeEm: naturalSizeEm,
-		break: { kind: "forced" },
-		hangingIndex: null,
-		deformationRatio: Math.abs(naturalSizeEm - lineLengthEm) / Math.max(lineLengthEm, EPSILON),
-		priorityCost: 0
-	};
-}
-function scoreFor(line, previousFitness) {
-	const mode = line.break.kind;
-	const fitness = Math.min(3, Math.floor(line.deformationRatio * 4));
-	const transition = Math.abs(previousFitness - fitness) > 1 ? 1 : 0;
-	const modeCounts = {
-		forced: mode === "forced" ? 1 : 0,
-		stretched: mode === "stretched" ? 1 : 0,
-		hanging: mode === "hanging" ? 1 : 0,
-		shrunk: mode === "shrunk" && line.priorityCost > EPSILON ? 1 : 0
-	};
-	return {
-		score: [
-			modeCounts.forced,
-			modeCounts.stretched,
-			modeCounts.hanging,
-			modeCounts.shrunk,
-			line.priorityCost,
-			line.deformationRatio ** 3,
-			transition
-		],
-		fitness
-	};
-}
-function addScore(left, right) {
-	return [
-		left[0] + right[0],
-		left[1] + right[1],
-		left[2] + right[2],
-		left[3] + right[3],
-		left[4] + right[4],
-		left[5] + right[5],
-		left[6] + right[6]
-	];
-}
-/**
-* The line-end offsets a state's path took, earliest first. Rebuilt on demand by walking `previous`
-* rather than carried on every `State`: every candidate line attempted would otherwise pay for a
-* copy of its whole path, when `isBetter` only ever reads it on the exact-score tie this comparison
-* breaks — for `boundaryAllowed` predicates permissive enough to fully saturate the optimizer's
-* search window, ties are rare enough that this deferred cost is negligible.
-*/
-function breaksOf(state, states) {
-	const result = [];
-	let cursor = state;
-	while (cursor?.line !== null && cursor?.line !== void 0) {
-		result.push(cursor.line.end);
-		cursor = cursor.previous === null ? void 0 : states.get(cursor.previous.index)?.get(cursor.previous.fitness);
-	}
-	return result.reverse();
-}
-function compareBreaks(left, right) {
-	const length = Math.min(left.length, right.length);
-	for (let index = 0; index < length; index += 1) {
-		const difference = (right[index] ?? 0) - (left[index] ?? 0);
-		if (difference !== 0) return difference;
-	}
-	return left.length - right.length;
-}
-function isBetter(candidateState, current, states) {
-	if (current === void 0) return true;
-	for (let index = 0; index < candidateState.score.length; index += 1) {
-		const difference = (candidateState.score[index] ?? 0) - (current.score[index] ?? 0);
-		if (Math.abs(difference) > EPSILON) return difference < 0;
-	}
-	return compareBreaks(breaksOf(candidateState, states), breaksOf(current, states)) < 0;
-}
-function layoutParagraph(atoms, lineLengthEm, profile, boundaryAllowed) {
-	if (atoms.length === 0) return [];
-	const classes = atoms.map(({ characterClass }) => characterClass);
-	const boxPrefixEm = Array.from({ length: atoms.length + 1 }).fill(0);
-	for (let index = 0; index < atoms.length; index += 1) boxPrefixEm[index + 1] = (boxPrefixEm[index] ?? 0) + (atoms[index]?.boxAdvanceEm ?? 0);
-	const states = /* @__PURE__ */ new Map([[0, /* @__PURE__ */ new Map([[0, {
-		score: [
-			0,
-			0,
-			0,
-			0,
-			0,
-			0,
-			0
-		],
-		fitness: 0,
-		previous: null,
-		line: null
-	}]])]]);
-	for (let start = 0; start < atoms.length; start += 1) {
-		const activeStates = states.get(start);
-		if (activeStates === void 0) continue;
-		const contentStart = skipSourceGaps(atoms, start);
-		if (contentStart === atoms.length) {
-			const terminalStates = states.get(atoms.length) ?? /* @__PURE__ */ new Map();
-			for (const state of activeStates.values()) if (isBetter(state, terminalStates.get(state.fitness), states)) terminalStates.set(state.fitness, state);
-			states.set(atoms.length, terminalStates);
-			continue;
-		}
-		for (const state of activeStates.values()) for (let end = contentStart + 1; end <= atoms.length; end += 1) {
-			const right = skipSourceGaps(atoms, end);
-			const left = previousVisible(atoms, end);
-			if (atoms[end - 1]?.sourceGap === true) continue;
-			if (end < atoms.length && right < atoms.length && (left === void 0 || !boundaryAllowed(left, right))) continue;
-			const line = candidate(atoms, classes, boxPrefixEm, start, end, lineLengthEm, profile);
-			if (line.break.kind === "forced" && line.inlineSizeEm > lineLengthEm + EPSILON && hasEarlierBoundary(boundaryAllowed, contentStart, end)) {
-				if (line.inlineSizeEm > lineLengthEm * 2 && end > contentStart + 1) break;
-				continue;
-			}
-			const lineScore = scoreFor(line, state.fitness);
-			const nextState = {
-				score: addScore(state.score, lineScore.score),
-				fitness: lineScore.fitness,
-				previous: {
-					index: start,
-					fitness: state.fitness
-				},
-				line
-			};
-			const statesAtEnd = states.get(end) ?? /* @__PURE__ */ new Map();
-			if (isBetter(nextState, statesAtEnd.get(nextState.fitness), states)) {
-				statesAtEnd.set(nextState.fitness, nextState);
-				states.set(end, statesAtEnd);
-			}
-			if (line.inlineSizeEm > lineLengthEm * 2 && line.break.kind === "forced" && end > contentStart + 1) break;
-		}
-	}
-	const terminal = [...states.get(atoms.length)?.values() ?? []].reduce((best, state) => isBetter(state, best, states) ? state : best, void 0);
-	if (terminal === void 0) return [];
-	const lines = [];
-	let cursor = terminal;
-	while (cursor?.line !== null && cursor?.line !== void 0) {
-		lines.push(cursor.line);
-		cursor = cursor.previous === null ? void 0 : states.get(cursor.previous.index)?.get(cursor.previous.fitness);
-	}
-	lines.reverse();
-	const last = lines.at(-1);
-	if (last !== void 0 && last.end < atoms.length) lines[lines.length - 1] = {
-		...last,
-		suppressedIndexes: [...last.suppressedIndexes, ...Array.from({ length: atoms.length - last.end }, (_, index) => last.end + index)]
-	};
-	return lines;
-}
-//#endregion
-//#region src/appearance/paper-size.ts
-const PAPER_SIZES = {
-	a4: {
-		id: "a4",
-		label: "A4",
-		widthMm: 210,
-		heightMm: 297
-	},
-	a5: {
-		id: "a5",
-		label: "A5",
-		widthMm: 148,
-		heightMm: 210
-	},
-	a6: {
-		id: "a6",
-		label: "A6（文庫）",
-		widthMm: 105,
-		heightMm: 148
-	},
-	"jis-b5": {
-		id: "jis-b5",
-		label: "B5（JIS）",
-		widthMm: 182,
-		heightMm: 257
-	},
-	"jis-b6": {
-		id: "jis-b6",
-		label: "B6（JIS）",
-		widthMm: 128,
-		heightMm: 182
-	},
-	shinsho: {
-		id: "shinsho",
-		label: "新書",
-		widthMm: 106,
-		heightMm: 173
-	}
-};
-const PaperSize = {
-	of: (id) => PAPER_SIZES[id],
-	all: Object.values(PAPER_SIZES)
-};
-//#endregion
-//#region src/internal/length.ts
-const PT_PER_MM = 72 / 25.4;
-function ptToMm(pt) {
-	return pt / PT_PER_MM;
-}
-function mmToPt(mm) {
-	return mm * PT_PER_MM;
-}
-//#endregion
-//#region src/composer/manuscript-geometry.ts
-const STAGE_GAP_CELLS = 2;
-const LINE_GAP_CELLS = .5;
-const nonNegativeLength = () => v.pipe(v.number(), v.finite(), v.minValue(0));
-const ManuscriptGeometrySchema = readonlyObject({
-	paperWidthMm: nonNegativeLength(),
-	paperHeightMm: nonNegativeLength(),
-	cellSizeMm: nonNegativeLength(),
-	lineGapMm: nonNegativeLength(),
-	fontSizePt: FontSizePt.schema,
-	contentWidthMm: nonNegativeLength(),
-	contentHeightMm: nonNegativeLength(),
-	marginInlineMm: v.pipe(v.number(), v.finite()),
-	marginBlockMm: v.pipe(v.number(), v.finite()),
-	fitsPaper: v.boolean()
-});
-/**
-* Every stage stacked vertically, plus the gap between adjacent stages.
-*/
-function contentHeightInEm(flow) {
-	return flow.stagesPerPage * flow.lineLengthEm + STAGE_GAP_CELLS * (flow.stagesPerPage - 1);
-}
-/**
-* Every vertical line side by side, plus the gap between adjacent lines.
-*/
-function contentWidthInEm(flow) {
-	return flow.linesPerStage + LINE_GAP_CELLS * (flow.linesPerStage - 1);
-}
-const ManuscriptGeometry = {
-	schema: ManuscriptGeometrySchema,
-	of: (flow, appearance) => {
-		const paper = PaperSize.of(appearance.paperSize);
-		const cellSizeMm = ptToMm(appearance.fontSizePt);
-		const contentWidthMm = contentWidthInEm(flow) * cellSizeMm;
-		const contentHeightMm = contentHeightInEm(flow) * cellSizeMm;
-		const marginInlineMm = (paper.widthMm - contentWidthMm) / 2;
-		const marginBlockMm = (paper.heightMm - contentHeightMm) / 2;
-		return {
-			paperWidthMm: paper.widthMm,
-			paperHeightMm: paper.heightMm,
-			cellSizeMm,
-			lineGapMm: LINE_GAP_CELLS * cellSizeMm,
-			fontSizePt: appearance.fontSizePt,
-			contentWidthMm,
-			contentHeightMm,
-			marginInlineMm,
-			marginBlockMm,
-			fitsPaper: marginInlineMm >= 0 && marginBlockMm >= 0
-		};
-	},
-	/**
-	* The largest step-aligned point size whose text area still fits the paper.
-	*/
-	maxFontSizePt: (flow, paperSizeId) => {
-		const paper = PaperSize.of(paperSizeId);
-		const maxCellSizeMm = Math.min(paper.widthMm / contentWidthInEm(flow), paper.heightMm / contentHeightInEm(flow));
-		const steps = Math.floor(mmToPt(maxCellSizeMm) / FontSizePt.range.step + 1e-9);
-		const aligned = Math.round(steps * FontSizePt.range.step * 1e3) / 1e3;
-		return Math.min(FontSizePt.range.max, Math.max(FontSizePt.range.min, aligned));
-	}
-};
-const CompositionStatistics = { schema: readonlyObject({
-	chars: nonNegativeInteger(),
-	sourceLines: nonNegativeInteger(),
-	pages: nonNegativeInteger()
-}) };
-//#endregion
-//#region src/composer/composed-annotation-fragment.ts
-const emLength = () => v.pipe(v.number(), v.finite(), v.minValue(0));
-const continuation = v.union([
-	v.literal("whole"),
-	v.literal("start"),
-	v.literal("middle"),
-	v.literal("end")
-]);
-const PositionedReadingGraphemeSchema = readonlyObject({
-	value: v.string(),
-	offsetEm: v.pipe(v.number(), v.finite()),
-	advanceEm: emLength()
-});
-const common$1 = {
-	annotationRange: ManuscriptRange.schema,
-	fragmentRange: ManuscriptRange.schema,
-	continuation
-};
-const ComposedAnnotationFragment = { schema: v.variant("kind", [
-	readonlyObject({
-		kind: v.literal("bold"),
-		...common$1
-	}),
-	readonlyObject({
-		kind: v.literal("italic"),
-		...common$1
-	}),
-	readonlyObject({
-		kind: v.literal("emphasis"),
-		mark: v.string(),
-		...common$1
-	}),
-	readonlyObject({
-		kind: v.literal("ruby"),
-		rubyKind: RubyKind.schema,
-		reading: v.string(),
-		baseOffsetEm: emLength(),
-		baseAdvanceEm: emLength(),
-		readingGraphemes: readonlyArray(PositionedReadingGraphemeSchema),
-		...common$1
-	})
-]) };
-const InlineSpan = { schema: readonlyObject({
-	offsetEm: v.pipe(v.number(), v.finite()),
-	advanceEm: v.pipe(v.number(), v.finite(), v.minValue(0))
-}) };
-//#endregion
-//#region src/composer/vertical-text-presentation.ts
-const common = { groupRange: ManuscriptRange.schema };
-const VerticalTextPresentation = { schema: v.variant("kind", [
-	readonlyObject({
-		kind: v.literal("mixed"),
-		...common
-	}),
-	readonlyObject({
-		kind: v.literal("upright"),
-		...common
-	}),
-	readonlyObject({
-		kind: v.literal("sideways"),
-		...common
-	}),
-	readonlyObject({
-		kind: v.literal("tate-chu-yoko"),
-		...common
-	})
-]) };
-//#endregion
-//#region src/composer/composed-inline-item.ts
-const signedEm = () => v.pipe(v.number(), v.finite());
-const GlyphItemSchema = readonlyObject({
-	kind: v.literal("glyph"),
-	value: v.string(),
-	range: ManuscriptRange.schema,
-	layoutSpan: InlineSpan.schema,
-	renderSpan: InlineSpan.schema,
-	disposition: v.union([v.literal("placed"), v.literal("hanging")]),
-	presentation: VerticalTextPresentation.schema
-});
-const GeneratedGlueItemSchema = readonlyObject({
-	kind: v.literal("glue"),
-	origin: v.literal("generated"),
-	offsetEm: signedEm(),
-	widthEm: signedEm(),
-	naturalWidthEm: signedEm(),
-	adjustment: v.union([
-		v.literal("natural"),
-		v.literal("shrunk"),
-		v.literal("stretched")
-	])
-});
-const SourceGlueItemSchema = readonlyObject({
-	kind: v.literal("glue"),
-	origin: v.literal("source"),
-	value: v.string(),
-	range: ManuscriptRange.schema,
-	offsetEm: signedEm(),
-	widthEm: signedEm(),
-	naturalWidthEm: signedEm(),
-	adjustment: v.union([
-		v.literal("natural"),
-		v.literal("shrunk"),
-		v.literal("stretched")
-	])
-});
-const KernItemSchema = readonlyObject({
-	kind: v.literal("kern"),
-	offsetEm: signedEm(),
-	widthEm: signedEm()
-});
-const SuppressedItemSchema = readonlyObject({
-	kind: v.literal("suppressed"),
-	value: v.string(),
-	range: ManuscriptRange.schema,
-	reason: v.literal("question-or-exclamation-gap")
-});
-const ComposedInlineItem = { schema: v.union([
-	GlyphItemSchema,
-	GeneratedGlueItemSchema,
-	SourceGlueItemSchema,
-	KernItemSchema,
-	SuppressedItemSchema
-]) };
-const LineBreakResult = { schema: v.variant("kind", [
-	readonlyObject({ kind: v.literal("natural") }),
-	readonlyObject({ kind: v.literal("shrunk") }),
-	readonlyObject({ kind: v.literal("stretched") }),
-	readonlyObject({ kind: v.literal("hanging") }),
-	readonlyObject({ kind: v.literal("forced") }),
-	readonlyObject({ kind: v.literal("paragraph-end") })
-]) };
-const NovelLine = {
-	schema: readonlyObject({
-		range: v.nullable(ManuscriptRange.schema),
-		inlineSizeEm: v.pipe(v.number(), v.finite(), v.minValue(0)),
-		items: readonlyArray(ComposedInlineItem.schema),
-		break: LineBreakResult.schema,
-		annotations: readonlyArray(ComposedAnnotationFragment.schema)
-	}),
-	empty: () => ({
-		range: null,
-		inlineSizeEm: 0,
-		items: [],
-		break: { kind: "paragraph-end" },
-		annotations: []
-	})
-};
-const NovelStage = {
-	schema: readonlyObject({
-		range: v.nullable(ManuscriptRange.schema),
-		lines: readonlyArray(NovelLine.schema)
-	}),
-	of: (lines) => ({
-		lines,
-		range: ManuscriptRange.merge(lines.map(({ range }) => range))
-	})
-};
-const NovelPage = {
-	schema: readonlyObject({
-		range: v.nullable(ManuscriptRange.schema),
-		stages: readonlyArray(NovelStage.schema)
-	}),
-	of: (stages) => ({
-		stages,
-		range: ManuscriptRange.merge(stages.map(({ range }) => range))
-	})
-};
-const NovelLayout = { schema: readonlyObject({
-	pages: readonlyArray(NovelPage.schema),
-	geometry: ManuscriptGeometry.schema,
-	stats: CompositionStatistics.schema
-}) };
-//#endregion
-//#region src/composer/novel-composer.ts
-const COMPOSER_ID = NamespacedId.of("kg/novel");
-const TYPESETTING_PROFILE = defaultJapaneseTypesettingProfile;
-const ASCII_ALPHANUMERIC = /^[A-Za-z0-9]$/u;
-const ASCII_TWO_DIGITS = /^[0-9]{2}$/u;
-const UPRIGHT_LATIN_ABBREVIATION = /^(?:[A-Z]+|[A-Z][a-z]{1,2})$/u;
-const FULLWIDTH_ALPHANUMERIC = /^[Ａ-Ｚａ-ｚ０-９]$/u;
-function presentation(kind, graphemes) {
-	const groupRange = ManuscriptRange.merge(graphemes.map(({ range }) => range));
-	return groupRange === null ? void 0 : {
-		kind,
-		groupRange
-	};
-}
-function presentedSourceLine(sourceLine) {
-	const presented = [];
-	let cursor = 0;
-	while (cursor < sourceLine.length) {
-		const first = sourceLine[cursor];
-		if (first === void 0) break;
-		if (!ASCII_ALPHANUMERIC.test(first.value)) {
-			const itemPresentation = presentation(FULLWIDTH_ALPHANUMERIC.test(first.value) ? "upright" : "mixed", [first]);
-			if (itemPresentation !== void 0) presented.push({
-				grapheme: first,
-				presentation: itemPresentation
-			});
-			cursor += 1;
-			continue;
-		}
-		const start = cursor;
-		while (ASCII_ALPHANUMERIC.test(sourceLine[cursor]?.value ?? "")) cursor += 1;
-		const run = sourceLine.slice(start, cursor);
-		const text = run.map(({ value }) => value).join("");
-		const runPresentation = presentation(ASCII_TWO_DIGITS.test(text) ? "tate-chu-yoko" : text.length === 1 || UPRIGHT_LATIN_ABBREVIATION.test(text) ? "upright" : "sideways", run);
-		if (runPresentation !== void 0) presented.push(...run.map((grapheme) => ({
-			grapheme,
-			presentation: runPresentation
-		})));
-	}
-	return presented;
-}
-function displayedLines(graphemes) {
-	const lines = [[]];
-	let endedWithLineBreak = false;
-	for (const grapheme of graphemes) {
-		if (grapheme.value === "\n" || grapheme.value === "\r" || grapheme.value === "\r\n") {
-			lines.push([]);
-			endedWithLineBreak = true;
-			continue;
-		}
-		lines.at(-1)?.push(grapheme);
-		endedWithLineBreak = false;
-	}
-	if (lines.length > 1 && endedWithLineBreak) lines.pop();
-	return lines;
-}
-function validGapIndexes(sourceLine) {
-	const line = sourceLine.map(({ value }) => value).join("");
-	const gapStarts = new Set(questionOrExclamationSpacings(line).filter((spacing) => spacing.kind === "valid").map(({ gap }) => gap.start));
-	const indexes = /* @__PURE__ */ new Set();
-	let offset = 0;
-	for (const [index, grapheme] of sourceLine.entries()) {
-		if (gapStarts.has(offset)) indexes.add(index);
-		offset += grapheme.value.length;
-	}
-	return indexes;
-}
-function indicesInside(atoms, annotation) {
-	return atoms.flatMap(({ grapheme }, index) => ManuscriptRange.overlaps(grapheme.range, annotation.range) ? [index] : []);
-}
-function measure(measurer, text, role, settings, presentationKind) {
-	const context = {
-		text,
-		fontPreset: settings.appearance.fontPreset,
-		writingMode: "vertical-rl"
-	};
-	const measurement = role === "base" ? measurer({
-		...context,
-		role,
-		presentation: presentationKind ?? "mixed"
-	}) : measurer({
-		...context,
-		role
-	});
-	const parsed = v.safeParse(InlineMeasurement.schema, measurement);
-	if (!parsed.success) return void 0;
-	const { advanceEm } = parsed.output;
-	return advanceEm;
-}
-/**
-* Widen a base character by `extraEm` so a reading longer than it has room, keeping the character's
-* ink in the middle of the widened box.
-*
-* JLReq 3.3.6 sets such a reading solid and spends the surplus on the base instead: two units
-* between the base characters for one unit before the first and after the last. Handing every base
-* character an equal share of the surplus and centring it inside that share produces exactly those
-* proportions, and it is also the 中付き position JLReq 3.3.5 asks of a mono ruby whose reading
-* outruns its single base character.
-*/
-function widenForReading(atom, extraEm) {
-	if (extraEm <= 0) return;
-	atom.boxAdvanceEm += extraEm;
-	atom.renderOffsetEm += extraEm / 2;
-}
-function measureSourceLine(sourceLine, annotations, settings, measurer) {
-	const mutable = presentedSourceLine(sourceLine).map(({ grapheme, presentation }) => {
-		const renderAdvanceEm = measure(measurer, grapheme.value, "base", settings, presentation.kind);
-		if (renderAdvanceEm === void 0) return void 0;
-		const characterClass = TYPESETTING_PROFILE.classify({
-			value: grapheme.value,
-			presentation: presentation.kind
-		});
-		const metrics = TYPESETTING_PROFILE.boxMetrics(characterClass, renderAdvanceEm);
-		return {
-			grapheme,
-			boxAdvanceEm: metrics.advanceEm,
-			renderAdvanceEm,
-			renderOffsetEm: metrics.renderOffsetEm,
-			presentation
-		};
-	});
-	if (mutable.some((atom) => atom === void 0)) return void 0;
-	const atoms = mutable.flatMap((atom) => atom === void 0 ? [] : [atom]);
-	for (const annotation of annotations) {
-		if (annotation.kind !== "ruby") continue;
-		const indexes = indicesInside(atoms, annotation);
-		if (indexes.length === 0) continue;
-		if ((annotation.reading.kind === "group" ? [annotation.reading.text] : annotation.reading.segments).some((text) => [...graphemeSegmenter.segment(text)].some(({ segment }) => measure(measurer, segment, "ruby", settings) === void 0))) return void 0;
-		if (annotation.reading.kind === "group") {
-			const readingAdvance = measure(measurer, annotation.reading.text, "ruby", settings);
-			if (readingAdvance === void 0) return void 0;
-			const baseAdvance = indexes.reduce((total, index) => total + (atoms[index]?.boxAdvanceEm ?? 0), 0);
-			const extra = Math.max(0, readingAdvance - baseAdvance) / indexes.length;
-			for (const index of indexes) {
-				const atom = atoms[index];
-				if (atom !== void 0) widenForReading(atom, extra);
-			}
-			continue;
-		}
-		for (const [segmentIndex, index] of indexes.entries()) {
-			const segment = annotation.reading.segments[segmentIndex];
-			const atom = atoms[index];
-			if (segment === void 0 || atom === void 0) continue;
-			const readingAdvance = measure(measurer, segment, "ruby", settings);
-			if (readingAdvance === void 0) return void 0;
-			widenForReading(atom, readingAdvance - atom.boxAdvanceEm);
-		}
-	}
-	return {
-		atoms,
-		suppressedIndexes: validGapIndexes(sourceLine)
-	};
-}
-function breakInsideFittableGroupRuby(atoms, annotations, boundary, lineLengthEm) {
-	const right = atoms[boundary];
-	if (right === void 0) return false;
-	const graphemeIndex = right.grapheme.range.graphemes.start;
-	return annotations.some((annotation) => {
-		if (annotation.kind !== "ruby" || annotation.reading.kind !== "group") return false;
-		if (graphemeIndex <= annotation.range.graphemes.start || graphemeIndex >= annotation.range.graphemes.end) return false;
-		return indicesInside(atoms, annotation).reduce((total, index) => total + (atoms[index]?.boxAdvanceEm ?? 0), 0) <= lineLengthEm;
-	});
-}
-function samePresentationGroup(left, right) {
-	return left.presentation.groupRange.graphemes.start === right.presentation.groupRange.graphemes.start && left.presentation.groupRange.graphemes.end === right.presentation.groupRange.graphemes.end;
-}
-function legalBoundary(atoms, annotations, leftIndex, rightIndex, lineLengthEm, profile) {
-	const left = atoms[leftIndex];
-	const right = atoms[rightIndex];
-	if (left === void 0 || right === void 0) return true;
-	return !samePresentationGroup(left, right) && profile.breakPenalty(profile.classify({
-		value: left.grapheme.value,
-		presentation: left.presentation.kind
-	}), profile.classify({
-		value: right.grapheme.value,
-		presentation: right.presentation.kind
-	})) !== null && !breakInsideFittableGroupRuby(atoms, annotations, rightIndex, lineLengthEm);
-}
-function continuationFor(annotation, range) {
-	const starts = range.graphemes.start === annotation.range.graphemes.start;
-	const ends = range.graphemes.end === annotation.range.graphemes.end;
-	if (starts && ends) return "whole";
-	if (starts) return "start";
-	if (ends) return "end";
-	return "middle";
-}
-function groupReadingsForFragments(annotation, fragmentRanges, baseAdvances) {
-	const baseLength = annotation.range.graphemes.end - annotation.range.graphemes.start;
-	if (annotation.reading.kind !== "group") return [];
-	const reading = [...graphemeSegmenter.segment(annotation.reading.text)].map(({ segment }) => segment);
-	const advances = Array.from({ length: baseLength }, (_, index) => baseAdvances.get(annotation.range.graphemes.start + index));
-	const measured = advances.every((advance) => advance !== void 0);
-	const advanceFor = (fragment) => {
-		const fragmentStart = fragment.graphemes.start - annotation.range.graphemes.start;
-		const fragmentLength = fragment.graphemes.end - fragment.graphemes.start;
-		return measured ? advances.slice(fragmentStart, fragmentStart + fragmentLength).reduce((total, advance) => total + advance, 0) : fragmentLength;
-	};
-	const weights = fragmentRanges.map(advanceFor);
-	const effectiveWeights = weights.reduce((total, weight) => total + weight, 0) > 0 ? weights : fragmentRanges.map(({ graphemes }) => graphemes.end - graphemes.start);
-	const totalWeight = effectiveWeights.reduce((total, weight) => total + weight, 0);
-	const reserveEveryFragment = reading.length >= fragmentRanges.length;
-	const fragments = [];
-	let readingStart = 0;
-	let accumulatedWeight = 0;
-	for (const [index, weight] of effectiveWeights.entries()) {
-		accumulatedWeight += weight;
-		const remainingFragments = effectiveWeights.length - index - 1;
-		const proportionalEnd = index === effectiveWeights.length - 1 ? reading.length : Math.round(accumulatedWeight * reading.length / totalWeight);
-		const minimumEnd = reserveEveryFragment ? readingStart + 1 : readingStart;
-		const maximumEnd = reserveEveryFragment ? reading.length - remainingFragments : reading.length;
-		const readingEnd = Math.min(maximumEnd, Math.max(minimumEnd, proportionalEnd));
-		fragments.push(reading.slice(readingStart, readingEnd).join(""));
-		readingStart = readingEnd;
-	}
-	return fragments;
-}
-function readingForFragment(annotation, range, fragmentPlan) {
-	const start = range.graphemes.start - annotation.range.graphemes.start;
-	const length = range.graphemes.end - range.graphemes.start;
-	if (annotation.reading.kind !== "group") return {
-		kind: annotation.reading.kind,
-		text: annotation.reading.segments.slice(start, start + length).join("")
-	};
-	const fragmentIndex = fragmentPlan.ranges.findIndex(({ graphemes }) => graphemes.start === range.graphemes.start && graphemes.end === range.graphemes.end);
-	return {
-		kind: "group",
-		text: fragmentPlan.groupReadings[fragmentIndex] ?? ""
-	};
-}
-function positionReading(text, baseOffsetEm, baseAdvanceEm, settings, measurer) {
-	const measured = [...graphemeSegmenter.segment(text)].map(({ segment }) => ({
-		value: segment,
-		advanceEm: measure(measurer, segment, "ruby", settings) ?? 0
-	}));
-	const total = measured.reduce((sum, grapheme) => sum + grapheme.advanceEm, 0);
-	const edgeGap = measured.length > 0 && total < baseAdvanceEm ? (baseAdvanceEm - total) / (2 * measured.length) : 0;
-	let offsetEm = baseOffsetEm + (total > baseAdvanceEm ? (baseAdvanceEm - total) / 2 : edgeGap);
-	return measured.map((grapheme, index) => {
-		const positioned = {
-			value: grapheme.value,
-			advanceEm: grapheme.advanceEm,
-			offsetEm
-		};
-		offsetEm += grapheme.advanceEm;
-		if (index < measured.length - 1) offsetEm += edgeGap * 2;
-		return positioned;
-	});
-}
-function annotationFragmentRange(graphemes, suppressed, sourceGlues, annotation) {
-	return ManuscriptRange.merge([
-		...graphemes.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range)).map(({ range }) => range),
-		...suppressed.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range)).map(({ range }) => range),
-		...sourceGlues.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range)).map(({ range }) => range)
-	]);
-}
-function annotationFragments(graphemes, suppressed, sourceGlues, annotations, settings, measurer, fragmentPlansByAnnotation) {
-	const fragments = [];
-	for (const annotation of annotations) {
-		const covered = graphemes.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range));
-		const fragmentRange = annotationFragmentRange(graphemes, suppressed, sourceGlues, annotation);
-		const first = covered[0];
-		const last = covered.at(-1);
-		if (fragmentRange === null || first === void 0 || last === void 0) continue;
-		const common = {
-			annotationRange: annotation.range,
-			fragmentRange,
-			continuation: continuationFor(annotation, fragmentRange)
-		};
-		switch (annotation.kind) {
-			case "bold":
-			case "italic":
-				fragments.push({
-					kind: annotation.kind,
-					...common
-				});
-				break;
-			case "emphasis":
-				fragments.push({
-					kind: "emphasis",
-					mark: annotation.mark,
-					...common
-				});
-				break;
-			case "ruby": {
-				const fragmentPlan = fragmentPlansByAnnotation.get(annotation);
-				if (fragmentPlan === void 0) break;
-				const baseOffsetEm = first.layoutSpan.offsetEm;
-				const baseAdvanceEm = last.layoutSpan.offsetEm + last.layoutSpan.advanceEm - baseOffsetEm;
-				const reading = readingForFragment(annotation, fragmentRange, fragmentPlan);
-				fragments.push({
-					kind: "ruby",
-					rubyKind: reading.kind,
-					reading: reading.text,
-					baseOffsetEm,
-					baseAdvanceEm,
-					readingGraphemes: positionReading(reading.text, baseOffsetEm, baseAdvanceEm, settings, measurer),
-					...common
-				});
-				break;
-			}
-		}
-	}
-	return fragments;
-}
-function positionedLine(atoms, sourceGapIndexes, plan) {
-	const items = plan.suppressedIndexes.flatMap((index) => {
-		const atom = atoms[index];
-		return atom === void 0 ? [] : [{
-			kind: "suppressed",
-			value: atom.grapheme.value,
-			range: atom.grapheme.range,
-			reason: "question-or-exclamation-gap"
-		}];
-	});
-	const spacings = new Map(plan.pairSpacings.map((spacing) => [spacing.boundary, spacing]));
-	const characterSpacings = new Map(plan.characterSpacings.map((spacing) => [spacing.index, spacing]));
-	let offsetEm = 0;
-	const adjustmentOf = (widthEm, naturalWidthEm) => widthEm < naturalWidthEm ? "shrunk" : widthEm > naturalWidthEm ? "stretched" : "natural";
-	const positionSpacing = (spacing) => {
-		if (spacing.kind === "kern") items.push({
-			kind: "kern",
-			offsetEm,
-			widthEm: spacing.widthEm
-		});
-		else items.push({
-			kind: "glue",
-			origin: "generated",
-			offsetEm,
-			widthEm: spacing.widthEm,
-			naturalWidthEm: spacing.naturalWidthEm,
-			adjustment: adjustmentOf(spacing.widthEm, spacing.naturalWidthEm)
-		});
-		offsetEm += spacing.widthEm;
-	};
-	for (let index = plan.contentStart; index < plan.end; index += 1) {
-		const spacing = spacings.get(index);
-		if (spacing !== void 0) positionSpacing(spacing);
-		const atom = atoms[index];
-		if (atom === void 0) continue;
-		const characterSpacing = characterSpacings.get(index);
-		if (sourceGapIndexes.has(index) || characterSpacing !== void 0) {
-			const naturalWidthEm = characterSpacing?.naturalWidthEm ?? atom.boxAdvanceEm;
-			const widthEm = characterSpacing?.widthEm ?? atom.boxAdvanceEm;
-			items.push({
-				kind: "glue",
-				origin: "source",
-				value: atom.grapheme.value,
-				range: atom.grapheme.range,
-				offsetEm,
-				widthEm,
-				naturalWidthEm,
-				adjustment: adjustmentOf(widthEm, naturalWidthEm)
-			});
-			offsetEm += widthEm;
-			continue;
-		}
-		const hanging = plan.hangingIndex === index;
-		const layoutAdvanceEm = hanging ? 0 : atom.boxAdvanceEm;
-		items.push({
-			kind: "glyph",
-			value: atom.grapheme.value,
-			range: atom.grapheme.range,
-			layoutSpan: {
-				offsetEm,
-				advanceEm: layoutAdvanceEm
-			},
-			renderSpan: {
-				offsetEm: offsetEm + atom.renderOffsetEm,
-				advanceEm: atom.renderAdvanceEm
-			},
-			disposition: hanging ? "hanging" : "placed",
-			presentation: atom.presentation
-		});
-		offsetEm += layoutAdvanceEm;
-	}
-	const trailingSpacing = spacings.get(plan.end);
-	if (trailingSpacing !== void 0) positionSpacing(trailingSpacing);
-	const ranges = items.flatMap((item) => item.kind === "glyph" || item.kind === "suppressed" || item.kind === "glue" && item.origin === "source" ? [item.range] : []);
-	return {
-		range: ManuscriptRange.merge(ranges),
-		inlineSizeEm: Math.max(0, plan.inlineSizeEm),
-		items,
-		break: plan.break,
-		annotations: []
-	};
-}
-function wrapSourceLine(sourceLine, annotations, settings, measurer, baseAdvances) {
-	if (sourceLine.atoms.length === 0) return [NovelLine.empty()];
-	const profile = TYPESETTING_PROFILE;
-	const lines = layoutParagraph(sourceLine.atoms.map(({ grapheme, boxAdvanceEm, presentation }, index) => {
-		const current = sourceLine.atoms[index];
-		const next = sourceLine.atoms[index + 1];
-		return {
-			value: grapheme.value,
-			boxAdvanceEm,
-			sourceGap: sourceLine.suppressedIndexes.has(index),
-			characterClass: profile.classify({
-				value: grapheme.value,
-				presentation: presentation.kind
-			}),
-			pairSpacingAfter: current === void 0 || next === void 0 || !samePresentationGroup(current, next) && !breakInsideFittableGroupRuby(sourceLine.atoms, annotations, index + 1, settings.flow.lineLengthEm)
-		};
-	}), settings.flow.lineLengthEm, profile, (leftIndex, rightIndex) => legalBoundary(sourceLine.atoms, annotations, leftIndex, rightIndex, settings.flow.lineLengthEm, profile)).map((plan) => positionedLine(sourceLine.atoms, sourceLine.suppressedIndexes, plan));
-	const fragmentPlansByAnnotation = new Map(annotations.map((annotation) => {
-		const ranges = lines.flatMap((line) => {
-			const range = annotationFragmentRange(line.items.filter((item) => item.kind === "glyph"), line.items.filter((item) => item.kind === "suppressed"), line.items.flatMap((item) => item.kind === "glue" && item.origin === "source" ? [item] : []), annotation);
-			return range === null ? [] : [range];
-		});
-		return [annotation, {
-			ranges,
-			groupReadings: annotation.kind === "ruby" ? groupReadingsForFragments(annotation, ranges, baseAdvances) : []
-		}];
-	}));
-	return lines.map((line) => ({
-		range: line.range,
-		inlineSizeEm: line.inlineSizeEm,
-		items: line.items,
-		break: line.break,
-		annotations: annotationFragments(line.items.filter((item) => item.kind === "glyph"), line.items.filter((item) => item.kind === "suppressed"), line.items.flatMap((item) => item.kind === "glue" && item.origin === "source" ? [item] : []), annotations, settings, measurer, fragmentPlansByAnnotation)
-	}));
-}
-function blankLines(count) {
-	return Array.from({ length: count }, NovelLine.empty);
-}
-function buildPages(contentLines, settings) {
-	const { linesPerStage, stagesPerPage } = settings.flow;
-	const { stage: stageOffset, page: pageOffset } = settings.offsets;
-	const usablePerStage = linesPerStage - LineOffset.total(stageOffset);
-	const usablePerPage = usablePerStage * stagesPerPage;
-	const pages = [];
-	let contentIndex = 0;
-	while (contentIndex < contentLines.length || pages.length === 0) {
-		const stages = [];
-		for (let stageIndex = 0; stageIndex < stagesPerPage; stageIndex += 1) {
-			const lines = [];
-			for (let position = 0; position < linesPerStage; position += 1) {
-				const usableIndex = stageIndex * usablePerStage + position - stageOffset.leading;
-				const withinStage = position >= stageOffset.leading && position < linesPerStage - stageOffset.trailing;
-				const withinPage = usableIndex >= pageOffset.leading && usableIndex < usablePerPage - pageOffset.trailing;
-				const next = contentLines[contentIndex];
-				if (!withinStage || !withinPage || next === void 0) {
-					lines.push(NovelLine.empty());
-					continue;
-				}
-				lines.push(next);
-				contentIndex += 1;
-			}
-			stages.push(NovelStage.of(lines));
-		}
-		pages.push(NovelPage.of(stages));
-	}
-	return pages;
-}
-function createCompose(measurer) {
-	return (manuscript, settings) => {
-		const sourceLines = displayedLines(manuscript.graphemes);
-		const measured = sourceLines.map((line) => measureSourceLine(line, manuscript.annotations, settings, measurer));
-		if (measured.some((line) => line === void 0)) return ManuscriptResult.fail({ reason: "inline measurer returned a negative or non-finite value" });
-		const baseAdvances = /* @__PURE__ */ new Map();
-		for (const line of measured) for (const atom of line?.atoms ?? []) baseAdvances.set(atom.grapheme.range.graphemes.start, atom.boxAdvanceEm);
-		const manuscriptLines = measured.flatMap((line) => line === void 0 ? [] : wrapSourceLine(line, manuscript.annotations, settings, measurer, baseAdvances));
-		const pages = buildPages([
-			...blankLines(settings.offsets.document.leading),
-			...manuscriptLines,
-			...blankLines(settings.offsets.document.trailing)
-		], settings);
-		return ManuscriptResult.succeed({
-			pages,
-			geometry: ManuscriptGeometry.of(settings.flow, settings.appearance),
-			stats: {
-				chars: sourceLines.reduce((total, line) => total + line.length, 0),
-				sourceLines: sourceLines.length,
-				pages: pages.length
-			}
-		});
-	};
-}
-function createNovelComposer(options) {
-	return {
-		id: COMPOSER_ID,
-		settingsSchema: NovelCompositionSettings.schema,
-		layoutSchema: NovelLayout.schema,
-		compose: createCompose(options.measurer)
-	};
-}
-const novelComposer = createNovelComposer({ measurer: logicalInlineMeasurer });
-//#endregion
-export { logicalInlineMeasurer as a, ManuscriptOffsets as c, FontSizePt as d, FontPresetId as f, PaperSize as i, ManuscriptAppearanceSettings as l, novelComposer as n, NovelCompositionSettings as o, ParsedManuscript as p, ManuscriptGeometry as r, NovelFlowSettings as s, createNovelComposer as t, PaperSizeId as u };