@nkardaz/typography-core 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,368 @@
+# @nkardaz/typography-core
+
+Framework-agnostic core for building typography plugins.
+Provides rule initialisation, string-phase processing, locale resolution,
+and a plugin factory — with no knowledge of any AST or framework.
+
+Used internally by [@nkardaz/remark-typography](https://github.com/DemerNkardaz/remark-typography)
+and intended as the foundation for any custom typography plugin built on
+[@nkardaz/typography-rules](https://github.com/DemerNkardaz/typography-rules).
+
+---
+
+## Installation
+
+```bash
+npm i -D @nkardaz/typography-core
+```
+
+> **Requires Node.js ≥ 24.0.0**
+
+---
+
+## Overview
+
+`@nkardaz/typography-core` does three things:
+
+- **Initialises rules** — registers built-in and custom rule sets via `initRules`
+- **Processes strings** — applies all string-phase rules to a text value via `applyRules`
+- **Creates plugins** — provides `createTypographyPlugin` as a generic factory for building framework-specific plugins with a standardised config contract
+
+---
+
+## API
+
+### `initRules(config: ResolvedCoreConfig): void`
+
+Registers rule sets based on the resolved config. Called once per plugin instantiation.
+
+```typescript
+import { initRules } from '@nkardaz/typography-core';
+
+initRules({
+  initTypographyRules: true,
+  initMarkupRules: false,
+  locale: 'en',
+  plugins: [myCustomRules],
+  logs: false,
+});
+```
+
+Behaviour:
+- If `initTypographyRules` is `true` — calls `initTypographyRules()` from `@nkardaz/typography-rules`
+- If `initMarkupRules` is `true` — calls `initMarkupRules()` from `@nkardaz/typography-rules`
+- Runs each plugin in `plugins` as `plugin()()`
+
+---
+
+### `applyRules(text, locale, config): string`
+
+Applies all string-phase rules (`replace`, `transform`, `function→string`) to a text value.
+Protected regions (URLs, emails, code spans, etc.) are shielded before rules run and restored after.
+
+```typescript
+import { applyRules } from '@nkardaz/typography-core';
+
+const result = applyRules('Hello -- world', 'en', { logs: false });
+```
+
+Node-type rules (`kind: 'node'`) are skipped here — they require AST access and are handled
+by the framework-specific plugin layer.
+
+---
+
+### `applyNodeRules(textNodes, parent, locale, config): void`
+
+Applies node-phase rules (`kind === 'node'` and `function`→`Node[]`) to a flat list of
+text nodes belonging to a single parent element, mutating `parent.children` in-place.
+
+Operates on one level of the tree only — it does not recurse. Traversal and locale
+switching across element boundaries is the caller's responsibility (see `processElement`).
+
+Must be called **after** `applyRules` + `joinNodes`/`splitNodes` have already handled
+string-phase processing on the same text nodes.
+
+```typescript
+import { applyRules, applyNodeRules } from '@nkardaz/typography-core';
+import { joinNodes, splitNodes } from '@nkardaz/typography-rules/helpers';
+import type { ElementNode, TextNode } from '@nkardaz/typography-rules';
+
+const textNodes = element.children.filter((c): c is TextNode => c.type === 'text');
+
+if (textNodes.length > 0) {
+  // Phase 1 — string rules
+  const combined = joinNodes(textNodes);
+  const transformed = applyRules(combined, locale, { logs: false });
+  splitNodes(transformed, textNodes);
+
+  // Phase 2 — node rules (mutates element.children in-place)
+  applyNodeRules(textNodes, element, locale, { logs: false });
+}
+```
+
+| Parameter   | Type                               | Description                                              |
+| ----------- | ---------------------------------- | -------------------------------------------------------- |
+| `textNodes` | `TextNode[]`                       | Direct text-node children of `parent`, pre-filtered     |
+| `parent`    | `ElementNode`                      | The element whose `children` array is mutated on expansion |
+| `locale`    | `string`                           | Active locale for rule selection                         |
+| `config`    | `Pick<ResolvedCoreConfig, 'logs'>` | Only `logs` is used — controls warning output            |
+
+Rules of `kind: 'function'` are only expanded here if they return `Node[]`.
+If a function rule returns a `string`, it is silently skipped (already handled by `applyRules`).
+
+---
+
+### `processElement(element, locale, config): void`
+
+Recursively processes an element and all its descendants, applying both string-phase and
+node-phase typography rules. Owns traversal, locale inheritance, and coordinates the
+two-phase pipeline at each level of the tree.
+
+Locale is resolved per element: if the element carries a `lang`, `language`, or `locale`
+attribute, that value is used for the element's subtree; otherwise the parent's locale is
+inherited. This mirrors the `lang` attribute semantics of HTML.
+
+```typescript
+import { processElement } from '@nkardaz/typography-core';
+import type { ElementNode } from '@nkardaz/typography-rules';
+
+// Process an entire element tree with a base locale
+processElement(rootElement, 'en', { logs: false });
+
+// Mixed-locale content is handled automatically via attributes:
+// <p lang="ru">Привет — мир</p>  →  processed with Russian rules
+// <p>Hello -- world</p>          →  processed with inherited locale
+```
+
+| Parameter | Type                               | Description                                                  |
+| --------- | ---------------------------------- | ------------------------------------------------------------ |
+| `element` | `ElementNode`                      | Root of the subtree to process; `children` mutated in-place  |
+| `locale`  | `string`                           | Inherited locale from the parent scope                       |
+| `config`  | `Pick<ResolvedCoreConfig, 'logs'>` | Only `logs` is used — controls warning output                |
+
+Locale attribute priority: `lang` → `language` → `locale` → inherited.
+
+> `processElement` works with `ElementNode` from `@nkardaz/typography-rules`. For vanilla DOM,
+> write a thin adapter that reads `element.getAttribute('lang')` and maps DOM nodes to
+> `ElementNode` — the pipeline logic is identical.
+
+---
+
+### `getFrontmatterLocale(data): string | undefined`
+
+Resolves a locale string from a parsed frontmatter object.
+Checks keys in order: `locale` → `lang` → `language`.
+
+```typescript
+import { getFrontmatterLocale } from '@nkardaz/typography-core';
+
+const locale = getFrontmatterLocale({ lang: 'ru' }); // → 'ru'
+```
+
+---
+
+### `warning(message, showLogs): void`
+
+Emits a prefixed `console.warn` if `showLogs` is `true`.
+
+```typescript
+import { warning } from '@nkardaz/typography-core';
+
+warning('No rules registered for locale “is”', config.logs);
+```
+
+---
+
+### `createTypographyPlugin(factory): (options?) => handler`
+
+Generic factory for building framework-specific typography plugins.
+Handles config merging, default resolution, and `initRules` — so the plugin
+author only provides the handler logic.
+
+```typescript
+import { createTypographyPlugin } from '@nkardaz/typography-core';
+
+export const myPlugin = createTypographyPlugin({
+  defaultOptions: {
+    locale: 'de',
+  },
+  createHandler: (config) => (tree) => {
+    // your AST traversal here
+    // config is fully resolved: ResolvedCoreConfig & TOptions
+  },
+});
+```
+
+The returned `myPlugin` is a standard two-call plugin function:
+
+```typescript
+myPlugin()                     // default options
+myPlugin({ locale: 'fr' })    // override options
+```
+
+Config resolution order (last wins):
+
+```
+factory defaults  ←  createTypographyPlugin defaultOptions  ←  user options
+```
+
+---
+
+## Exports
+
+```typescript
+// Functions
+export { initRules } from '@nkardaz/typography-core';
+export { applyRules } from '@nkardaz/typography-core';
+export { applyNodeRules } from '@nkardaz/typography-core';
+export { processElement } from '@nkardaz/typography-core';
+export { getFrontmatterLocale } from '@nkardaz/typography-core';
+export { warning } from '@nkardaz/typography-core';
+export { createTypographyPlugin } from '@nkardaz/typography-core';
+
+// Types
+export type { TypographyCoreOptions, ResolvedCoreConfig, PluginFactory } from '@nkardaz/typography-core';
+```
+
+---
+
+## Types
+
+```typescript
+import type {
+  TypographyCoreOptions,
+  ResolvedCoreConfig,
+  PluginFactory,
+} from '@nkardaz/typography-core';
+```
+
+### `TypographyCoreOptions`
+
+Options accepted by any plugin built with `createTypographyPlugin`.
+
+```typescript
+export interface TypographyCoreOptions {
+  initTypographyRules?: boolean;
+  initMarkupRules?: boolean;
+  locale?: string;
+  plugins?: (() => () => void)[];
+  logs?: boolean;
+}
+```
+
+| Option                | Type                   | Default | Description                                                                 |
+| --------------------- | ---------------------- | ------- | --------------------------------------------------------------------------- |
+| `initTypographyRules` | `boolean`              | `true`  | Register built-in typography rules from `@nkardaz/typography-rules`           |
+| `initMarkupRules`     | `boolean`              | `false` | Register built-in markup rules from `@nkardaz/typography-rules`               |
+| `locale`              | `string`               | `'en'`  | Default locale for rule selection                                           |
+| `plugins`             | `(() => () => void)[]` | `[]`    | Custom rule plugins. Each is a factory returning a thunk: `() => () => void` |
+| `logs`                | `boolean`              | `false` | Emit warnings for missing locales and rule errors                           |
+
+### `ResolvedCoreConfig`
+
+`Required<TypographyCoreOptions>` — all fields guaranteed present. This is what
+`createHandler` receives.
+
+### `PluginFactory<TOptions, TTree>`
+
+```typescript
+export interface PluginFactory<TOptions extends TypographyCoreOptions, TTree> {
+  defaultOptions?: Partial<TOptions>;
+  createHandler: (config: ResolvedCoreConfig & TOptions) => (tree: TTree) => void;
+}
+```
+
+---
+
+## Building a Custom Plugin
+
+Extend `TypographyCoreOptions` with your own fields and pass a typed factory:
+
+```typescript
+import { createTypographyPlugin, type TypographyCoreOptions } from '@nkardaz/typography-core';
+import { myRules } from './rules';
+
+interface MyPluginOptions extends TypographyCoreOptions {
+  strictMode?: boolean;
+}
+
+export const myTypographyPlugin = createTypographyPlugin<MyPluginOptions, MyTree>({
+  defaultOptions: {
+    locale: 'fr',
+    plugins: [myRules],
+    strictMode: false,
+  },
+  createHandler: (config) => (tree) => {
+    if (config.strictMode) {
+      // strict processing
+    }
+    // traverse tree, call applyRules, etc.
+  },
+});
+```
+
+The factory automatically calls `initRules` with the resolved config before
+invoking `createHandler`. No need to call it manually.
+
+---
+
+## Two-Phase Processing Pattern
+
+Typography processing is split into two sequential phases. Both must run in order for full rule coverage.
+
+**Phase 1 — string rules** (`applyRules`): handles `replace`, `transform`, and `function`→`string` rules.
+Operates on raw text; protected regions (URLs, code, etc.) are shielded automatically.
+
+**Phase 2 — node rules** (`applyNodeRules`): handles `node` and `function`→`Node[]` rules.
+Expands text nodes into mixed text/element trees (e.g. wrapping `H[^2]O` into `H<sup>2</sup>O`).
+Must run after phase 1 because node expansion on unsettled text produces incorrect results.
+
+The helpers `joinNodes` / `splitNodes` from `@nkardaz/typography-rules/helpers` bridge sibling text
+nodes into a single string before phase 1, so rules can see context across node boundaries.
+
+For most cases `processElement` handles both phases and full traversal automatically:
+
+```typescript
+import { processElement } from '@nkardaz/typography-core';
+
+processElement(rootElement, 'en', { logs: false });
+```
+
+When building a custom plugin that needs finer control, the two phases can be called directly.
+This is exactly what `processElement` does internally at each level:
+
+```typescript
+import { joinNodes, splitNodes } from '@nkardaz/typography-rules/helpers';
+import { applyRules, applyNodeRules } from '@nkardaz/typography-core';
+import type { ElementNode, TextNode } from '@nkardaz/typography-rules';
+
+function processLevel(element: ElementNode, locale: string, config: ResolvedCoreConfig) {
+  const lang =
+    element.attrs?.['lang'] ??
+    element.attrs?.['language'] ??
+    element.attrs?.['locale'] ??
+    locale;
+
+  const textNodes = element.children.filter((c): c is TextNode => c.type === 'text');
+
+  if (textNodes.length > 0) {
+    // Phase 1 — join siblings → string rules → split back
+    const combined = joinNodes(textNodes);
+    const transformed = applyRules(combined, lang, config);
+    splitNodes(transformed, textNodes);
+
+    // Phase 2 — node-expanding rules
+    applyNodeRules(textNodes, element, lang, config);
+  }
+
+  // Recurse into non-text children with updated locale
+  for (const child of element.children) {
+    if (child.type !== 'text') {
+      processLevel(child as ElementNode, lang, config);
+    }
+  }
+}
+```
+
+> `applyNodeRules` operates on a single level only — it does not recurse.
+> Traversal and locale propagation are always the caller's responsibility.

package/dist/factory.d.ts

@@ -0,0 +1,7 @@
+import type { ResolvedCoreConfig, TypographyCoreOptions } from './types';
+export interface PluginFactory<TOptions extends TypographyCoreOptions, TTree> {
+    defaultOptions?: Partial<TOptions>;
+    createHandler: (config: ResolvedCoreConfig & TOptions) => (tree: TTree) => void;
+}
+export declare function createTypographyPlugin<TOptions extends TypographyCoreOptions, TTree>(factory: PluginFactory<TOptions, TTree>): (options?: Partial<TOptions>) => (tree: TTree) => void;
+//# sourceMappingURL=factory.d.ts.map

package/dist/index.cjs

@@ -0,0 +1,185 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  applyNodeRules: () => applyNodeRules,
+  applyRules: () => applyRules,
+  createTypographyPlugin: () => createTypographyPlugin,
+  getFrontmatterLocale: () => getFrontmatterLocale,
+  initRules: () => initRules,
+  processElement: () => processElement,
+  warning: () => warning
+});
+module.exports = __toCommonJS(index_exports);
+var import_typography_rules2 = require("@nkardaz/typography-rules");
+var import_helpers = require("@nkardaz/typography-rules/helpers");
+
+// src/factory.ts
+var import_typography_rules = require("@nkardaz/typography-rules");
+function createTypographyPlugin(factory) {
+  return function plugin(options = {}) {
+    const resolved = {
+      initTypographyRules: true,
+      initMarkupRules: false,
+      logs: false,
+      locale: "en",
+      plugins: [],
+      ...factory.defaultOptions,
+      ...options
+    };
+    resolved.locale = import_typography_rules.ALIAS.resolve(resolved.locale) ?? resolved.locale;
+    initRules(resolved);
+    return factory.createHandler(resolved);
+  };
+}
+
+// src/index.ts
+function initRules(config) {
+  if (config.initTypographyRules) {
+    (0, import_typography_rules2.initTypographyRules)();
+  }
+  if (config.initMarkupRules) {
+    (0, import_typography_rules2.initMarkupRules)();
+  }
+  config.plugins?.forEach((plugin) => plugin()());
+}
+function warning(message, showLogs) {
+  if (showLogs) {
+    console.warn(`[@nkardaz/typography] ${message}`);
+  }
+}
+function getFrontmatterLocale(data) {
+  if (!data) return void 0;
+  return (typeof data["locale"] === "string" ? data["locale"] : void 0) ?? (typeof data["lang"] === "string" ? data["lang"] : void 0) ?? (typeof data["language"] === "string" ? data["language"] : void 0);
+}
+function applyRules(text, locale, config) {
+  const key = import_typography_rules2.ALIAS.resolve(locale) ?? locale;
+  const rules = (0, import_typography_rules2.getWeightedRules)(key);
+  if (rules.length === 0) return text;
+  const [initialProtectedValue, protectedMatches] = (0, import_helpers.protect)(text, key);
+  let value = initialProtectedValue;
+  for (const item of rules) {
+    if (!item?.kind) {
+      if (config.logs) console.warn("[@nkardaz/typography] Skipping invalid rule:", item);
+      continue;
+    }
+    if (item.label && (0, import_typography_rules2.isRuleDisabled)(item.label)) continue;
+    if (item.kind === "node") continue;
+    try {
+      switch (item.kind) {
+        case "function": {
+          const funcItem = item;
+          const result = funcItem.rule(value, ...funcItem.args ?? []);
+          if (typeof result === "string") value = result;
+          break;
+        }
+        case "transform": {
+          const transformItem = item;
+          value = value.replace(transformItem.rule, (match, ...groups) => {
+            const regexArray = [match, ...groups];
+            return transformItem.transform(regexArray);
+          });
+          break;
+        }
+        case "replace": {
+          const replaceItem = item;
+          value = value.replace(replaceItem.rule, replaceItem.replacement);
+          break;
+        }
+      }
+    } catch (err) {
+      if (config.logs)
+        console.warn("[@nkardaz/typography] Rule threw an error, skipping:", item, err);
+    }
+  }
+  return (0, import_helpers.unprotect)(value, protectedMatches);
+}
+function applyNodeRules(textNodes, parent, locale, config) {
+  const key = import_typography_rules2.ALIAS.resolve(locale) ?? locale;
+  const rules = (0, import_typography_rules2.getWeightedRules)(key).filter(
+    (r) => r.kind === "node" || r.kind === "function"
+  );
+  if (rules.length === 0) return;
+  for (const textNode of textNodes) {
+    let current = [textNode];
+    for (const rule of rules) {
+      if (rule.label && (0, import_typography_rules2.isRuleDisabled)(rule.label)) continue;
+      const next = [];
+      for (const node of current) {
+        if (node.type !== "text") {
+          next.push(node);
+          continue;
+        }
+        const textValue = node.value;
+        let nodeList;
+        try {
+          if (rule.kind === "node") {
+            const nodeRule = rule;
+            nodeList = (0, import_typography_rules2.htmlNode)(textValue, {
+              expression: nodeRule.rule,
+              nodes: nodeRule.nodes
+            });
+          } else {
+            const funcRule = rule;
+            const result = funcRule.rule(textValue, ...funcRule.args ?? []);
+            if (typeof result === "string" || !Array.isArray(result)) {
+              next.push(node);
+              continue;
+            }
+            nodeList = result;
+          }
+        } catch (err) {
+          if (config.logs)
+            console.warn("[@nkardaz/typography] Node rule threw an error, skipping:", rule, err);
+          next.push(node);
+          continue;
+        }
+        if (nodeList.length === 1 && nodeList[0].type === "text" && nodeList[0].value === textValue) {
+          next.push(node);
+          continue;
+        }
+        for (const n of nodeList) next.push(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 processElement(element, locale, config) {
+  const lang = element.attrs?.["lang"] ?? element.attrs?.["language"] ?? element.attrs?.["locale"] ?? locale;
+  const textNodes = element.children.filter((c) => c.type === "text");
+  if (textNodes.length > 0) {
+    const combined = (0, import_helpers.joinNodes)(textNodes);
+    const transformed = applyRules(combined, lang, config);
+    (0, import_helpers.splitNodes)(transformed, textNodes);
+    applyNodeRules(textNodes, element, lang, config);
+  }
+  for (const child of element.children) {
+    if (child.type !== "text") {
+      processElement(child, lang, config);
+    }
+  }
+}
+//# sourceMappingURL=index.cjs.map

package/dist/index.d.ts

@@ -0,0 +1,53 @@
+import { type ElementNode, type TextNode } from '@nkardaz/typography-rules';
+import type { ResolvedCoreConfig } from './types';
+export * from './factory';
+export type * from './types';
+export declare function initRules(config: ResolvedCoreConfig): void;
+export declare function warning(message: string, showLogs: boolean): void;
+/**
+ * Resolve locale from a parsed frontmatter data object.
+ * Checks keys in order: `locale` → `lang` → `language`.
+ */
+export declare function getFrontmatterLocale(data: Record<string, unknown> | null): string | undefined;
+/**
+ * Apply all string-phase rules (replace / transform / function→string) to `text`.
+ * Protected regions (URLs, emails, code spans, …) are shielded before rules run.
+ *
+ * This is the only processing function that is truly framework-agnostic:
+ * it operates purely on strings and has no knowledge of any AST.
+ */
+export declare function applyRules(text: string, locale: string, config: Pick<ResolvedCoreConfig, 'logs'>): string;
+/**
+ * Apply node-phase rules (kind === 'node' | 'function'→Node[]) to a flat list
+ * of text nodes belonging to a single parent element, mutating the parent's
+ * children array in-place.
+ *
+ * This function operates on one level of the tree only — it does not recurse.
+ * Traversal and locale switching across element boundaries is the caller's
+ * responsibility (see `processElement`).
+ *
+ * Must be called *after* `applyRules` + `joinNodes`/`splitNodes` have already
+ * handled string-phase processing on the same text nodes.
+ *
+ * @param textNodes - Direct text-node children of `parent`, pre-filtered by the caller
+ * @param parent    - The element whose `children` array will be mutated on expansion
+ * @param locale    - Active locale for rule selection
+ * @param config    - Core config; only `logs` is used
+ */
+export declare function applyNodeRules(textNodes: TextNode[], parent: ElementNode, locale: string, config: Pick<ResolvedCoreConfig, 'logs'>): void;
+/**
+ * Recursively processes an element and all its descendants, applying both
+ * string-phase and node-phase typography rules.
+ *
+ * Mirrors the role of `processNode` in the remark plugin: it owns the locale
+ * stack, handles `lang`/`language`/`locale` attribute switching on child
+ * elements, and coordinates the two-phase pipeline for each level:
+ *   1. `joinNodes` → `applyRules` → `splitNodes`  (string phase)
+ *   2. `applyNodeRules`                            (node phase)
+ *
+ * @param element - The element to process; its `children` array is mutated in-place
+ * @param locale  - Inherited locale from the parent scope
+ * @param config  - Core config; only `logs` is used
+ */
+export declare function processElement(element: ElementNode, locale: string, config: Pick<ResolvedCoreConfig, 'logs'>): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.mjs

@@ -0,0 +1,171 @@
+// src/index.ts
+import {
+  getWeightedRules,
+  initTypographyRules,
+  initMarkupRules,
+  isRuleDisabled,
+  htmlNode,
+  ALIAS as ALIAS2
+} from "@nkardaz/typography-rules";
+import { joinNodes, protect, splitNodes, unprotect } from "@nkardaz/typography-rules/helpers";
+
+// src/factory.ts
+import { ALIAS } from "@nkardaz/typography-rules";
+function createTypographyPlugin(factory) {
+  return function plugin(options = {}) {
+    const resolved = {
+      initTypographyRules: true,
+      initMarkupRules: false,
+      logs: false,
+      locale: "en",
+      plugins: [],
+      ...factory.defaultOptions,
+      ...options
+    };
+    resolved.locale = ALIAS.resolve(resolved.locale) ?? resolved.locale;
+    initRules(resolved);
+    return factory.createHandler(resolved);
+  };
+}
+
+// src/index.ts
+function initRules(config) {
+  if (config.initTypographyRules) {
+    initTypographyRules();
+  }
+  if (config.initMarkupRules) {
+    initMarkupRules();
+  }
+  config.plugins?.forEach((plugin) => plugin()());
+}
+function warning(message, showLogs) {
+  if (showLogs) {
+    console.warn(`[@nkardaz/typography] ${message}`);
+  }
+}
+function getFrontmatterLocale(data) {
+  if (!data) return void 0;
+  return (typeof data["locale"] === "string" ? data["locale"] : void 0) ?? (typeof data["lang"] === "string" ? data["lang"] : void 0) ?? (typeof data["language"] === "string" ? data["language"] : void 0);
+}
+function applyRules(text, locale, config) {
+  const key = ALIAS2.resolve(locale) ?? locale;
+  const rules = getWeightedRules(key);
+  if (rules.length === 0) return text;
+  const [initialProtectedValue, protectedMatches] = protect(text, key);
+  let value = initialProtectedValue;
+  for (const item of rules) {
+    if (!item?.kind) {
+      if (config.logs) console.warn("[@nkardaz/typography] Skipping invalid rule:", item);
+      continue;
+    }
+    if (item.label && isRuleDisabled(item.label)) continue;
+    if (item.kind === "node") continue;
+    try {
+      switch (item.kind) {
+        case "function": {
+          const funcItem = item;
+          const result = funcItem.rule(value, ...funcItem.args ?? []);
+          if (typeof result === "string") value = result;
+          break;
+        }
+        case "transform": {
+          const transformItem = item;
+          value = value.replace(transformItem.rule, (match, ...groups) => {
+            const regexArray = [match, ...groups];
+            return transformItem.transform(regexArray);
+          });
+          break;
+        }
+        case "replace": {
+          const replaceItem = item;
+          value = value.replace(replaceItem.rule, replaceItem.replacement);
+          break;
+        }
+      }
+    } catch (err) {
+      if (config.logs)
+        console.warn("[@nkardaz/typography] Rule threw an error, skipping:", item, err);
+    }
+  }
+  return unprotect(value, protectedMatches);
+}
+function applyNodeRules(textNodes, parent, locale, config) {
+  const key = ALIAS2.resolve(locale) ?? locale;
+  const rules = getWeightedRules(key).filter(
+    (r) => r.kind === "node" || r.kind === "function"
+  );
+  if (rules.length === 0) return;
+  for (const textNode of textNodes) {
+    let current = [textNode];
+    for (const rule of rules) {
+      if (rule.label && isRuleDisabled(rule.label)) continue;
+      const next = [];
+      for (const node of current) {
+        if (node.type !== "text") {
+          next.push(node);
+          continue;
+        }
+        const textValue = node.value;
+        let nodeList;
+        try {
+          if (rule.kind === "node") {
+            const nodeRule = rule;
+            nodeList = htmlNode(textValue, {
+              expression: nodeRule.rule,
+              nodes: nodeRule.nodes
+            });
+          } else {
+            const funcRule = rule;
+            const result = funcRule.rule(textValue, ...funcRule.args ?? []);
+            if (typeof result === "string" || !Array.isArray(result)) {
+              next.push(node);
+              continue;
+            }
+            nodeList = result;
+          }
+        } catch (err) {
+          if (config.logs)
+            console.warn("[@nkardaz/typography] Node rule threw an error, skipping:", rule, err);
+          next.push(node);
+          continue;
+        }
+        if (nodeList.length === 1 && nodeList[0].type === "text" && nodeList[0].value === textValue) {
+          next.push(node);
+          continue;
+        }
+        for (const n of nodeList) next.push(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 processElement(element, locale, config) {
+  const lang = element.attrs?.["lang"] ?? element.attrs?.["language"] ?? element.attrs?.["locale"] ?? locale;
+  const textNodes = element.children.filter((c) => c.type === "text");
+  if (textNodes.length > 0) {
+    const combined = joinNodes(textNodes);
+    const transformed = applyRules(combined, lang, config);
+    splitNodes(transformed, textNodes);
+    applyNodeRules(textNodes, element, lang, config);
+  }
+  for (const child of element.children) {
+    if (child.type !== "text") {
+      processElement(child, lang, config);
+    }
+  }
+}
+export {
+  applyNodeRules,
+  applyRules,
+  createTypographyPlugin,
+  getFrontmatterLocale,
+  initRules,
+  processElement,
+  warning
+};
+//# sourceMappingURL=index.mjs.map

package/dist/types.d.ts

@@ -0,0 +1,9 @@
+export interface TypographyCoreOptions {
+    initTypographyRules?: boolean;
+    initMarkupRules?: boolean;
+    locale?: string;
+    plugins?: (() => () => void)[];
+    logs?: boolean;
+}
+export type ResolvedCoreConfig = Required<TypographyCoreOptions>;
+//# sourceMappingURL=types.d.ts.map

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@nkardaz/typography-core",
+  "version": "1.0.0",
+  "description": "Your package description here",
+  "license": "MIT",
+  "author": "Yalla Nkardaz",
+  "keywords": [
+    "typography",
+    "typographic",
+    "text-formatting",
+    "typesetting",
+    "english",
+    "russian",
+    "text"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DemerNkardaz/typography-core.git"
+  },
+  "homepage": "https://github.com/DemerNkardaz/typography-core#readme",
+  "bugs": {
+    "url": "https://github.com/DemerNkardaz/typography-core/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/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",
+    "prettier": "^3.0.0",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.60.1",
+    "vite-tsconfig-paths": "^6.1.1",
+    "vitest": "^4.1.8"
+  },
+  "dependencies": {
+    "@nkardaz/typography-rules": "1.0.0"
+  }
+}