@nkardaz/remark-typography 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yalla Nkardaz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,297 @@
+# @nkardaz/remark-typography
+
+A Remark plugin that automatically applies typography rules to MDX files.
+Handles smart quotes, punctuation correction, non-breaking spaces, chemical
+notation, ruby annotations, and more — driven by the
+[@nkardaz/typography-rules](https://github.com/DemerNkardaz/typography-rules)
+rule engine.
+
+Built on [@nkardaz/typography-core](https://github.com/DemerNkardaz/typography-core).
+Designed specifically for MDX. Correct behaviour with plain Markdown (`.md`)
+files is not guaranteed.
+
+---
+
+## Installation
+
+```bash
+npm i -D @nkardaz/remark-typography
+```
+
+> **Requires Node.js ≥ 24.0.0**
+
+---
+
+## Quick Start
+
+`vite.config.ts`
+
+```typescript
+import remarkTypography from '@nkardaz/remark-typography';
+import remarkFrontmatter from 'remark-frontmatter';
+
+export default {
+  plugins: [
+    {
+      enforce: 'pre',
+      ...mdx({
+        jsxImportSource: 'vue',
+        remarkPlugins: [
+          remarkFrontmatter,
+          [
+            remarkTypography,
+            {
+              locale: 'en',
+            },
+          ],
+        ],
+      }),
+    },
+  ],
+};
+```
+
+---
+
+## Options
+
+```typescript
+export type RemarkTypographyOptions = TypographyCoreOptions;
+```
+
+All options come from `@nkardaz/typography-core`. See its documentation for the full reference.
+
+| Option                | Type                   | Default | Description                                                                                    |
+| --------------------- | ---------------------- | ------- | ---------------------------------------------------------------------------------------------- |
+| `locale`              | `string`               | `'en'`  | Default locale used for typography rules                                                       |
+| `initTypographyRules` | `boolean`              | `true`  | Automatically registers all built-in rules from `@nkardaz/typography-rules` on plugin init       |
+| `initMarkupRules`     | `boolean`              | `false` | Automatically registers all built-in markup rules from `@nkardaz/typography-rules` on plugin init |
+| `plugins`             | `(() => () => void)[]` | `[]`    | Custom rule plugins to register before processing. Each plugin is a factory returning a thunk  |
+| `logs`                | `boolean`              | `false` | Enables console warnings for missing locale rules and rule errors during processing            |
+
+---
+
+## Locale Resolution
+
+The active locale is resolved in the following order of priority for each processed node:
+
+1. **Per-node attribute** — `lang`, `language`, or `locale` on a JSX element
+2. **Frontmatter key** — `locale`, `lang`, or `language` in the file's YAML frontmatter
+3. **Plugin option** — `locale` passed to `remarkTypography()`
+4. **Fallback** — `'en'`
+
+### Per-file locale (frontmatter)
+
+Supported frontmatter keys in order of priority: `locale` → `lang` → `language`.
+
+```mdx
+---
+locale: ru
+---
+
+Текст на русском языке…
+```
+
+> `remark-frontmatter` must be placed before `remarkTypography` in
+> `remarkPlugins` for frontmatter locale detection to work.
+
+### Per-node locale (JSX attribute)
+
+Any JSX element can declare a locale via `lang`, `language`, or `locale`
+attribute. Typography rules for that locale are applied only to text within
+that element.
+
+```mdx
+<p lang="de">Ein schönes "Beispiel"</p>
+```
+
+---
+
+## Excluded Node Types
+
+The following node types are never processed — their content is passed through unchanged:
+
+| Node type    | Reason                                      |
+| ------------ | ------------------------------------------- |
+| `code`       | Fenced code blocks                          |
+| `inlineCode` | Inline code spans                           |
+| `math`       | Block math (remark-math)                    |
+| `inlineMath` | Inline math (remark-math)                   |
+| `html`       | Raw HTML blocks                             |
+| `yaml`       | YAML frontmatter (consumed for locale only) |
+| `toml`       | TOML frontmatter                            |
+
+Any node can also be excluded programmatically by setting `skipTypography: true`
+on its `data` object:
+
+```typescript
+// inside a remark plugin or unified transform
+node.data = { ...node.data, skipTypography: true };
+```
+
+---
+
+## Processing Pipeline
+
+Each text node goes through two sequential phases:
+
+**Phase 1 — String rules** (`replace`, `transform`, `function` rules returning `string`)
+
+Text content is joined across sibling text nodes, wrapped with `protect()` to
+shield URLs, emails, code spans, and other structured content from modification,
+then all matching string rules are applied in weight order via `applyRules` from
+`@nkardaz/typography-core`, and finally `unprotect()` restores the original protected spans.
+
+**Phase 2 — Node rules** (`node` rules and `function` rules returning `Node[]`)
+
+Text nodes that survived phase 1 are walked again. Rules that return a node
+tree (e.g. `chemNotation`, `wrapWithTag`, `rubyText`) split text nodes into
+mixed arrays of text and element nodes, which are spliced back into the parent's
+children.
+
+Both phases are applied per locale context. When a JSX element declares a `lang`, `language`, or `locale` attribute, a new locale context is pushed for that element's subtree before either phase runs — and popped on exit. Text inside `<p lang="ru">` goes through both phases with Russian rules, even if the surrounding file uses a different locale. See [Locale Resolution](#locale-resolution) for the full priority order.
+
+---
+
+## Custom Plugins
+
+Register additional rules using `@nkardaz/typography-rules` before passing the
+plugin to `remarkTypography`.
+
+`plugins/islenskaRules.ts`
+
+```typescript
+import { registerRule, newRule } from '@nkardaz/typography-rules';
+import { smartQuotes } from '@nkardaz/typography-rules/functions';
+import { PUNCTUATION } from '@nkardaz/typography-rules/glyphs';
+
+export default function islenskaRules() {
+  return () => {
+    registerRule(
+      'is',
+      newRule('/islenska/typography/quotes', smartQuotes, [
+        {
+          outer: [
+            PUNCTUATION.is.leftSided.outerQuoteOpen,
+            PUNCTUATION.is.rightSided.outerQuoteClose,
+          ],
+          inner: [
+            PUNCTUATION.is.leftSided.innerQuoteOpen,
+            PUNCTUATION.is.rightSided.innerQuoteClose,
+          ],
+        },
+      ], 100)
+    );
+
+    registerRule('is',
+      newRule('/islenska/numbers/1', /\b1\b/g, 'einn'),
+      newRule('/islenska/numbers/2', /\b2\b/g, 'tveir'),
+      newRule('/islenska/numbers/10', /\b10\b/g, 'tíu'),
+    );
+  };
+}
+```
+
+`vite.config.ts`
+
+```typescript
+import remarkTypography from '@nkardaz/remark-typography';
+import islenskaRules from './plugins/islenskaRules';
+
+export default {
+  plugins: [
+    {
+      enforce: 'pre',
+      ...mdx({
+        remarkPlugins: [
+          [remarkTypography, { plugins: [islenskaRules], locale: 'is' }],
+        ],
+      }),
+    },
+  ],
+};
+```
+
+---
+
+## Building a Derived Plugin
+
+`remarkTypography` is itself built with `createTypographyPlugin` from `@nkardaz/typography-core`.
+If you need a plugin with different defaults or additional options, use the same factory directly
+instead of wrapping `remarkTypography`:
+
+```typescript
+import { createTypographyPlugin, type TypographyCoreOptions } from '@nkardaz/typography-core';
+import { myRules } from './rules';
+
+interface MyPluginOptions extends TypographyCoreOptions {
+  strictMode?: boolean;
+}
+
+export const myTypographyPlugin = createTypographyPlugin<MyPluginOptions, Root>({
+  defaultOptions: {
+    locale: 'de',
+    plugins: [myRules],
+  },
+  createHandler: (config) => (tree: Root) => {
+    // your MDX/remark AST traversal
+  },
+});
+```
+
+See [@nkardaz/typography-core](https://github.com/DemerNkardaz/typography-core) for full factory documentation.
+
+---
+
+## Plugin Order
+
+### Place `remark-typography` AFTER these plugins
+
+| Plugin                                          | Reason                                                                                           |
+| ----------------------------------------------- | ------------------------------------------------------------------------------------------------ |
+| `remark-frontmatter`                            | Isolates YAML/TOML frontmatter and exposes it for locale detection                              |
+| `remark-mdx-frontmatter`                        | Same — exports frontmatter as named exports                                                      |
+| `remark-gfm`                                    | Adds tables, strikethrough, task lists, autolinks — typography must see the final node structure |
+| `remark-math`                                   | Introduces `math` / `inlineMath` nodes — must exist before typography skips them                |
+| `remark-directive`                              | Adds container/leaf/inline directive nodes before typography processes remaining text            |
+| `remark-github`                                 | Resolves mentions, issue refs, and commit links into nodes                                       |
+| `remark-footnotes` / `remark-gfm` (footnotes)  | Footnote nodes must be created before text inside them is processed                             |
+| `remark-extract-toc` / `remark-toc`            | TOC is built from headings — headings must exist in the tree first                              |
+| `remark-emoji`                                  | Converts `:emoji:` shortcodes to Unicode — run before so output is not re-processed             |
+| `remark-breaks`                                 | Converts soft breaks to `<br>` — structural change should precede text transformation           |
+| `remark-unwrap-images`                          | Moves image nodes up — structural, must precede text passes                                     |
+| `remark-mdx`                                   | Parses MDX expressions and JSX nodes — their text content must be in the tree first             |
+
+### Place `remark-typography` BEFORE these plugins
+
+| Plugin                                  | Reason                                                                          |
+| --------------------------------------- | ------------------------------------------------------------------------------- |
+| `remark-reading-time`                   | Counts words over text nodes — should see the final transformed text            |
+| `remark-reading-time-export`            | Re-exports the reading time value — must come after the count is done           |
+| `remark-stringify`                      | Serializes the tree back to Markdown — must see final text                      |
+| `remark-rehype`                         | Converts mdast → hast for HTML pipeline — carries final text values into rehype |
+| `remark-mdx-export` / custom exporters  | Export text content as JS variables — must reflect final typography             |
+
+### Order does not matter relative to these plugins
+
+| Plugin                           | Reason                                                                                 |
+| -------------------------------- | -------------------------------------------------------------------------------------- |
+| `remark-slug` / `rehype-slug`    | Operates on `id` generation from heading text — runs in rehype, separate pipeline      |
+| `remark-code-titles`             | Parses code block meta strings, never touches text nodes                               |
+| `remark-prism` / `remark-shiki` | Syntax highlighting — operates on code node values, which are excluded from typography |
+| `remark-attr`                    | Parses inline attribute syntax `{.class}` — structural only, no text node mutation     |
+
+---
+
+## TypeScript
+
+```typescript
+import type { RemarkTypographyOptions } from '@nkardaz/remark-typography';
+import type { TypographyCoreOptions, ResolvedCoreConfig } from '@nkardaz/typography-core';
+```
+
+| Type                      | Source                   | Description                         |
+| ------------------------- | ------------------------ | ------------------------------------ |
+| `RemarkTypographyOptions` | `@nkardaz/remark-typography` | Alias for `TypographyCoreOptions`   |
+| `TypographyCoreOptions`   | `@nkardaz/typography-core`  | Base options interface              |
+| `ResolvedCoreConfig`      | `@nkardaz/typography-core`  | Fully resolved config (all required) |

package/dist/index.cjs

@@ -0,0 +1,179 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  remarkTypography: () => remarkTypography
+});
+module.exports = __toCommonJS(index_exports);
+var import_unist_util_visit = require("unist-util-visit");
+var import_js_yaml = __toESM(require("js-yaml"), 1);
+var import_typography_rules = require("@nkardaz/typography-rules");
+var import_helpers = require("@nkardaz/typography-rules/helpers");
+var import_typography_core = require("@nkardaz/typography-core");
+var EXCLUDED_TYPES = /* @__PURE__ */ new Set([
+  "code",
+  "inlineCode",
+  "math",
+  "inlineMath",
+  "html",
+  "yaml",
+  "toml"
+]);
+var JSX_TYPES = /* @__PURE__ */ new Set(["mdxJsxFlowElement", "mdxJsxTextElement"]);
+function getJsxLang(node) {
+  for (const attr of node.attributes) {
+    if (attr.type === "mdxJsxAttribute" && (attr.name === "lang" || attr.name === "language" || attr.name === "locale") && typeof attr.value === "string") {
+      return attr.value;
+    }
+  }
+  return void 0;
+}
+var remarkTypography = (0, import_typography_core.createTypographyPlugin)({
+  createHandler: (config) => (tree) => {
+    let frontmatterLocale;
+    (0, import_unist_util_visit.visit)(tree, "yaml", (node) => {
+      const data = import_js_yaml.default.load(node.value);
+      frontmatterLocale = (0, import_typography_core.getFrontmatterLocale)(data);
+    });
+    const fileLocale = frontmatterLocale ?? config.locale ?? "en";
+    function applyNodeRules(textNodes, parent, locale) {
+      const rules2 = (0, import_typography_rules.getWeightedRules)(locale).filter(
+        (r) => r.kind === "node" || r.kind === "function"
+      );
+      if (rules2.length === 0) return;
+      for (const textNode of textNodes) {
+        let current = [textNode];
+        for (const rule of rules2) {
+          if (rule.label && (0, import_typography_rules.isRuleDisabled)(rule.label)) continue;
+          const next = [];
+          for (const node of current) {
+            if (node.type !== "text") {
+              next.push(node);
+              continue;
+            }
+            let nodeList;
+            if (rule.kind === "node") {
+              const nodeRule = rule;
+              nodeList = (0, import_typography_rules.htmlNode)(node.value, {
+                expression: nodeRule.rule,
+                nodes: nodeRule.nodes
+              });
+            } else {
+              const funcRule = rule;
+              const result = funcRule.rule(node.value, ...funcRule.args ?? []);
+              if (typeof result === "string" || !Array.isArray(result)) {
+                next.push(node);
+                continue;
+              }
+              nodeList = result;
+            }
+            if (nodeList.length === 1 && nodeList[0].type === "text") {
+              next.push(node);
+              continue;
+            }
+            for (const n of nodeList) {
+              next.push((0, import_typography_rules.nodeToMdast)(n));
+            }
+          }
+          current = next;
+        }
+        if (current.length === 1 && current[0] === textNode) continue;
+        const index = parent.children.indexOf(textNode);
+        if (index !== -1) {
+          parent.children.splice(index, 1, ...current);
+        }
+      }
+    }
+    function processNode(node, localeStack) {
+      if (EXCLUDED_TYPES.has(node.type)) return;
+      if (node.data?.skipTypography) return;
+      const currentLocale = localeStack[localeStack.length - 1] ?? fileLocale;
+      if (JSX_TYPES.has(node.type)) {
+        const jsxNode = node;
+        const jsxLang = getJsxLang(jsxNode);
+        if (jsxLang) {
+          if (!(0, import_typography_rules.rulesHas)(fileLocale)) {
+            (0, import_typography_core.warning)(
+              !(0, import_typography_rules.rulesHas)("common") || (0, import_typography_rules.rulesCount)("common") === 0 ? `No rules registered for both of common and "${jsxLang}" locales on <${jsxNode.name ?? "unknown"}> node.` : `No rules registered for locale "${jsxLang}" on <${jsxNode.name ?? "unknown"}> node, only common rules will be applied.`,
+              config.logs
+            );
+          }
+          localeStack.push(jsxLang);
+        }
+        const jsxLocale = localeStack[localeStack.length - 1] ?? fileLocale;
+        if ("children" in jsxNode) {
+          const directTextNodes2 = jsxNode.children.filter(
+            (child) => child.type === "text"
+          );
+          if (directTextNodes2.length > 0) {
+            const combinedText = (0, import_helpers.joinNodes)(directTextNodes2);
+            const transformedText = (0, import_typography_core.applyRules)(combinedText, jsxLocale, { logs: config.logs });
+            (0, import_helpers.splitNodes)(transformedText, directTextNodes2);
+            applyNodeRules(directTextNodes2, jsxNode, jsxLocale);
+          }
+          for (const child of jsxNode.children) {
+            if (child.type !== "text") {
+              processNode(child, localeStack);
+            }
+          }
+        }
+        if (jsxLang) localeStack.pop();
+        return;
+      }
+      if (!("children" in node)) return;
+      const parent = node;
+      const directTextNodes = parent.children.filter(
+        (child) => child.type === "text"
+      );
+      if (directTextNodes.length > 0) {
+        const combinedText = (0, import_helpers.joinNodes)(directTextNodes);
+        const transformedText = (0, import_typography_core.applyRules)(combinedText, currentLocale, { logs: config.logs });
+        (0, import_helpers.splitNodes)(transformedText, directTextNodes);
+        applyNodeRules(directTextNodes, parent, currentLocale);
+      }
+      for (const child of parent.children) {
+        if (child.type !== "text") {
+          processNode(child, localeStack);
+        }
+      }
+    }
+    if (!(0, import_typography_rules.rulesHas)(fileLocale)) {
+      (0, import_typography_core.warning)(
+        !(0, import_typography_rules.rulesHas)("common") || (0, import_typography_rules.rulesCount)("common") === 0 ? `No rules registered for both of common and "${fileLocale}" locales.` : `No rules registered for locale "${fileLocale}", only common rules will be applied.`,
+        config.logs
+      );
+    }
+    const rules = (0, import_typography_rules.getWeightedRules)(fileLocale);
+    if (rules.length === 0) return;
+    processNode(tree, [fileLocale]);
+  }
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type { Root } from 'mdast';
+import { type TypographyCoreOptions } from '@nkardaz/typography-core';
+export type RemarkTypographyOptions = TypographyCoreOptions;
+export declare const remarkTypography: (options?: Partial<TypographyCoreOptions> | undefined) => (tree: Root) => void;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.mjs

@@ -0,0 +1,160 @@
+// src/index.ts
+import { visit } from "unist-util-visit";
+import yaml from "js-yaml";
+import {
+  getWeightedRules,
+  rulesCount,
+  rulesHas,
+  isRuleDisabled,
+  htmlNode,
+  nodeToMdast
+} from "@nkardaz/typography-rules";
+import { joinNodes, splitNodes } from "@nkardaz/typography-rules/helpers";
+import {
+  createTypographyPlugin,
+  getFrontmatterLocale,
+  applyRules,
+  warning
+} from "@nkardaz/typography-core";
+var EXCLUDED_TYPES = /* @__PURE__ */ new Set([
+  "code",
+  "inlineCode",
+  "math",
+  "inlineMath",
+  "html",
+  "yaml",
+  "toml"
+]);
+var JSX_TYPES = /* @__PURE__ */ new Set(["mdxJsxFlowElement", "mdxJsxTextElement"]);
+function getJsxLang(node) {
+  for (const attr of node.attributes) {
+    if (attr.type === "mdxJsxAttribute" && (attr.name === "lang" || attr.name === "language" || attr.name === "locale") && typeof attr.value === "string") {
+      return attr.value;
+    }
+  }
+  return void 0;
+}
+var remarkTypography = createTypographyPlugin({
+  createHandler: (config) => (tree) => {
+    let frontmatterLocale;
+    visit(tree, "yaml", (node) => {
+      const data = yaml.load(node.value);
+      frontmatterLocale = getFrontmatterLocale(data);
+    });
+    const fileLocale = frontmatterLocale ?? config.locale ?? "en";
+    function applyNodeRules(textNodes, parent, locale) {
+      const rules2 = getWeightedRules(locale).filter(
+        (r) => r.kind === "node" || r.kind === "function"
+      );
+      if (rules2.length === 0) return;
+      for (const textNode of textNodes) {
+        let current = [textNode];
+        for (const rule of rules2) {
+          if (rule.label && isRuleDisabled(rule.label)) continue;
+          const next = [];
+          for (const node of current) {
+            if (node.type !== "text") {
+              next.push(node);
+              continue;
+            }
+            let nodeList;
+            if (rule.kind === "node") {
+              const nodeRule = rule;
+              nodeList = htmlNode(node.value, {
+                expression: nodeRule.rule,
+                nodes: nodeRule.nodes
+              });
+            } else {
+              const funcRule = rule;
+              const result = funcRule.rule(node.value, ...funcRule.args ?? []);
+              if (typeof result === "string" || !Array.isArray(result)) {
+                next.push(node);
+                continue;
+              }
+              nodeList = result;
+            }
+            if (nodeList.length === 1 && nodeList[0].type === "text") {
+              next.push(node);
+              continue;
+            }
+            for (const n of nodeList) {
+              next.push(nodeToMdast(n));
+            }
+          }
+          current = next;
+        }
+        if (current.length === 1 && current[0] === textNode) continue;
+        const index = parent.children.indexOf(textNode);
+        if (index !== -1) {
+          parent.children.splice(index, 1, ...current);
+        }
+      }
+    }
+    function processNode(node, localeStack) {
+      if (EXCLUDED_TYPES.has(node.type)) return;
+      if (node.data?.skipTypography) return;
+      const currentLocale = localeStack[localeStack.length - 1] ?? fileLocale;
+      if (JSX_TYPES.has(node.type)) {
+        const jsxNode = node;
+        const jsxLang = getJsxLang(jsxNode);
+        if (jsxLang) {
+          if (!rulesHas(fileLocale)) {
+            warning(
+              !rulesHas("common") || rulesCount("common") === 0 ? `No rules registered for both of common and "${jsxLang}" locales on <${jsxNode.name ?? "unknown"}> node.` : `No rules registered for locale "${jsxLang}" on <${jsxNode.name ?? "unknown"}> node, only common rules will be applied.`,
+              config.logs
+            );
+          }
+          localeStack.push(jsxLang);
+        }
+        const jsxLocale = localeStack[localeStack.length - 1] ?? fileLocale;
+        if ("children" in jsxNode) {
+          const directTextNodes2 = jsxNode.children.filter(
+            (child) => child.type === "text"
+          );
+          if (directTextNodes2.length > 0) {
+            const combinedText = joinNodes(directTextNodes2);
+            const transformedText = applyRules(combinedText, jsxLocale, { logs: config.logs });
+            splitNodes(transformedText, directTextNodes2);
+            applyNodeRules(directTextNodes2, jsxNode, jsxLocale);
+          }
+          for (const child of jsxNode.children) {
+            if (child.type !== "text") {
+              processNode(child, localeStack);
+            }
+          }
+        }
+        if (jsxLang) localeStack.pop();
+        return;
+      }
+      if (!("children" in node)) return;
+      const parent = node;
+      const directTextNodes = parent.children.filter(
+        (child) => child.type === "text"
+      );
+      if (directTextNodes.length > 0) {
+        const combinedText = joinNodes(directTextNodes);
+        const transformedText = applyRules(combinedText, currentLocale, { logs: config.logs });
+        splitNodes(transformedText, directTextNodes);
+        applyNodeRules(directTextNodes, parent, currentLocale);
+      }
+      for (const child of parent.children) {
+        if (child.type !== "text") {
+          processNode(child, localeStack);
+        }
+      }
+    }
+    if (!rulesHas(fileLocale)) {
+      warning(
+        !rulesHas("common") || rulesCount("common") === 0 ? `No rules registered for both of common and "${fileLocale}" locales.` : `No rules registered for locale "${fileLocale}", only common rules will be applied.`,
+        config.logs
+      );
+    }
+    const rules = getWeightedRules(fileLocale);
+    if (rules.length === 0) return;
+    processNode(tree, [fileLocale]);
+  }
+});
+export {
+  remarkTypography
+};
+//# sourceMappingURL=index.mjs.map

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@nkardaz/remark-typography",
+  "version": "1.0.0",
+  "description": "Implements typography rules for MDX files.",
+  "license": "MIT",
+  "author": "Yalla Nkardaz",
+  "keywords": [
+    "typography",
+    "typographic",
+    "text-formatting",
+    "typesetting",
+    "russian",
+    "english",
+    "text",
+    "mdast",
+    "markdown",
+    "unified",
+    "remark",
+    "remark-plugin"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DemerNkardaz/remark-typography.git"
+  },
+  "homepage": "https://github.com/DemerNkardaz/remark-typography#readme",
+  "bugs": {
+    "url": "https://github.com/DemerNkardaz/remark-typography/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "bundleSizeLimit": 20480,
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "scripts": {
+    "build:js": "node esbuild.config.mjs",
+    "build:types": "tsc --project tsconfig.build.json --emitDeclarationOnly",
+    "build": "npm run build:js && npm run build:types",
+    "dev": "esbuild --watch",
+    "lint": "eslint src --ext .ts,.tsx",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "format": "prettier --write \"src/**/*.{ts,tsx,json,md}\"",
+    "type-check": "tsc --noEmit",
+    "test": "vitest --run",
+    "test:coverage": "vitest --run --coverage",
+    "prepublishOnly": "npm run build && npm run lint && npm run type-check",
+    "knip": "knip"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/js-yaml": "^4.0.9",
+    "@types/mdast": "^4.0.4",
+    "@types/mdx": "^2.0.14",
+    "@types/node": "^25.9.1",
+    "@vitest/coverage-v8": "^4.1.8",
+    "esbuild": "^0.28.0",
+    "eslint": "^10.4.1",
+    "eslint-config-prettier": "^10.1.8",
+    "knip": "^6.15.0",
+    "mdast-util-mdx-jsx": "^3.2.0",
+    "prettier": "^3.0.0",
+    "remark-parse": "^11.0.0",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.60.1",
+    "unified": "^11.0.5",
+    "vite-tsconfig-paths": "^6.1.1",
+    "vitest": "^4.1.8"
+  },
+  "dependencies": {
+    "@nkardaz/typography-core": "1.0.1",
+    "@nkardaz/typography-rules": "1.0.0",
+    "js-yaml": "^4.2.0",
+    "unist-util-visit": "^5.1.0"
+  }
+}