@nkardaz/typography-rules 1.0.0

package/dist/functions/index.cjs

@@ -0,0 +1,514 @@
+"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/functions/index.ts
+var index_exports = {};
+__export(index_exports, {
+  chemNotation: () => chemNotation,
+  clearSpaces: () => clearSpaces,
+  resolvePlacement: () => resolvePlacement,
+  rubyText: () => rubyText,
+  runt: () => runt,
+  smartNumberGrouping: () => smartNumberGrouping,
+  smartQuotes: () => smartQuotes,
+  wrapWithTag: () => wrapWithTag,
+  wrapWithTagExpression: () => wrapWithTagExpression
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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
+var import_glyphs = require("../glyphs/index.cjs");
+function smartQuotes(text, {
+  outer = [import_glyphs.PUNCTUATION.en.leftSided.outerQuoteOpen, import_glyphs.PUNCTUATION.en.rightSided.outerQuoteClose],
+  inner = [import_glyphs.PUNCTUATION.en.leftSided.innerQuoteOpen, import_glyphs.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
+var import_glyphs2 = require("../glyphs/index.cjs");
+function clearSpaces(text, { spaces = import_glyphs2.SPACES.find("noBreak", "hair", "thin") ?? [import_glyphs2.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
+var import_glyphs3 = require("../glyphs/index.cjs");
+
+// 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 = import_glyphs3.SPACES.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;
+}
+//# sourceMappingURL=index.cjs.map

package/dist/functions/index.d.ts

@@ -0,0 +1,8 @@
+export * from './smartNumberGrouping';
+export * from './smartQuotes';
+export * from './clearSpaces';
+export * from './runt';
+export * from './wrapWithTag';
+export * from './rubyText';
+export * from './chemNotation';
+//# sourceMappingURL=index.d.ts.map