@nkardaz/typography-rules 1.0.0

package/dist/functions/index.mjs

@@ -0,0 +1,491 @@
+// src/functions/smartNumberGrouping.ts
+function smartNumberGrouping(text, { locale = "en-US", minLength = 5 }) {
+  return text.replace(
+    /(?<![\p{L}\d])([+\-\u2212]?)(\d(?:[\u00A0]?\d)*)([.,]\d+)?(?!\d)/gu,
+    (match, sign, rawInt, floatPart) => {
+      const intPart = rawInt.replace(/\u00A0/g, "");
+      if (intPart.length < minLength) return match;
+      const decimalDigits = floatPart ? floatPart.slice(1) : "";
+      const normalised = decimalDigits ? `${intPart}.${decimalDigits}` : intPart;
+      const num = Number(normalised);
+      if (!Number.isFinite(num)) return match;
+      const formatter = new Intl.NumberFormat(locale, {
+        maximumFractionDigits: decimalDigits.length,
+        minimumFractionDigits: decimalDigits.length
+      });
+      return (sign === "\u2212" ? "\u2212" : sign) + formatter.format(num);
+    }
+  );
+}
+
+// src/functions/smartQuotes.ts
+import { PUNCTUATION } from "../glyphs/index.mjs";
+function smartQuotes(text, {
+  outer = [PUNCTUATION.en.leftSided.outerQuoteOpen, PUNCTUATION.en.rightSided.outerQuoteClose],
+  inner = [PUNCTUATION.en.leftSided.innerQuoteOpen, PUNCTUATION.en.rightSided.innerQuoteClose]
+} = {}) {
+  let result = "";
+  const stack = [];
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    const prev = text[i - 1] ?? "";
+    const next = text[i + 1] ?? "";
+    if (char === '"') {
+      const afterSpace = prev === "" || /\s/.test(prev);
+      const beforeSpace = next === "" || /\s/.test(next);
+      let isOpen;
+      if (stack.length === 0) {
+        isOpen = true;
+      } else if (afterSpace && !beforeSpace) {
+        isOpen = true;
+      } else if (!afterSpace && beforeSpace) {
+        isOpen = false;
+      } else if (!afterSpace && !beforeSpace) {
+        isOpen = false;
+      } else {
+        isOpen = false;
+      }
+      if (isOpen) {
+        const q = stack.length === 0 ? outer : inner;
+        result += q[0];
+        stack.push('"');
+      } else {
+        const matchIdx = [...stack].reverse().indexOf('"');
+        if (matchIdx !== -1) {
+          stack.splice(stack.length - 1 - matchIdx, 1);
+        }
+        const q = stack.length === 0 ? outer : inner;
+        result += q[1];
+      }
+      continue;
+    }
+    if (char === "'") {
+      const insideDoubleQuotes = stack.includes('"');
+      const isApostrophe = /[a-zA-Z\u0430-\u044F\u0410-\u042F\u0451\u0401]/.test(prev) && /[a-zA-Z\u0430-\u044F\u0410-\u042F\u0451\u04010-9]/.test(next);
+      if (isApostrophe || !insideDoubleQuotes) {
+        result += char;
+        continue;
+      }
+      const lastDoubleIdx = stack.lastIndexOf('"');
+      const hasOpenSingle = stack.slice(lastDoubleIdx + 1).includes("'");
+      const isOpen = !hasOpenSingle;
+      if (isOpen) {
+        result += inner[0];
+        stack.push("'");
+      } else {
+        const matchIdx = [...stack].reverse().indexOf("'");
+        if (matchIdx !== -1) {
+          stack.splice(stack.length - 1 - matchIdx, 1);
+        }
+        result += inner[1];
+      }
+      continue;
+    }
+    result += char;
+  }
+  return result;
+}
+
+// src/functions/clearSpaces.ts
+import { SPACES } from "../glyphs/index.mjs";
+function clearSpaces(text, { spaces = SPACES.find("noBreak", "hair", "thin") ?? [SPACES._] } = {}) {
+  let result = text;
+  spaces.forEach((s) => {
+    const escaped = s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+    const regex = new RegExp(`${escaped}{2,}`, "g");
+    result = result.replace(regex, s);
+  });
+  return result;
+}
+
+// src/functions/runt.ts
+import { SPACES as SPACES2 } from "../glyphs/index.mjs";
+
+// src/functions/wrapWithTag.ts
+function wrapWithTag(text, settings = {}, tagSettings = {}) {
+  if ("expression" in settings) {
+    return wrapWithTagExpression(text, settings, tagSettings);
+  }
+  const { marker = "^", tag = "sup", wrapper = ["[", "]"] } = settings;
+  const result = [];
+  let i = 0;
+  while (i < text.length) {
+    const start = text.indexOf(wrapper[0] + marker, i);
+    if (start === -1) {
+      result.push({ type: "text", value: text.slice(i) });
+      break;
+    }
+    if (start > i) {
+      result.push({ type: "text", value: text.slice(i, start) });
+    }
+    let depth = 0;
+    let j = start;
+    let end = -1;
+    while (j < text.length) {
+      if (text[j] === wrapper[0]) depth++;
+      else if (text[j] === wrapper[1]) {
+        depth--;
+        if (depth === 0) {
+          end = j;
+          break;
+        }
+      }
+      j++;
+    }
+    if (end === -1) {
+      result.push({ type: "text", value: text.slice(start) });
+      break;
+    }
+    result.push({
+      type: tag,
+      data: { skipTypography: true },
+      ...tagSettings.className && { className: tagSettings.className },
+      ...tagSettings.attrs && { attrs: tagSettings.attrs },
+      children: wrapWithTag(text.slice(start + 2, end))
+    });
+    i = end + 1;
+  }
+  return result;
+}
+var TAG_OPEN = "<TAG>";
+var TAG_CLOSE = "</TAG>";
+function wrapWithTagExpression(text, { expression, tag = "sup", placement }, tagSettings = {}) {
+  const result = [];
+  const regex = new RegExp(
+    expression.source,
+    expression.flags.includes("g") ? expression.flags : expression.flags + "g"
+  );
+  let lastIndex = 0;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    if (match[0].length === 0) {
+      regex.lastIndex++;
+      continue;
+    }
+    if (match.index > lastIndex) {
+      result.push({ type: "text", value: text.slice(lastIndex, match.index) });
+    }
+    if (placement) {
+      result.push(...resolvePlacement(match, placement, tag, tagSettings));
+    } else {
+      result.push({
+        type: tag,
+        data: { skipTypography: true },
+        ...tagSettings.className && { className: tagSettings.className },
+        ...tagSettings.attrs && { attrs: tagSettings.attrs },
+        children: [{ type: "text", value: match[0] }]
+      });
+    }
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < text.length) {
+    result.push({ type: "text", value: text.slice(lastIndex) });
+  }
+  return result;
+}
+function resolvePlacement(match, placement, tag, tagSettings) {
+  const resolved = placement.replace(/\$(\d+)/g, (_, n) => match[Number(n)] ?? "");
+  const tagOpenIdx = resolved.indexOf(TAG_OPEN);
+  const tagCloseIdx = resolved.indexOf(TAG_CLOSE);
+  if (tagOpenIdx === -1 || tagCloseIdx === -1) {
+    return [{ type: "text", value: resolved }];
+  }
+  const nodes = [];
+  if (tagOpenIdx > 0) {
+    nodes.push({ type: "text", value: resolved.slice(0, tagOpenIdx) });
+  }
+  nodes.push({
+    type: tag,
+    data: { skipTypography: true },
+    ...tagSettings.className && { className: tagSettings.className },
+    ...tagSettings.attrs && { attrs: tagSettings.attrs },
+    children: [{ type: "text", value: resolved.slice(tagOpenIdx + TAG_OPEN.length, tagCloseIdx) }]
+  });
+  const after = resolved.slice(tagCloseIdx + TAG_CLOSE.length);
+  if (after) {
+    nodes.push({ type: "text", value: after });
+  }
+  return nodes;
+}
+
+// src/functions/runt.ts
+var NOWRAP_MARKER = "~";
+var NOWRAP_WRAPPER = ["[", "]"];
+function runt(text, { threshold = 10, space = SPACES2.noBreak, minLineLength = 75 * 2 } = {}) {
+  if (text.length < minLineLength) return [{ type: "text", value: text }];
+  const segmenter = new Intl.Segmenter(void 0, {
+    granularity: "word"
+  });
+  const words = [...segmenter.segment(text)].filter((s) => s.isWordLike).map((s) => ({
+    index: s.index,
+    word: s.segment,
+    length: s.segment.length
+  }));
+  if (words.length < 2) return [{ type: "text", value: text }];
+  const noBreakPositions = /* @__PURE__ */ new Set();
+  let nowrapRange = null;
+  const markSpaceBefore = (pos) => {
+    for (let i = pos - 1; i >= 0; i--) {
+      const char = text[i];
+      if (char && /\s/u.test(char)) {
+        noBreakPositions.add(i);
+        break;
+      }
+    }
+  };
+  const last = words.at(-1);
+  if ([...last.word].length >= threshold) {
+    markSpaceBefore(last.index);
+    return [{ type: "text", value: applyNoBreaks(text, noBreakPositions, space) }];
+  }
+  const limit = threshold / 1.25;
+  for (let i = words.length - 1; i > 0; i--) {
+    const word = words[i];
+    const prev = words[i - 1];
+    markSpaceBefore(word.index);
+    if ([...prev.word].length >= limit) {
+      markSpaceBefore(prev.index);
+      nowrapRange = {
+        start: prev.index,
+        end: word.index + word.word.length
+      };
+      break;
+    }
+  }
+  const processed = applyNoBreaks(text, noBreakPositions, space);
+  if (!nowrapRange) return [{ type: "text", value: processed }];
+  const marked = processed.slice(0, nowrapRange.start) + NOWRAP_WRAPPER[0] + NOWRAP_MARKER + processed.slice(nowrapRange.start, nowrapRange.end) + NOWRAP_WRAPPER[1] + processed.slice(nowrapRange.end);
+  return wrapWithTag(
+    marked,
+    {
+      marker: NOWRAP_MARKER,
+      tag: "span",
+      wrapper: NOWRAP_WRAPPER
+    },
+    {
+      attrs: { style: "white-space: nowrap;" }
+    }
+  );
+}
+function applyNoBreaks(text, positions, space) {
+  if (positions.size === 0) return text;
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    out += positions.has(i) ? space : text[i];
+  }
+  return out;
+}
+
+// src/functions/rubyText.ts
+function rubyText(text, { marker = ":", wrapper = ["[", "]"] } = {}, { className, attrs } = {}) {
+  const result = [];
+  let i = 0;
+  const open = wrapper[0] + marker;
+  while (i < text.length) {
+    const baseStart = text.indexOf(open, i);
+    if (baseStart === -1) {
+      result.push({ type: "text", value: text.slice(i) });
+      break;
+    }
+    if (baseStart > i) {
+      result.push({ type: "text", value: text.slice(i, baseStart) });
+    }
+    let depth = 0;
+    let j = baseStart;
+    let baseEnd = -1;
+    while (j < text.length) {
+      if (text[j] === wrapper[0]) depth++;
+      else if (text[j] === wrapper[1]) {
+        depth--;
+        if (depth === 0) {
+          baseEnd = j;
+          break;
+        }
+      }
+      j++;
+    }
+    if (baseEnd === -1) {
+      result.push({ type: "text", value: text.slice(baseStart) });
+      break;
+    }
+    const furiganaStart = text.indexOf(open, baseEnd + 1);
+    if (furiganaStart !== baseEnd + 1) {
+      result.push({ type: "text", value: text.slice(baseStart, baseEnd + 1) });
+      i = baseEnd + 1;
+      continue;
+    }
+    depth = 0;
+    j = furiganaStart;
+    let furiganaEnd = -1;
+    while (j < text.length) {
+      if (text[j] === wrapper[0]) depth++;
+      else if (text[j] === wrapper[1]) {
+        depth--;
+        if (depth === 0) {
+          furiganaEnd = j;
+          break;
+        }
+      }
+      j++;
+    }
+    if (furiganaEnd === -1) {
+      result.push({ type: "text", value: text.slice(baseStart) });
+      break;
+    }
+    const baseInner = text.slice(baseStart + open.length, baseEnd);
+    const furiganaInner = text.slice(furiganaStart + open.length, furiganaEnd);
+    const baseParts = baseInner.split("|");
+    const furiganaParts = furiganaInner.split("|");
+    const children = [];
+    for (let k = 0; k < baseParts.length; k++) {
+      children.push({
+        type: "rb",
+        data: { skipTypography: true },
+        children: [{ type: "text", value: baseParts[k] ?? "" }]
+      });
+      children.push({
+        type: "rt",
+        data: { skipTypography: true },
+        children: [{ type: "text", value: furiganaParts[k] ?? "" }]
+      });
+    }
+    result.push({
+      type: "ruby",
+      data: { skipTypography: true },
+      ...className && { className },
+      ...attrs && { attrs },
+      children
+    });
+    i = furiganaEnd + 1;
+  }
+  return result;
+}
+
+// src/functions/chemNotation.ts
+function parseScripts(content) {
+  const tokens = [];
+  let j = 0;
+  while (j < content.length) {
+    if (content[j] === "(") {
+      const close = content.indexOf(")", j);
+      if (close === -1) break;
+      const inner = content.slice(j + 1, close);
+      if (inner.startsWith("^")) {
+        tokens.push({ kind: "sup", value: inner.slice(1) });
+      } else if (inner.startsWith("_")) {
+        tokens.push({ kind: "sub", value: inner.slice(1) });
+      }
+      j = close + 1;
+    } else {
+      let k = j;
+      while (k < content.length && content[k] !== "(") k++;
+      const chunk = content.slice(j, k).trim();
+      if (chunk) tokens.push({ kind: "base", value: chunk });
+      j = k;
+    }
+  }
+  const baseIdx = tokens.findIndex((t) => t.kind === "base" && t.value);
+  if (baseIdx === -1) return null;
+  const base = tokens[baseIdx].value;
+  const left = tokens.slice(0, baseIdx);
+  const right = tokens.slice(baseIdx + 1);
+  return {
+    base,
+    supL: left.find((t) => t.kind === "sup")?.value ?? "",
+    subL: left.find((t) => t.kind === "sub")?.value ?? "",
+    supR: right.find((t) => t.kind === "sup")?.value ?? "",
+    subR: right.find((t) => t.kind === "sub")?.value ?? ""
+  };
+}
+function splitParts(content) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] === "(") depth++;
+    else if (content[i] === ")") depth--;
+    else if (content[i] === "-" && depth === 0) {
+      parts.push(content.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(content.slice(start));
+  return parts.map((p) => p.trim()).filter(Boolean);
+}
+function textNode(value) {
+  return { type: "text", value };
+}
+function mnNode(value) {
+  return { type: "mn", data: { skipTypography: true }, children: [textNode(value)] };
+}
+function buildMmultiscripts({ base, supL, subL, supR, subR }) {
+  const baseNode = { type: "mi", data: { skipTypography: true }, children: [textNode(base)] };
+  const children = [baseNode, mnNode(subR), mnNode(supR)];
+  if (subL || supL) {
+    children.push({ type: "mprescripts", data: { skipTypography: true }, children: [] });
+    children.push(mnNode(subL), mnNode(supL));
+  }
+  return { type: "mmultiscripts", data: { skipTypography: true }, children };
+}
+function chemNotation(text, { marker = "%", wrapper = ["[", "]"] } = {}, { className, attrs } = {}) {
+  const result = [];
+  const open = wrapper[0] + marker;
+  const openChar = wrapper[0];
+  const closeChar = wrapper[1];
+  let i = 0;
+  while (i < text.length) {
+    const start = text.indexOf(open, i);
+    if (start === -1) {
+      result.push(textNode(text.slice(i)));
+      break;
+    }
+    if (start > i) result.push(textNode(text.slice(i, start)));
+    let depth = 0;
+    let j = start;
+    let end = -1;
+    while (j < text.length) {
+      if (text[j] === openChar) depth++;
+      else if (text[j] === closeChar) {
+        depth--;
+        if (depth === 0) {
+          end = j;
+          break;
+        }
+      }
+      j++;
+    }
+    if (end === -1) {
+      result.push(textNode(text.slice(start)));
+      break;
+    }
+    const content = text.slice(start + open.length, end);
+    const parts = splitParts(content);
+    const parsed = parts.map(parseScripts).filter((p) => p !== null);
+    if (!parsed.length) {
+      result.push(textNode(text.slice(start, end + 1)));
+      i = end + 1;
+      continue;
+    }
+    result.push({
+      type: "math",
+      data: { skipTypography: true },
+      ...className && { className },
+      ...attrs && { attrs },
+      children: parsed.map(buildMmultiscripts)
+    });
+    i = end + 1;
+  }
+  return result;
+}
+export {
+  chemNotation,
+  clearSpaces,
+  resolvePlacement,
+  rubyText,
+  runt,
+  smartNumberGrouping,
+  smartQuotes,
+  wrapWithTag,
+  wrapWithTagExpression
+};
+//# sourceMappingURL=index.mjs.map

package/dist/functions/rubyText.d.ts

@@ -0,0 +1,11 @@
+import type { Node, TagSettings, RubyTextSettings } from '@/types';
+/**
+ * Parses ruby annotation syntax (base text and reading) and converts it to a <ruby> structure.
+ * Expected format: [marker]base|text[marker]reading
+ * * @param text - The input string containing ruby syntax
+ * @param settings - Configuration for the marker and wrapper delimiters
+ * @param tagSettings - Optional class name and attributes for the <ruby> element
+ * @returns An array of nodes containing text and <ruby> components (<rb>, <rt>)
+ */
+export declare function rubyText(text: string, { marker, wrapper }?: RubyTextSettings, { className, attrs }?: TagSettings): Node[];
+//# sourceMappingURL=rubyText.d.ts.map

package/dist/functions/runt.d.ts

@@ -0,0 +1,3 @@
+import type { Node, RuntSettings } from '@/types';
+export declare function runt(text: string, { threshold, space, minLineLength }?: RuntSettings): Node[];
+//# sourceMappingURL=runt.d.ts.map

package/dist/functions/smartNumberGrouping.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Inserts locale-aware grouping into large numeric sequences inside text,
+ * delegating all formatting to `Intl.NumberFormat`.
+ *
+ * @param text - Input text that may contain numbers.
+ * @param locale - BCP 47 locale tag used by `Intl.NumberFormat` (e.g. `"ru"`, `"en-US"`).
+ *
+ * @param settings - Formatting options:
+ * - `minLength` — minimum integer digit count before grouping is applied (default: 5)
+ *
+ * @returns Text with formatted numbers using locale-appropriate grouping separators.
+ *
+ * @example
+ * smartNumberGrouping("Price: 1234567", "en-US");
+ * // "Price: 1,234,567"
+ *
+ * @example
+ * smartNumberGrouping("Цена: 1234567.891011", "ru");
+ * // "Цена: 1 234 567,891011"
+ */
+export declare function smartNumberGrouping(text: string, { locale, minLength }: {
+    locale?: string | undefined;
+    minLength?: number | undefined;
+}): string;
+//# sourceMappingURL=smartNumberGrouping.d.ts.map

package/dist/functions/smartQuotes.d.ts

@@ -0,0 +1,29 @@
+import type { QuoteSettings } from '@/types';
+/**
+ * Smart typographic quotes replacement.
+ *
+ * Converts straight quotes (`"` and `'`) into typographically correct
+ * opening/closing quotes based on nesting context and surrounding characters.
+ *
+ * Supports:
+ * - Outer and inner quote levels
+ * - Nested quotation handling
+ * - Apostrophe detection for contractions (e.g. don't, it's)
+ *
+ * @param text - Input string containing raw quotes.
+ * @param quotes - Quote configuration for outer and inner levels.
+ * @param quotes.outer - Pair of outer quotes: [open, close]
+ * @param quotes.inner - Pair of inner quotes: [open, close]
+ *
+ * @returns String with typographically corrected quotes.
+ *
+ * @example
+ * smartQuotes('"Hello"');
+ * // «Hello» (depending on configuration)
+ *
+ * @example
+ * smartQuotes('"He said \'hi\'"');
+ * // «He said „hi“»
+ */
+export declare function smartQuotes(text: string, { outer, inner, }?: QuoteSettings): string;
+//# sourceMappingURL=smartQuotes.d.ts.map

package/dist/functions/wrapWithTag.d.ts

@@ -0,0 +1,42 @@
+import type { Node, TagSettings, WrapWithTagsSettings, WrapWithTagExpressionSettings } from '@/types';
+/**
+ * Parses text and wraps content found within specific markers into HTML tags.
+ * Supports nested structures by recursively calling itself.
+ *
+ * @param text The input string to parse
+ * @param settings Configuration for the marker, tag type, and wrapper delimiters
+ * @param tagSettings Optional class name and attributes for the generated tag
+ * @returns An array of nodes representing the processed text and wrapped elements
+ */
+export declare function wrapWithTag(text: string): Node[];
+/**
+ * Parses text using a custom RegExp and wraps matched regions into HTML tags.
+ *
+ * When `placement` is provided, it acts as a structural template:
+ * - `$1`, `$2`, etc. reference capture groups from `expression`
+ * - `<TAG>...</TAG>` marks which part of the match gets wrapped
+ *
+ * @example
+ * // expression: /([\d\s]м)(2|3)/g, tag: 'sup', placement: '$1<TAG>$2</TAG>'
+ * // 'Площадь 25м2' → 'Площадь 25м<sup>2</sup>'
+ *
+ * @param text The input string to parse
+ * @param settings Configuration with expression, tag, and optional placement
+ * @param tagSettings Optional class name and attributes for the generated tag
+ * @returns An array of nodes representing the processed text and wrapped elements
+ */
+export declare function wrapWithTag(text: string, settings: WrapWithTagsSettings, tagSettings?: TagSettings): Node[];
+export declare function wrapWithTag(text: string, settings: WrapWithTagExpressionSettings, tagSettings?: TagSettings): Node[];
+export declare function wrapWithTagExpression(text: string, { expression, tag, placement }: WrapWithTagExpressionSettings, tagSettings?: TagSettings): Node[];
+/**
+ * Resolves a placement template into an array of nodes.
+ *
+ * Replaces `$N` references with capture groups and wraps the content
+ * inside `<TAG>...</TAG>` into an element node.
+ *
+ * @example
+ * // placement: '$1<TAG>$2</TAG>', match for /([\d\s]м)(2|3)/
+ * // → [TextNode('25м'), ElementNode('sup', [TextNode('2')])]
+ */
+export declare function resolvePlacement(match: RegExpExecArray, placement: string, tag: string, tagSettings: TagSettings): Node[];
+//# sourceMappingURL=wrapWithTag.d.ts.map