@effected/markdown 0.2.0

package/MarkdownNode.js

@@ -0,0 +1,641 @@
+import { Effect, Schema } from "effect";
+
+//#region src/MarkdownNode.ts
+/**
+* A single point in a source document: 1-based `line` and `column`, 0-based
+* `offset`.
+*
+* `offset` is the index into the source string, which is what the edit layer
+* splices against; `line`/`column` are the human-facing coordinates unist
+* specifies.
+*
+* @public
+*/
+var Point = class extends Schema.Class("Point")({
+	line: Schema.Number,
+	column: Schema.Number,
+	offset: Schema.Number
+}) {};
+/**
+* The source span of a node: `start` inclusive, `end` exclusive.
+*
+* @public
+*/
+var Position = class Position extends Schema.Class("Position")({
+	start: Point,
+	end: Point
+}) {
+	/**
+	* The zero-width synthetic position: line 1, column 1, offset 0 at both
+	* ends — the span every node class's `make` fills in when `position` is
+	* omitted, and the same sentinel `Mdast.fromMdast` synthesizes for foreign
+	* nodes that carry none.
+	*
+	* @remarks
+	* Clearly synthetic and inert for rendering: trees carrying it serve
+	* tree-level workflows (stringify, the visitor, `MarkdownFormat.modify`
+	* replacement fragments, projection out), not offset-splice editing, whose
+	* offsets must come from a real parse.
+	*/
+	static synthetic = Position.make({
+		start: Point.make({
+			line: 1,
+			column: 1,
+			offset: 0
+		}),
+		end: Point.make({
+			line: 1,
+			column: 1,
+			offset: 0
+		})
+	});
+};
+const NodePosition = Position.pipe(Schema.withConstructorDefault(Effect.succeed(Position.synthetic)));
+/**
+* The explicitness of a reference, per mdast's `referenceType` enum.
+*
+* - `shortcut` — implicit, identifier inferred from the content (`[foo]`).
+* - `collapsed` — explicit, identifier inferred from the content (`[foo][]`).
+* - `full` — explicit, identifier explicitly set (`[foo][bar]`).
+*
+* @public
+*/
+const ReferenceType = Schema.Literals([
+	"shortcut",
+	"collapsed",
+	"full"
+]);
+/**
+* The two ways CommonMark spells a heading: `atx` (`# Title`) and `setext`
+* (a title underlined with `=` or `-`).
+*
+* @public
+*/
+const HeadingStyle = Schema.Literals(["atx", "setext"]);
+/**
+* The two ways CommonMark spells a hard line break: a trailing backslash or
+* two-or-more trailing spaces.
+*
+* @public
+*/
+const BreakStyle = Schema.Literals(["backslash", "spaces"]);
+/**
+* The two fence characters a fenced code block may use.
+*
+* @public
+*/
+const FenceChar = Schema.Literals(["`", "~"]);
+/**
+* The three bullet characters an unordered list may use.
+*
+* @public
+*/
+const BulletChar = Schema.Literals([
+	"-",
+	"*",
+	"+"
+]);
+/**
+* The two delimiters an ordered list marker may use (`1.` or `1)`).
+*
+* @public
+*/
+const ListDelimiter = Schema.Literals([".", ")"]);
+/**
+* The three characters a thematic break may be drawn with.
+*
+* @public
+*/
+const ThematicBreakChar = Schema.Literals([
+	"-",
+	"_",
+	"*"
+]);
+/**
+* The two characters emphasis and strong emphasis may be marked with.
+*
+* @public
+*/
+const EmphasisChar = Schema.Literals(["*", "_"]);
+/**
+* The six legal ATX/setext heading depths.
+*
+* @public
+*/
+const HeadingDepth = Schema.Literals([
+	1,
+	2,
+	3,
+	4,
+	5,
+	6
+]);
+/**
+* The three alignments a GFM table column may declare. A `null` entry in a
+* {@link Table}'s `align` array means the column carries no alignment.
+*
+* @public
+*/
+const TableAlign = Schema.Literals([
+	"left",
+	"right",
+	"center"
+]);
+/**
+* Text — a run of literal characters, with entity references and backslash
+* escapes already resolved into `value`.
+*
+* @public
+*/
+var Text = class extends Schema.Class("Text")({
+	type: Schema.tag("text"),
+	value: Schema.String,
+	position: NodePosition
+}) {};
+/**
+* InlineCode — a code span: `foo` written between backtick fences in the
+* source. `value` holds the span's content with the backtick fence stripped
+* and the spec's space-stripping applied.
+*
+* @public
+*/
+var InlineCode = class extends Schema.Class("InlineCode")({
+	type: Schema.tag("inlineCode"),
+	value: Schema.String,
+	position: NodePosition
+}) {};
+/**
+* Html — a fragment of raw HTML, kept verbatim. Used for both HTML blocks
+* (flow) and inline raw HTML (phrasing); the same node type serves both, as
+* mdast specifies.
+*
+* @public
+*/
+var Html = class extends Schema.Class("Html")({
+	type: Schema.tag("html"),
+	value: Schema.String,
+	position: NodePosition
+}) {};
+/**
+* Break — a hard line break.
+*
+* `breakStyle` is a fidelity extra recording which of the two CommonMark
+* spellings produced it.
+*
+* @public
+*/
+var Break = class extends Schema.Class("Break")({
+	type: Schema.tag("break"),
+	position: NodePosition,
+	breakStyle: Schema.optionalKey(BreakStyle)
+}) {};
+/**
+* Image — an inline image (`![alt](url "title")`).
+*
+* @public
+*/
+var Image = class extends Schema.Class("Image")({
+	type: Schema.tag("image"),
+	url: Schema.String,
+	title: Schema.optionalKey(Schema.String),
+	alt: Schema.optionalKey(Schema.String),
+	position: NodePosition
+}) {};
+/**
+* ImageReference — an image referring to a {@link Definition} by identifier
+* (`![alt][ref]`).
+*
+* The parser emits these unresolved, whether or not a matching definition
+* exists in the tree — resolution is the consumer's business.
+*
+* @public
+*/
+var ImageReference = class extends Schema.Class("ImageReference")({
+	type: Schema.tag("imageReference"),
+	identifier: Schema.String,
+	label: Schema.optionalKey(Schema.String),
+	referenceType: ReferenceType,
+	alt: Schema.optionalKey(Schema.String),
+	position: NodePosition
+}) {};
+/**
+* Emphasis — `*foo*` or `_foo_`.
+*
+* `markerChar` is a fidelity extra recording which marker produced it.
+*
+* @public
+*/
+var Emphasis = class extends Schema.Class("Emphasis")({
+	type: Schema.tag("emphasis"),
+	children: Schema.Array(Schema.suspend(() => PhrasingContent)),
+	position: NodePosition,
+	markerChar: Schema.optionalKey(EmphasisChar)
+}) {};
+/**
+* Strong — `**foo**` or `__foo__`.
+*
+* `markerChar` is a fidelity extra recording which marker produced it.
+*
+* @public
+*/
+var Strong = class extends Schema.Class("Strong")({
+	type: Schema.tag("strong"),
+	children: Schema.Array(Schema.suspend(() => PhrasingContent)),
+	position: NodePosition,
+	markerChar: Schema.optionalKey(EmphasisChar)
+}) {};
+/**
+* Delete — GFM strikethrough (`~~foo~~`). Content that is no longer accurate
+* or relevant.
+*
+* `~~` is the only marker `~~foo~~` renders through, so unlike
+* {@link Emphasis} and {@link Strong} there is no marker-character fidelity
+* extra to carry.
+*
+* @public
+*/
+var Delete = class extends Schema.Class("Delete")({
+	type: Schema.tag("delete"),
+	children: Schema.Array(Schema.suspend(() => PhrasingContent)),
+	position: NodePosition
+}) {};
+/**
+* Link — an inline link (`[text](url "title")`), including autolinks.
+*
+* @public
+*/
+var Link = class extends Schema.Class("Link")({
+	type: Schema.tag("link"),
+	url: Schema.String,
+	title: Schema.optionalKey(Schema.String),
+	children: Schema.Array(Schema.suspend(() => PhrasingContent)),
+	position: NodePosition
+}) {};
+/**
+* LinkReference — a link referring to a {@link Definition} by identifier
+* (`[text][ref]`).
+*
+* Emitted unresolved, on the same terms as {@link ImageReference}.
+*
+* @public
+*/
+var LinkReference = class extends Schema.Class("LinkReference")({
+	type: Schema.tag("linkReference"),
+	identifier: Schema.String,
+	label: Schema.optionalKey(Schema.String),
+	referenceType: ReferenceType,
+	children: Schema.Array(Schema.suspend(() => PhrasingContent)),
+	position: NodePosition
+}) {};
+/**
+* FootnoteReference — a GFM footnote marker (`[^alpha]`), associating this
+* point in the text with a {@link FootnoteDefinition} by identifier.
+*
+* Has no content model of its own — the marker carries no children, only the
+* mdast Association pair `identifier`/`label`. Like {@link LinkReference},
+* the parser emits these unresolved: resolution against a matching
+* `FootnoteDefinition` is the consumer's business.
+*
+* @public
+*/
+var FootnoteReference = class extends Schema.Class("FootnoteReference")({
+	type: Schema.tag("footnoteReference"),
+	identifier: Schema.String,
+	label: Schema.optionalKey(Schema.String),
+	position: NodePosition
+}) {};
+/**
+* The union of every node that may appear where mdast expects **phrasing**
+* content — the text of a document and its markup.
+*
+* Defined lazily via `Schema.suspend` to break the recursive reference chain
+* `PhrasingContent -> Emphasis/Strong/Link/LinkReference -> PhrasingContent`.
+*
+* @public
+*/
+const PhrasingContent = Schema.suspend(() => Schema.Union([
+	Break,
+	Delete,
+	Emphasis,
+	FootnoteReference,
+	Html,
+	Image,
+	ImageReference,
+	InlineCode,
+	Link,
+	LinkReference,
+	Strong,
+	Text
+]));
+/**
+* ThematicBreak — a horizontal rule (`---`, `***`, `___`).
+*
+* `markerChar` is a fidelity extra recording which character drew it.
+*
+* @public
+*/
+var ThematicBreak = class extends Schema.Class("ThematicBreak")({
+	type: Schema.tag("thematicBreak"),
+	position: NodePosition,
+	markerChar: Schema.optionalKey(ThematicBreakChar)
+}) {};
+/**
+* Code — a code block, fenced or indented.
+*
+* `lang` and `meta` split the fence's info string at the first run of
+* whitespace. The fidelity extras `fenceChar` and `fenceLength` are present
+* for fenced blocks and **absent for indented blocks** — their absence is how
+* the two are told apart on the way back out.
+*
+* @public
+*/
+var Code = class extends Schema.Class("Code")({
+	type: Schema.tag("code"),
+	value: Schema.String,
+	lang: Schema.optionalKey(Schema.String),
+	meta: Schema.optionalKey(Schema.String),
+	position: NodePosition,
+	fenceChar: Schema.optionalKey(FenceChar),
+	fenceLength: Schema.optionalKey(Schema.Number)
+}) {};
+/**
+* Definition — a link reference definition (`[ref]: /url "title"`).
+*
+* Kept in the tree at its source position rather than stripped, which is the
+* deliberate departure from commonmark.js and the reason references can stay
+* unresolved.
+*
+* @public
+*/
+var Definition = class extends Schema.Class("Definition")({
+	type: Schema.tag("definition"),
+	identifier: Schema.String,
+	label: Schema.optionalKey(Schema.String),
+	url: Schema.String,
+	title: Schema.optionalKey(Schema.String),
+	position: NodePosition
+}) {};
+/**
+* FootnoteDefinition — a GFM footnote definition (`[^alpha]: bravo.`), the
+* content a {@link FootnoteReference} points at.
+*
+* Kept in the tree at its source position, on the same terms as
+* {@link Definition} — the parser never relocates it; a consumer that wants
+* cmark-gfm's end-of-document footnote section renders it there instead.
+*
+* @public
+*/
+var FootnoteDefinition = class extends Schema.Class("FootnoteDefinition")({
+	type: Schema.tag("footnoteDefinition"),
+	identifier: Schema.String,
+	label: Schema.optionalKey(Schema.String),
+	children: Schema.Array(Schema.suspend(() => FlowContent)),
+	position: NodePosition
+}) {};
+/**
+* Paragraph — a run of phrasing content.
+*
+* @public
+*/
+var Paragraph = class extends Schema.Class("Paragraph")({
+	type: Schema.tag("paragraph"),
+	children: Schema.Array(Schema.suspend(() => PhrasingContent)),
+	position: NodePosition
+}) {};
+/**
+* Heading — an ATX or setext heading of depth 1 to 6.
+*
+* `headingStyle` is a fidelity extra recording which spelling produced it;
+* setext headings can only be depth 1 or 2.
+*
+* @public
+*/
+var Heading = class extends Schema.Class("Heading")({
+	type: Schema.tag("heading"),
+	depth: HeadingDepth,
+	children: Schema.Array(Schema.suspend(() => PhrasingContent)),
+	position: NodePosition,
+	headingStyle: Schema.optionalKey(HeadingStyle)
+}) {};
+/**
+* ListItem — one item of a {@link List}.
+*
+* `spread` follows mdast in being optional: absent means "not known", which a
+* hand-built tree may legitimately be. The parser always sets it.
+*
+* `checked` is a GFM extra (task-list items, `- [ ] foo` / `- [x] foo`):
+* `true` for done, `false` for not done, and **absent** — never `null` — for
+* an item that is not a task-list item at all. The parser only ever sets it
+* on items it recognized as task-list markers.
+*
+* @public
+*/
+var ListItem = class extends Schema.Class("ListItem")({
+	type: Schema.tag("listItem"),
+	spread: Schema.optionalKey(Schema.Boolean),
+	children: Schema.Array(Schema.suspend(() => FlowContent)),
+	position: NodePosition,
+	checked: Schema.optionalKey(Schema.Boolean)
+}) {};
+/**
+* List — an ordered or unordered list.
+*
+* `ordered`, `start` and `spread` are all optional per mdast (absent meaning
+* "not known"); the parser always sets `ordered` and `spread`, and sets
+* `start` only for ordered lists.
+*
+* The fidelity extras record the marker actually used: `bulletChar` for
+* unordered lists, `delimiter` for ordered ones.
+*
+* @public
+*/
+var List = class extends Schema.Class("List")({
+	type: Schema.tag("list"),
+	ordered: Schema.optionalKey(Schema.Boolean),
+	start: Schema.optionalKey(Schema.Number),
+	spread: Schema.optionalKey(Schema.Boolean),
+	children: Schema.Array(Schema.suspend(() => ListItem)),
+	position: NodePosition,
+	bulletChar: Schema.optionalKey(BulletChar),
+	delimiter: Schema.optionalKey(ListDelimiter)
+}) {};
+/**
+* Blockquote — a section quoted from somewhere else.
+*
+* @public
+*/
+var Blockquote = class extends Schema.Class("Blockquote")({
+	type: Schema.tag("blockquote"),
+	children: Schema.Array(Schema.suspend(() => FlowContent)),
+	position: NodePosition
+}) {};
+/**
+* TableCell — one cell of a {@link TableRow}: a header cell if its
+* grandparent {@link Table}'s first row, a data cell otherwise.
+*
+* mdast's content model for `TableCell` is phrasing content **excluding**
+* `Break` nodes — GFM tables are single-line source, so a hard break cannot
+* occur inside one. This schema does not carve that exclusion out of
+* `PhrasingContent`: a second phrasing union just for table cells would
+* duplicate the whole recursive-suspend machinery above for one excluded
+* member, and a parser that never emits `Break` inside a cell satisfies the
+* exclusion in practice without it.
+*
+* @public
+*/
+var TableCell = class extends Schema.Class("TableCell")({
+	type: Schema.tag("tableCell"),
+	children: Schema.Array(Schema.suspend(() => PhrasingContent)),
+	position: NodePosition
+}) {};
+/**
+* The union of every node that may appear where mdast expects **row**
+* content — the cells in a {@link TableRow}. A one-member union, kept because
+* mdast names the category.
+*
+* @public
+*/
+const RowContent = Schema.suspend(() => TableCell);
+/**
+* TableRow — one row of a {@link Table}: the labels of the columns if it is
+* the table's first row, a data row otherwise.
+*
+* @public
+*/
+var TableRow = class extends Schema.Class("TableRow")({
+	type: Schema.tag("tableRow"),
+	children: Schema.Array(Schema.suspend(() => TableCell)),
+	position: NodePosition
+}) {};
+/**
+* The union of every node that may appear where mdast expects **table**
+* content — the rows in a {@link Table}. A one-member union, kept because
+* mdast names the category.
+*
+* @public
+*/
+const TableContent = Schema.suspend(() => TableRow);
+/**
+* Table — GFM two-dimensional data.
+*
+* `align` is optional per mdast: absent means "not known" — which the parser
+* never produces, since a GFM table's delimiter row always yields one
+* `TableAlign | null` entry per column, but a hand-built tree may omit it.
+* When present, each entry is `null` for a column with no declared alignment.
+*
+* @public
+*/
+var Table = class extends Schema.Class("Table")({
+	type: Schema.tag("table"),
+	align: Schema.optionalKey(Schema.Array(Schema.NullOr(TableAlign))),
+	children: Schema.Array(Schema.suspend(() => TableRow)),
+	position: NodePosition
+}) {};
+/**
+* The union of every node that may appear where mdast expects **flow**
+* content — the sections of a document.
+*
+* Defined lazily via `Schema.suspend` to break the recursive reference chain
+* `FlowContent -> Blockquote/List -> FlowContent`. Widened for GFM with
+* {@link FootnoteDefinition} and {@link Table}, per mdast's `FlowContent`
+* (GFM) category.
+*
+* @public
+*/
+const FlowContent = Schema.suspend(() => Schema.Union([
+	Blockquote,
+	Code,
+	Definition,
+	FootnoteDefinition,
+	Heading,
+	Html,
+	List,
+	Paragraph,
+	Table,
+	ThematicBreak
+]));
+/**
+* The union of every node that may appear where mdast expects **list**
+* content. A one-member union, kept because mdast names the category and
+* later dialects widen it.
+*
+* @public
+*/
+const ListContent = Schema.suspend(() => ListItem);
+/**
+* The frontmatter formats the capture recognizes, keyed by their opening
+* fence: `---` is yaml, `+++` is toml and `---json` is json.
+*
+* @public
+*/
+const FrontmatterFormat = Schema.Literals([
+	"yaml",
+	"toml",
+	"json"
+]);
+/**
+* Frontmatter — the raw, fidelity-preserving capture of a document's metadata
+* block. `value` is the source text between the fences, exactly as written
+* (never inline-parsed, never decoded); `format` records which fence captured
+* it. The position spans the whole block including both fence lines.
+*
+* mdast has no single frontmatter node: it names `yaml` in the readme and
+* `toml` through the frontmatter extension, and json has no mdast name at
+* all. This package captures all three through ONE node — the design doc's
+* "text plus a format marker" — and the `Mdast` projection (P5) maps
+* `format` onto the mdast type names where they exist. Decoding the value is
+* the codec modules' job (`YamlFrontmatter`/`TomlFrontmatter`/
+* `JsonFrontmatter`, P3 Task 2); the engine never looks inside it.
+*
+* Only ever the first child of {@link Root}, and only when parsing opted in
+* via `MarkdownParseOptions.frontmatter` — mdast's "limited to one node, only
+* as head" constraint is structural here, not validated.
+*
+* @public
+*/
+var Frontmatter = class extends Schema.Class("Frontmatter")({
+	type: Schema.tag("frontmatter"),
+	format: FrontmatterFormat,
+	value: Schema.String,
+	position: NodePosition
+}) {};
+/**
+* The union of every node that may appear where mdast expects
+* **frontmatter** content — a one-member union, kept because mdast names the
+* category (its member there is `Yaml`; ours is the format-agnostic capture).
+*
+* @public
+*/
+const FrontmatterContent = Schema.suspend(() => Frontmatter);
+/**
+* Root — a whole document, and the only node that is never a child.
+*
+* mdast leaves a root's content model open; a parsed markdown document is
+* flow content, optionally headed by one {@link Frontmatter} node — mdast's
+* `FlowContentFrontmatter` merge, which admits frontmatter at the root and
+* nowhere else.
+*
+* @public
+*/
+var Root = class extends Schema.Class("Root")({
+	type: Schema.tag("root"),
+	children: Schema.Array(Schema.suspend(() => Schema.Union([Frontmatter, FlowContent]))),
+	position: NodePosition
+}) {};
+/**
+* A schema matching any node in the tree.
+*
+* @public
+*/
+const MarkdownNode = Schema.suspend(() => Schema.Union([
+	Root,
+	FrontmatterContent,
+	FlowContent,
+	ListContent,
+	PhrasingContent,
+	RowContent,
+	TableContent
+]));
+
+//#endregion
+export { Blockquote, Break, BreakStyle, BulletChar, Code, Definition, Delete, Emphasis, EmphasisChar, FenceChar, FlowContent, FootnoteDefinition, FootnoteReference, Frontmatter, FrontmatterContent, FrontmatterFormat, Heading, HeadingDepth, HeadingStyle, Html, Image, ImageReference, InlineCode, Link, LinkReference, List, ListContent, ListDelimiter, ListItem, MarkdownNode, Paragraph, PhrasingContent, Point, Position, ReferenceType, Root, RowContent, Strong, Table, TableAlign, TableCell, TableContent, TableRow, Text, ThematicBreak, ThematicBreakChar };