satteri-comark 0.1.0

package/README.md

@@ -0,0 +1,235 @@
+# satteri-comark
+
+`satteri-comark` is a [Satteri](https://satteri.bruits.org) plugin that adds support for most of [Comark](https://comark.dev)'s component syntax by transforming it into MDX.
+
+## See an example
+
+Take this scary example from Comark docs:
+
+````md
+::card{.featured}
+```yaml [props]
+variant: elevated
+color: primary
+actions:
+  - label: Read More
+    url: /article
+  - label: Share
+    icon: share
+```
+#header
+## Article Title
+*By Jane Doe*
+
+#content
+This is the main article content with **markdown** support.
+
+#footer
+Published on January 15, 2024
+::
+````
+
+With `satteri-comark`, Satteri transforms it into the following JSX output:
+
+```jsx
+<Card
+  class="featured"
+  variant="elevated"
+  color="primary"
+  actions={[
+    {
+      label: "Read More",
+      url: "/article",
+    },
+    {
+      label: "Share",
+      icon: "share",
+    },
+  ]}
+>
+  <Fragment slot="header">
+    <h2>{"Article Title"}</h2>
+    <p>
+      <em>{"By Jane Doe"}</em>
+    </p>
+  </Fragment>
+  <Fragment slot="content">
+    {"This is the main article content with "}
+    <strong>{"markdown"}</strong>
+    {" support."}
+  </Fragment>
+  <Fragment slot="footer">{"Published on January 15, 2024"}</Fragment>
+</Card>
+```
+
+## Features
+
+### What is supported
+
+- Two-colon component syntax (`::component` can be a container)
+- Translation of block components and inline components into MDX
+- Data binding syntax (`:prop="expr"`)
+- Block props inside code fences
+- Named slots. You can customize what slots transform into, and this package includes an adapter for [Astro](https://astro.build).
+
+### Extra features
+
+- In addition to normal data bindings for props, you can specify an expression to spread by setting the prop with name `::` (more convenient for inline props) or `...` (more convenient for block props) to that expression. For example, `:component{::="\{prop: 'value'\}"}`.
+
+- Block props support more languages by default, powered by [`confbox`](https://npmjs.com/package/confbox). Currently, in addition to YAML, JSON5, JSON with comments (JSONC), JSON, TOML, and INI are supported; just specify the language of the code block. You can also customize the behavior of prop blocks.
+
+- You can embed MDX `import/export` statements with ```` ```jsx|tsx [script] ```` code blocks.
+
+- You can embed JSX expressions with ```` ```jsx|tsx [embed] ```` code blocks.
+
+### Divergences from Comark
+
+In data bindings, values are just plain JS expressions (for example, you can do `:prop="arbitraryFunction()"`). This is more flexible than Comark.
+
+On the other hand, the data binding namespaces that Comark provides (`frontmatter`, `meta`, `data`, `props`) aren't set up by this plugin, and you or your framework need to inject them into your MDX environment. For example, Astro provides the `frontmatter` variable to all MDX files.
+
+### What is not supported
+
+- Frontmatter-style block props are not supported because Satteri cannot parse them.
+- Nesting components must each have a distinct number of colons, otherwise Satteri cannot parse them (bruits/satteri#203).
+- You must escape curly braces in inline props. This is due to a Satteri bug (bruits/satteri#301).
+- Other Comark extensions, such as admonitions (there are separate Satteri plugins you can use) or block attributes (planned: bruits/satteri#139).
+
+
+## How to use
+
+`satteri-comark` provides two Satteri plugins:
+
+```ts
+import directiveTwoColons from 'satteri-comark/2colons'
+import comarkMdx from 'satteri-comark'
+```
+
+- `directiveTwoColons` parses two-colon directives `::component` into container directives.
+- `comarkMdx` provides all other functionalities. It is possible to use this plugin without `directiveTwoColons`, it just means that two-colon directives will be parsed as leaf directives (Satteri's deafult behavior).
+
+To use:
+
+```ts
+import { mdxToJs } from 'satteri'
+
+const result = mdxToJs(mdxSource, {
+  features: {
+    directive: true, // Turn on baseline support for directive syntax
+  },
+  mdastPlugins: [
+    directiveTwoColons(), // must come before `comarkMdx`
+    comarkMdx(),
+  ]
+})
+```
+
+This will parse Comark syntax with the default handling for named slots: the slot names are simply discarded. To configure this, and other behaviors of `satteri-comark`, pass options to `directiveTwoColons` and `comarkMdx`:
+
+### Options for `directiveTwoColons`
+
+You can pass an object with the following signature to configure this plugin:
+
+```ts
+export interface Options {
+  /**
+   * Behavior when encoutering an unterminated 2-colon directive.
+   *
+   * - `'error'`: Throw an error.
+   * - `'greedy'`: Assume the directive extends as far as possible, until the next 2-colon
+   *   directive or the end of its parent element.
+   * - `'self-closing'`: Treat the directive as self-closing; no content is contained inside. Note
+   *    that this recovers the classical behavior of "leaf directives".
+   * @default 'self-closing'
+   */
+  onUnterminated?: 'error' | 'greedy' | 'self-closing'
+}
+```
+
+### Options for `comarkMdx`
+
+You can pass an object with the following signature to configure this plugin:
+
+```ts
+export interface Options {
+  /**
+   * Function for normalizing element names. Pass a no-op function to disable this behavior.
+   * @default htmlOrPascalCase
+   */
+  normalizeCase?: (name: string) => string
+
+  /**
+   * Support bindings (arbitrary expressions) in props via the `:prop="expr"` syntax, as well as
+   * the `::` and `...` prop names for expressions to be used as spread props.
+   * @default true
+   */
+  bindings?: boolean
+
+  /**
+   * How to parse `[props]` code blocks in the given languages
+   * @default viaConfbox
+   */
+  propsBlocks?: Record<string, (input: string) => unknown>
+
+  /**
+   * Enable `[script]` code blocks
+   * @default true
+   */
+  scriptBlocks?: boolean
+
+  /**
+   * Enable `[embed]` code blocks
+   * @default true
+   */
+  embedBlocks?: boolean
+
+  /**
+   * Define slot support in container directives
+   * @default passthrough
+   */
+  slots?: (name: string, children: SlotContents) => BlockLevelContent | BlockLevelContent[]
+}
+
+export type BlockLevelContent = BlockContent | DefinitionContent
+
+export type SlotContents =
+  { type: 'inline'; contents: PhrasingContent[] } | { type: 'block'; contents: BlockLevelContent[] }
+```
+
+The default values `htmlOrPascalCase`, `viaConfbox`, and `passthrough` are as follows:
+
+```ts
+/**
+ * Default value for `Options.normalizeCase`. If element name is a valid HTML tag, it will be
+ * converted to lowercase. Otherwise, it will be converted to PascalCase.
+ */
+export function htmlOrPascalCase(name: string): string
+
+/**
+ * Default value for `Options.propsBlocks`. Uses the `confbox` library to parse the following
+ * languages: JSON5, JSON with comments (JSONC), YAML, JSON, TOML, and INI.
+ */
+export const viaConfbox: Record<string, (input: string) => unknown>
+
+/**
+ * Default value for `Options.slots`. Passes through the slot contents as-is and discards the slot
+ * name.
+ */
+export function passthrough(_name: string, children: SlotContents): BlockLevelContent[]
+```
+
+`satteri-comark` additionally exports a named slot adapter suitable for use with Astro. You should `import { astroFragment } from 'satteri-comark'` and pass it to the `slots` fields of the `Options` object.
+
+```ts
+/**
+ * Value for `Options.slots` suitable for the Astro framework. Converts slots into slotted JSX
+ * fragments:
+ *
+ * ```jsx
+ * <Fragment slot="[slotName]">
+ *   <... slot content ...>
+ * </Fragment>
+ * ```
+ */
+export function astroFragment(name: string, children: SlotContents): BlockLevelContent
+```

package/dist/2colons.d.mts

@@ -0,0 +1,58 @@
+import { MdastPluginDefinition } from "satteri";
+//#region src/2colons.d.ts
+export interface Options {
+  /**
+   * Behavior when encoutering an unterminated 2-colon directive.
+   *
+   * - `'error'`: Throw an error.
+   * - `'greedy'`: Assume the directive extends as far as possible, until the next 2-colon
+   *   directive or the end of its parent element.
+   * - `'self-closing'`: Treat the directive as self-closing; no content is contained inside. Note
+   *    that this recovers the classical behavior of "leaf directives".
+   * @default 'self-closing'
+   */
+  onUnterminated?: "error" | "greedy" | "self-closing";
+}
+/**
+ * This Satteri plugin allows for container directives using two colons, instead of three at
+ * minimum:
+ *
+ * ```md
+ * ::container
+ * ... content ...
+ * ::
+ * ```
+ *
+ * Note that this plugin doesn't change that each nesting level of container directives must have
+ * _distinct_ numbers of colons. This is a limitation of `pulldown-cmark` that we cannot work
+ * around. For example, the following input would still parse nonsensically:
+ *
+ * ```md
+ * ::container
+ * ::container-2
+ * :::container-3
+ * :::container-4
+ * :::
+ * :::
+ * ::
+ * ::
+ * ```
+ *
+ * As opposed to this, which parses correctly:
+ *
+ * ```md
+ * ::container
+ * :::::container-2
+ * :::container-3
+ * ::::container-4
+ * ::::
+ * :::
+ * :::::
+ * ::
+ * ```
+ *
+ * Of special note here is that the number of colons need not be strictly increasing or decreasing.
+ */
+declare const _default: (opts?: Options) => MdastPluginDefinition;
+//#endregion
+export { _default as default };

package/dist/2colons.mjs

@@ -0,0 +1,96 @@
+import { r as splitParagraph, t as omit } from "./util-ChyRgdb_.mjs";
+import { defineMdastPlugin } from "satteri";
+import { u } from "unist-builder";
+//#region src/2colons.ts
+const visit = ({ onUnterminated = "self-closing" }) => (node, ctx) => {
+	const newChildren = [];
+	let start = null;
+	let inside = [];
+	let commit = (terminated) => {
+		if (start) {
+			if (!terminated && onUnterminated === "error") throw new Error(`Unterminated directive: ${start.name}`);
+			else if (!terminated && onUnterminated === "self-closing") newChildren.push(start);
+			else {
+				newChildren.push(u("containerDirective", omit(start, "type"), [...start.children.length ? [u("paragraph", { data: { directiveLabel: true } }, start.children)] : [], ...inside]));
+				inside = [];
+			}
+		}
+		newChildren.push(...inside);
+	};
+	for (let blockIx = 0; blockIx < node.children.length; blockIx++) {
+		const block = node.children[blockIx];
+		if (block.type === "leafDirective") {
+			commit(false);
+			start = block;
+			inside = [];
+		} else if (start && block.type === "paragraph") {
+			const split = splitParagraph(block, (line) => line === "::");
+			if (!split) {
+				inside.push(block);
+				continue;
+			}
+			const [before, _, after] = split;
+			inside.push(...before.length ? [u("paragraph", before)] : []);
+			commit(true);
+			start = null;
+			inside = after.length ? [u("paragraph", after)] : [];
+		} else inside.push(block);
+	}
+	commit(false);
+	ctx.replaceNode(node, {
+		...node,
+		children: newChildren
+	});
+};
+/**
+* This Satteri plugin allows for container directives using two colons, instead of three at
+* minimum:
+*
+* ```md
+* ::container
+* ... content ...
+* ::
+* ```
+*
+* Note that this plugin doesn't change that each nesting level of container directives must have
+* _distinct_ numbers of colons. This is a limitation of `pulldown-cmark` that we cannot work
+* around. For example, the following input would still parse nonsensically:
+*
+* ```md
+* ::container
+* ::container-2
+* :::container-3
+* :::container-4
+* :::
+* :::
+* ::
+* ::
+* ```
+*
+* As opposed to this, which parses correctly:
+*
+* ```md
+* ::container
+* :::::container-2
+* :::container-3
+* ::::container-4
+* ::::
+* :::
+* :::::
+* ::
+* ```
+*
+* Of special note here is that the number of colons need not be strictly increasing or decreasing.
+*/
+var _2colons_default = (opts = {}) => defineMdastPlugin({
+	name: "directive-2-colons",
+	before: visit(opts),
+	blockquote: visit(opts),
+	listItem: visit(opts),
+	footnoteDefinition: visit(opts),
+	containerDirective: visit(opts),
+	descriptionDetails: visit(opts),
+	mdxJsxFlowElement: visit(opts)
+});
+//#endregion
+export { _2colons_default as default };

package/dist/index.d.mts

@@ -0,0 +1,93 @@
+import { MdastPluginDefinition } from "satteri";
+import { BlockContent, DefinitionContent, PhrasingContent } from "mdast";
+//#region src/index.d.ts
+export type BlockLevelContent = BlockContent | DefinitionContent;
+export type SlotContents = {
+  type: "inline";
+  contents: PhrasingContent[];
+} | {
+  type: "block";
+  contents: BlockLevelContent[];
+};
+export interface Options {
+  /**
+   * Function for normalizing element names. Pass a no-op function to disable this behavior.
+   * @default htmlOrPascalCase
+   */
+  normalizeCase?: (name: string) => string;
+  /**
+   * Support bindings (arbitrary expressions) in props via the `:prop="expr"` syntax, as well as
+   * the `::` and `...` prop names for expressions to be used as spread props.
+   * @default true
+   */
+  bindings?: boolean;
+  /**
+   * How to parse `[props]` code blocks in the given languages
+   * @default viaConfbox
+   */
+  propsBlocks?: Record<string, (input: string) => unknown>;
+  /**
+   * Enable `[script]` code blocks
+   * @default true
+   */
+  scriptBlocks?: boolean;
+  /**
+   * Enable `[embed]` code blocks
+   * @default true
+   */
+  embedBlocks?: boolean;
+  /**
+   * Define slot support in container directives
+   * @default passthrough
+   */
+  slots?: (name: string, children: SlotContents) => BlockLevelContent | BlockLevelContent[];
+}
+/**
+ * Default value for `Options.normalizeCase`. If element name is a valid HTML tag, it will be
+ * converted to lowercase. Otherwise, it will be converted to PascalCase.
+ */
+export declare function htmlOrPascalCase(name: string): string;
+/**
+ * Default value for `Options.propsBlocks`. Uses the `confbox` library to parse the following
+ * languages: JSON5, JSON with comments (JSONC), YAML, JSON, TOML, and INI.
+ */
+export declare const viaConfbox: Record<string, (input: string) => unknown>;
+/**
+ * Default value for `Options.slots`. Passes through the slot contents as-is and discards the slot
+ * name.
+ */
+export declare function passthrough(_name: string, children: SlotContents): BlockLevelContent[];
+/**
+ * Value for `Options.slots` suitable for the Astro framework. Converts slots into slotted JSX
+ * fragments:
+ *
+ * ```jsx
+ * <Fragment slot="[slotName]">
+ *   <... slot content ...>
+ * </Fragment>
+ * ```
+ */
+export declare function astroFragment(name: string, children: SlotContents): BlockLevelContent;
+/**
+ * This Satteri plugin provides support for most of the Comark components syntax by translating
+ * them into MDX.
+ *
+ * Note that the two-colon container syntax isn't provided by this plugin, but instead by
+ * `satteri-comark/2colons`, which must be placed _before_ this plugin if you wish to use
+ * two-colon containers.
+ *
+ * There are some divergences from Comark:
+ * - Prop bindings `:prop="value"` are arbitrary JavaScript expressions, which makes them more
+ *   flexible than Comark's JSON values/property paths.
+ * - You can spread props by setting the `::` or `...` prop to a JavaScript expression evaluating
+ *   to the object you wish to spread.
+ * - `[props]` blocks support more languages by default (JSON5, JSONC, YAML, JSON, TOML, and INI).
+ * - `[props]` blocks must be code blocks, not frontmatter.
+ * - You can embed MDX `import/export` statements with ```` ```jsx|tsx [script] ```` code blocks.
+ * - You can embed JSX expressions with ```` ```jsx|tsx [embed] ```` code blocks.
+ * - Curly braces in bindings need to be escaped. This is a Satteri bug.
+ * - This plugin doesn't handle the setup of binding namespaces like `frontmatter`, `data`, etc.
+ */
+declare const _default: ({ normalizeCase, bindings, propsBlocks, scriptBlocks, embedBlocks, slots }?: Options) => MdastPluginDefinition;
+//#endregion
+export { _default as default };

package/dist/index.mjs

@@ -0,0 +1,187 @@
+import { i as wrapOne, n as shouldBeEvalString, r as splitParagraph } from "./util-ChyRgdb_.mjs";
+import * as Confbox from "confbox";
+import htmlTagsArray from "html-tags";
+import { defineMdastPlugin } from "satteri";
+import { pascalCase } from "tiny-case";
+import { u } from "unist-builder";
+//#region src/index.ts
+const htmlTags = new Set(htmlTagsArray);
+/**
+* Default value for `Options.normalizeCase`. If element name is a valid HTML tag, it will be
+* converted to lowercase. Otherwise, it will be converted to PascalCase.
+*/
+function htmlOrPascalCase(name) {
+	if (htmlTags.has(name.toLowerCase())) return name.toLowerCase();
+	return pascalCase(name);
+}
+/**
+* Default value for `Options.propsBlocks`. Uses the `confbox` library to parse the following
+* languages: JSON5, JSON with comments (JSONC), YAML, JSON, TOML, and INI.
+*/
+const viaConfbox = {
+	json5: Confbox.parseJSON5,
+	jsonc: Confbox.parseJSONC,
+	yaml: Confbox.parseYAML,
+	json: Confbox.parseJSON,
+	toml: Confbox.parseTOML,
+	ini: Confbox.parseINI
+};
+/**
+* Default value for `Options.slots`. Passes through the slot contents as-is and discards the slot
+* name.
+*/
+function passthrough(_name, children) {
+	if (children.type === "inline") return [u("paragraph", children.contents)];
+	else return children.contents;
+}
+/**
+* Value for `Options.slots` suitable for the Astro framework. Converts slots into slotted JSX
+* fragments:
+*
+* ```jsx
+* <Fragment slot="[slotName]">
+*   <... slot content ...>
+* </Fragment>
+* ```
+*/
+function astroFragment(name, children) {
+	return u("mdxJsxFlowElement", {
+		name: "Fragment",
+		attributes: [u("mdxJsxAttribute", { name: "slot" }, name)]
+	}, children.contents);
+}
+function makeAttrs(attrs, bindings) {
+	return Object.entries(attrs ?? {}).map(([name, value]) => {
+		if (bindings && (name === "..." || name === "::")) return u("mdxJsxExpressionAttribute", `...(${shouldBeEvalString(value)})`);
+		if (bindings && name.startsWith(":")) return u("mdxJsxAttribute", {
+			name: name.slice(1),
+			value: u("mdxJsxAttributeValueExpression", shouldBeEvalString(value))
+		});
+		if (typeof value === "string") return u("mdxJsxAttribute", {
+			name,
+			value
+		});
+		return u("mdxJsxAttribute", {
+			name,
+			value: u("mdxJsxAttributeValueExpression", JSON.stringify(value))
+		});
+	});
+}
+/**
+* This Satteri plugin provides support for most of the Comark components syntax by translating
+* them into MDX.
+*
+* Note that the two-colon container syntax isn't provided by this plugin, but instead by
+* `satteri-comark/2colons`, which must be placed _before_ this plugin if you wish to use
+* two-colon containers.
+*
+* There are some divergences from Comark:
+* - Prop bindings `:prop="value"` are arbitrary JavaScript expressions, which makes them more
+*   flexible than Comark's JSON values/property paths.
+* - You can spread props by setting the `::` or `...` prop to a JavaScript expression evaluating
+*   to the object you wish to spread.
+* - `[props]` blocks support more languages by default (JSON5, JSONC, YAML, JSON, TOML, and INI).
+* - `[props]` blocks must be code blocks, not frontmatter.
+* - You can embed MDX `import/export` statements with ```` ```jsx|tsx [script] ```` code blocks.
+* - You can embed JSX expressions with ```` ```jsx|tsx [embed] ```` code blocks.
+* - Curly braces in bindings need to be escaped. This is a Satteri bug.
+* - This plugin doesn't handle the setup of binding namespaces like `frontmatter`, `data`, etc.
+*/
+var src_default = ({ normalizeCase = htmlOrPascalCase, bindings = true, propsBlocks = viaConfbox, scriptBlocks = true, embedBlocks = true, slots = passthrough } = {}) => defineMdastPlugin({
+	name: "comark-mdx",
+	code(node) {
+		if (scriptBlocks && node.meta?.trim() === "[script]") return u("mdxjsEsm", node.value);
+		if (embedBlocks && node.meta?.trim() === "[embed]") return u("mdxFlowExpression", node.value);
+	},
+	containerDirective(node, ctx) {
+		const label = node.children.find((child) => !!(child.data && "directiveLabel" in child.data));
+		let attributes = node.attributes;
+		const children = node.children.filter((child) => !(child.data && "directiveLabel" in child.data));
+		if (propsBlocks && children.length > 0 && children[0].type === "code" && children[0].meta?.trim() === "[props]" && children[0].lang && children[0].lang in propsBlocks) {
+			const props = children[0];
+			const parsed = propsBlocks[children[0].lang](props.value);
+			if (typeof parsed !== "object" || parsed === null) {
+				ctx.report({
+					node: props,
+					severity: "warning",
+					message: `Invalid parsed value for props block: ${props.value}. This is ignored.`
+				});
+				console.warn(`Invalid parsed value for props block: ${props.value}. This is ignored.`);
+			} else attributes = {
+				...attributes,
+				...parsed
+			};
+			children.shift();
+		}
+		const newChildren = [];
+		let slotName = null;
+		let inside = {
+			type: "inline",
+			contents: []
+		};
+		const pushBlock = (block) => {
+			if (inside.type === "block") inside.contents.push(block);
+			else inside = {
+				type: "block",
+				contents: [...inside.contents.length ? [u("paragraph", inside.contents)] : [], block]
+			};
+		};
+		const pushInlines = (content) => {
+			if (content.length === 0) return;
+			if (inside.type === "block") inside.contents.push(u("paragraph", content));
+			else inside.contents.push(...content);
+		};
+		const commitSlot = () => {
+			if (inside.contents.length === 0) return;
+			if (slotName) newChildren.push(...wrapOne(slots(slotName, inside)));
+			else newChildren.push(...passthrough("", inside));
+		};
+		for (let blockIx = 0; blockIx < children.length; blockIx++) {
+			const block = children[blockIx];
+			if (block.type !== "paragraph") {
+				pushBlock(block);
+				continue;
+			}
+			const split = splitParagraph(block, (line) => /^#\S/.test(line));
+			if (!split) {
+				pushBlock(block);
+				continue;
+			}
+			const [before, target, after] = split;
+			pushInlines(before);
+			commitSlot();
+			slotName = target.slice(1);
+			inside = {
+				type: "inline",
+				contents: []
+			};
+			pushInlines(after);
+		}
+		commitSlot();
+		if (label) newChildren.unshift(...wrapOne(slots("label", {
+			type: "inline",
+			contents: label.children
+		})));
+		return u("mdxJsxFlowElement", {
+			name: normalizeCase(node.name),
+			attributes: makeAttrs(attributes, bindings),
+			data: node.data
+		}, newChildren);
+	},
+	leafDirective(node) {
+		return u("mdxJsxFlowElement", {
+			name: normalizeCase(node.name),
+			attributes: makeAttrs(node.attributes, bindings),
+			data: node.data
+		}, node.children);
+	},
+	textDirective(node) {
+		return u("mdxJsxTextElement", {
+			name: normalizeCase(node.name),
+			attributes: makeAttrs(node.attributes, bindings),
+			data: node.data
+		}, node.children);
+	}
+});
+//#endregion
+export { astroFragment, src_default as default, htmlOrPascalCase, passthrough, viaConfbox };

package/dist/util-ChyRgdb_.mjs

@@ -0,0 +1,36 @@
+import { u } from "unist-builder";
+//#region src/util.ts
+function omit(obj, ...keys) {
+	return Object.fromEntries(Object.entries(obj).filter(([key]) => !keys.includes(key)));
+}
+function wrapOne(x) {
+	return Array.isArray(x) ? x : [x];
+}
+function shouldBeEvalString(x) {
+	return typeof x === "string" ? x.replaceAll("\\{", "{").replaceAll("\\}", "}") : JSON.stringify(x);
+}
+function splitParagraph(node, test) {
+	const before = [];
+	for (let inlineIx = 0; inlineIx < node.children.length; inlineIx++) {
+		const inline = node.children[inlineIx];
+		if (inline.type === "text") {
+			const lines = inline.value.split("\n");
+			const splitIdx = lines.map((line) => line.trim()).findIndex(test);
+			if (splitIdx === -1) {
+				before.push(inline);
+				continue;
+			}
+			if (splitIdx !== 0) before.push(u("text", lines.slice(0, splitIdx).join("\n")));
+			const after = [...splitIdx === lines.length - 1 ? [] : [u("text", lines.slice(splitIdx + 1).join("\n"))], ...node.children.slice(inlineIx + 1)];
+			return [
+				before,
+				lines[splitIdx].trim(),
+				after
+			];
+		}
+		before.push(inline);
+	}
+	return null;
+}
+//#endregion
+export { wrapOne as i, shouldBeEvalString as n, splitParagraph as r, omit as t };

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "satteri-comark",
+  "version": "0.1.0",
+  "author": "daylily <i@dayli.ly>",
+  "license": "BSD-3-Clause",
+  "description": "Support for Comark syntax in Sätteri",
+  "homepage": "https://github.com/coclique/satteri-comark",
+  "bugs": "https://github.com/coclique/satteri-comark/issues",
+  "repository": {
+    "type": "git",
+    "url": "github:coclique/satteri-comark"
+  },
+  "keywords": [
+    "satteri",
+    "markdown",
+    "mdast",
+    "directive",
+    "mdx",
+    "comark"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
+    },
+    "./2colons": {
+      "import": "./dist/2colons.mjs",
+      "types": "./dist/2colons.d.mts"
+    }
+  },
+  "devDependencies": {
+    "@ianvs/prettier-plugin-sort-imports": "^4.7.1",
+    "prettier": "^3.9.6",
+    "satteri": "^0.10.5",
+    "tsdown": "^0.23.0",
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.0"
+  },
+  "dependencies": {
+    "@types/mdast": "^4.0.4",
+    "confbox": "^0.3.1",
+    "html-tags": "^5.1.0",
+    "tiny-case": "^1.0.3",
+    "unist-builder": "^4.0.0"
+  },
+  "peerDependencies": {
+    "satteri": "^0.10.5"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "check": "tsc --noEmit",
+    "test": "vitest"
+  }
+}