@nkardaz/typography-rules 1.0.0

package/dist/index.cjs

@@ -0,0 +1,985 @@
+"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, {
+  ALIAS: () => ALIAS,
+  clearBlacklist: () => clearBlacklist,
+  createAlias: () => createAlias,
+  defaultRuleKeys: () => defaultRuleKeys,
+  disableRule: () => disableRule,
+  enableRule: () => enableRule,
+  getWeightedRules: () => getWeightedRules,
+  htmlNode: () => htmlNode,
+  initMarkupRules: () => initMarkupRules,
+  initTypographyRules: () => initTypographyRules,
+  isGloballyDisabled: () => isGloballyDisabled,
+  isRuleDisabled: () => isRuleDisabled,
+  newRule: () => newRule,
+  nodeToMdast: () => nodeToMdast,
+  registerRule: () => registerRule,
+  renderNode: () => renderNode,
+  renderNodes: () => renderNodes,
+  resetTypographyRules: () => resetTypographyRules,
+  rulesBase: () => rulesBase,
+  rulesCount: () => rulesCount,
+  rulesHas: () => rulesHas,
+  toggleRule: () => toggleRule,
+  typographyRules: () => typographyRules
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/api/newRule.ts
+function newRule(label, rule, second, weight = 0) {
+  if (typeof rule === "function") {
+    return {
+      label,
+      kind: "function",
+      rule,
+      args: Array.isArray(second) ? second : [],
+      weight
+    };
+  }
+  if (typeof second === "string") {
+    return {
+      label,
+      kind: "replace",
+      rule,
+      replacement: second,
+      weight
+    };
+  }
+  return {
+    label,
+    kind: "transform",
+    rule,
+    transform: second,
+    weight
+  };
+}
+
+// src/typography/aliases.ts
+function createAlias(map) {
+  const normalized = Object.fromEntries(
+    Object.entries(map).map(([key, values]) => [
+      key.toLowerCase(),
+      values.map((v) => v.toLowerCase())
+    ])
+  );
+  const methods = {
+    /**
+     * Checks whether an alias exists in the map,
+     * either as a root key or as an alternative name.
+     *
+     * @param alias - The alias to look up (case-insensitive).
+     * @returns `true` if the alias is found, `false` otherwise.
+     *
+     * @example
+     * ALIAS.has('English') // true
+     * ALIAS.has('fr')      // false
+     */
+    has(alias) {
+      const a = alias.toLowerCase();
+      if (a in normalized) return true;
+      return Object.values(normalized).some((vals) => vals.includes(a));
+    },
+    /**
+     * Resolves an alias to its root key.
+     *
+     * @param alias - The alias to resolve (case-insensitive).
+     * @returns The root key if found, `undefined` otherwise.
+     *
+     * @example
+     * ALIAS.resolve('Russian') // 'ru'
+     * ALIAS.resolve('ru-RU')   // 'ru'
+     * ALIAS.resolve('fr')      // undefined
+     */
+    resolve(alias) {
+      const a = alias.toLowerCase();
+      if (a in normalized) return a;
+      return Object.keys(normalized).find((k) => {
+        const values = normalized[k];
+        return Array.isArray(values) && values.includes(a);
+      });
+    },
+    /**
+     * Adds one or more alternative names to an existing or new root key.
+     * All values are automatically lowercased.
+     *
+     * @param root - The root key to add aliases to.
+     * @param aliases - One or more alternative names to register.
+     *
+     * @example
+     * ALIAS.push('ru', 'Рус', 'ру')
+     * ALIAS.ru // ['ru-ru', 'russian', 'русский', 'рус', 'ру']
+     */
+    push(root2, ...aliases) {
+      for (const alias of aliases) {
+        const a = alias.toLowerCase();
+        const r = root2.toLowerCase();
+        if (a in normalized) {
+          normalized[a]?.push(r);
+        } else {
+          normalized[a] = [r];
+        }
+      }
+    },
+    /**
+     * Normalizes one or more strings to lowercase.
+     *
+     * @param alias - One or more strings to normalize.
+     * @returns An array of lowercased strings.
+     *
+     * @example
+     * ALIAS.normalize('English', 'RU-RU') // ['english', 'ru-ru']
+     */
+    normalize(...alias) {
+      return alias.map((a) => a.toLowerCase());
+    }
+  };
+  return new Proxy(methods, {
+    get(target, prop) {
+      if (prop in target) return target[prop];
+      return normalized[prop];
+    },
+    has(_target, prop) {
+      return prop in normalized;
+    },
+    ownKeys() {
+      return [...Object.keys(normalized), ...Object.keys(methods)];
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      if (prop in normalized || prop in methods) {
+        return { enumerable: true, configurable: true };
+      }
+      return void 0;
+    }
+  });
+}
+var ALIAS = createAlias({
+  ru: ["ru-RU", "Russian", "\u0420\u0443\u0441\u0441\u043A\u0438\u0439"],
+  en: ["en-US", "English"],
+  ang: ["\xC6nglis\u010B", "\xC6nglisc", "Old English"]
+});
+
+// src/typography/store.ts
+var _rules = { common: [] };
+var _cache = /* @__PURE__ */ new Map();
+var typographyRules = new Proxy(_rules, {
+  set(target, locale3, value) {
+    target[locale3] = value;
+    _cache.delete(locale3);
+    if (locale3 !== "common") _cache.delete("common");
+    return true;
+  }
+});
+function getWeightedRules(locale3) {
+  if (_cache.has(locale3)) return _cache.get(locale3);
+  const common = _rules["common"] ?? [];
+  const localized = _rules[locale3] ?? [];
+  if (common.length === 0 && localized.length === 0) return [];
+  const result = [...common, ...localized].sort((a, b) => {
+    const weightA = a.weight ?? 0;
+    const weightB = b.weight ?? 0;
+    return weightA !== weightB ? weightA - weightB : 0;
+  });
+  _cache.set(locale3, result);
+  return result;
+}
+function resetTypographyRules() {
+  for (const key in _rules) {
+    _rules[key] = [];
+  }
+  _cache.clear();
+}
+function rulesHas(locale3) {
+  return !!_rules[locale3];
+}
+function rulesCount(locale3) {
+  return _rules[locale3]?.length ?? 0;
+}
+
+// src/api/registerRule.ts
+function registerRule(locale3, ...rules) {
+  const key = ALIAS.resolve(locale3) ?? locale3;
+  if (!typographyRules[key]) typographyRules[key] = [];
+  typographyRules[key].push(...rules);
+}
+function rulesBase(locale3, base, label, excludes, ...rules) {
+  const localeKey = ALIAS.resolve(locale3) ?? locale3;
+  const baseKey = ALIAS.resolve(base) ?? base;
+  const baseRules = (typographyRules[baseKey] ?? []).filter((rule) => !excludes?.includes(rule.label)).map((rule) => {
+    if (!label) return rule;
+    const shallow = { ...rule };
+    if (shallow.label) {
+      shallow.label = shallow.label.replace(label.expression, label.replacement);
+    }
+    return shallow;
+  });
+  registerRule(localeKey, ...baseRules, ...rules);
+}
+
+// src/api/blacklist.ts
+function createNode() {
+  return {
+    children: /* @__PURE__ */ new Map(),
+    end: false
+  };
+}
+var root = createNode();
+var globalDisabled = false;
+function getParts(rule) {
+  return rule.split("/").filter(Boolean);
+}
+function disableRule(rule) {
+  if (rule === "*") {
+    globalDisabled = true;
+    return;
+  }
+  let node = root;
+  for (const part of getParts(rule)) {
+    if (!node.children.has(part)) {
+      node.children.set(part, createNode());
+    }
+    node = node.children.get(part);
+  }
+  node.end = true;
+}
+function enableRule(rule) {
+  if (rule === "*") {
+    globalDisabled = false;
+    return;
+  }
+  const stack = [];
+  let node = root;
+  for (const part of getParts(rule)) {
+    if (!node.children.has(part)) return;
+    stack.push({ node, part });
+    node = node.children.get(part);
+  }
+  node.end = false;
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const entry = stack[i];
+    if (!entry) continue;
+    const { node: parent, part } = entry;
+    const child = parent.children.get(part);
+    if (child.end || child.children.size > 0) break;
+    parent.children.delete(part);
+  }
+}
+function toggleRule(rule) {
+  if (isRuleDisabled(rule)) {
+    enableRule(rule);
+  } else {
+    disableRule(rule);
+  }
+}
+function isRuleDisabled(rule) {
+  if (globalDisabled) return true;
+  let node = root;
+  for (const part of getParts(rule)) {
+    if (node.end) return true;
+    if (!node.children.has(part)) return false;
+    node = node.children.get(part);
+  }
+  return node.end;
+}
+function isGloballyDisabled() {
+  return globalDisabled;
+}
+function clearBlacklist() {
+  globalDisabled = false;
+  root.children.clear();
+  root.end = false;
+}
+
+// src/typography/sets/index.ts
+var sets_exports = {};
+__export(sets_exports, {
+  ang: () => ang_default,
+  common: () => common_default2,
+  en: () => en_default2,
+  ru: () => ru_default2
+});
+
+// src/typography/sets/ang.ts
+var ang_default = [
+  newRule("/\xE6nglis\u010B/articles/\xFEe", /\s+The\s+/g, ` \xDE\u0364 `),
+  newRule("/\xE6nglis\u010B/articles/\xFEe", /\s+the\s+/g, ` \xFE\u0364 `),
+  newRule("/\xE6nglis\u010B/articles/\xFEe", /\s+Þe\s+/g, ` \xDE\u0364 `),
+  newRule("/\xE6nglis\u010B/articles/\xFEe", /\s+þe\s+/g, ` \xFE\u0364 `)
+];
+
+// src/typography/sets/common.ts
+var import_functions = require("./functions/index.cjs");
+var import_glyphs2 = require("./glyphs/index.cjs");
+
+// src/typography/expressions/common.ts
+var import_glyphs = require("./glyphs/index.cjs");
+var PARTS = {
+  numerals: "[" + import_glyphs.RANGES.common.DIGITS.join("") + "]+",
+  interNumber: "[" + import_glyphs.MATHS.minus + import_glyphs.DASHES.en + "]",
+  walletSymbols: import_glyphs.WALLET.SYMBOL.values().map((s) => RegExp.escape(s)).join("|"),
+  walletISO: import_glyphs.WALLET.ISO.join("|"),
+  leftBrackets: RegExp.escape(import_glyphs.BRACKETS.common.left.join("")),
+  rightBrackets: RegExp.escape(import_glyphs.BRACKETS.common.right.join("")),
+  percentLike: "[" + import_glyphs.CHARACTERS.find("percent", "permil", "perTenThousand")?.join("") + "]",
+  expressivePunctuation: "[" + import_glyphs.PUNCTUATION.common.rightSided.find(
+    "exclamation",
+    "doubleExclamation",
+    "exclamationQuestion",
+    "question",
+    "doubleQuestion",
+    "questionExclamation",
+    "reversedQuestion",
+    "interrobang"
+  )?.join("") + "]",
+  get number() {
+    const value = `([${import_glyphs.MATHS.minus}]?${PARTS.numerals})`;
+    Object.defineProperty(this, "number", { value, enumerable: true, configurable: false });
+    return value;
+  }
+};
+var EXPRESSIONS = {
+  plusMinus: new RegExp(`(\\+[-${import_glyphs.MATHS.minus}])`, "g"),
+  minusPlus: new RegExp(`([-${import_glyphs.MATHS.minus}]\\+)`, "g"),
+  sectionNumeral: new RegExp(`(${import_glyphs.CHARACTERS.section})\\s*((?:${PARTS.numerals}\\s*)*)`, "g"),
+  percentValue: new RegExp(`${PARTS.number}\\s*(${PARTS.percentLike})`, "g"),
+  numeralsRange: new RegExp(`(${PARTS.numerals})-(${PARTS.numerals})`, "g"),
+  ellipsisRange: new RegExp(`${PARTS.number + PARTS.interNumber + PARTS.number}`, "g"),
+  multipleEllipsis: new RegExp(`${import_glyphs.PUNCTUATION.common.rightSided.ellipsis}{2,}`, "g"),
+  walletSymbolBeforeValue: new RegExp(`(${PARTS.walletSymbols})\\s*(\\d[\\d.]*)`, "g"),
+  walletSymbolAfterValue: new RegExp(`(\\d+)\\s*(${PARTS.walletSymbols})`, "g"),
+  walletISOBeforeValue: new RegExp(`(${PARTS.walletISO})\\s*(\\d[\\d.]*)`, "g"),
+  walletISOAfterValue: new RegExp(`(\\d+)\\s*(${PARTS.walletISO})`, "g"),
+  expressiveAposiopesis: new RegExp(
+    `(${PARTS.expressivePunctuation})\\s*(?:${import_glyphs.PUNCTUATION.common.rightSided.ellipsis}|\\.{1,})[.${import_glyphs.PUNCTUATION.common.rightSided.ellipsis}]*`,
+    "g"
+  ),
+  backwardsExpressiveAposiopesis: new RegExp(
+    `(?:${import_glyphs.PUNCTUATION.common.rightSided.ellipsis}|\\.{1,})[.${import_glyphs.PUNCTUATION.common.rightSided.ellipsis}]*\\s*(${PARTS.expressivePunctuation})`,
+    "g"
+  ),
+  temperature: new RegExp(`(\\d+)\\s*(${import_glyphs.TEMPERATURES.join()})`, "g")
+};
+var common_default = EXPRESSIONS;
+
+// src/typography/sets/common.ts
+var common_default2 = [
+  // Whitespace cleanup
+  // newRule(/\s+/g, SPACES._),
+  newRule("/common/space/cleanup/multiple", import_functions.clearSpaces),
+  newRule("/common/space/cleanup/trim", /^\s|\s$/g, import_glyphs2.NONE),
+  // Math
+  // Minus sign for negative numbers
+  newRule("/common/number/negative", /(?<!\d)-(\d+)/g, `${import_glyphs2.MATHS.minus}$1`),
+  // En dash for ranges, e.g. 1–2
+  newRule("/common/number/range/en-dash", common_default.numeralsRange, `$1${import_glyphs2.DASHES.en}$2`),
+  // Ellipsis for ranges, e.g. −2…3
+  newRule(
+    "/common/number/range/ellipsis-on-negative",
+    common_default.ellipsisRange,
+    `$1${import_glyphs2.PUNCTUATION.common.rightSided.ellipsis}$2`
+  ),
+  newRule("/common/number/dimension", /(\d+)\s*(?:x|х)\s*(\d+)/g, `$1${import_glyphs2.MATHS.multiply}$2`),
+  newRule("/common/number/multiply", /(\d+\s*)(?:\*)(\s*\d+)/g, `$1${import_glyphs2.MATHS.multiply}$2`),
+  newRule("/common/number/fraction", /(\d+)\/(\d+)/g, `$1${import_glyphs2.MATHS.fractionSlash}$2`),
+  newRule("/common/symbol/copyright", /\((?:c|с)\)/g, import_glyphs2.CHARACTERS.copyright),
+  newRule("/common/symbol/trademark", /\((?:tm|тм)\)/g, import_glyphs2.CHARACTERS.trademark),
+  newRule("/common/symbol/registered", /\(r\)/g, import_glyphs2.CHARACTERS.registered),
+  newRule("/common/symbol/section", /\(s\)/g, import_glyphs2.CHARACTERS.section),
+  newRule("/common/symbol/math/plus-minus", common_default.plusMinus, import_glyphs2.MATHS.plusMinus),
+  newRule("/common/symbol/math/minus-plus", common_default.minusPlus, import_glyphs2.MATHS.minusPlus),
+  // Generic Typography
+  // Em dash replacing double hyphen
+  newRule("/common/punctuation/dashes/em-dash", /--/g, import_glyphs2.DASHES.em),
+  // Fix too large dots count
+  newRule("/common/punctuation/dots/overload", /\.{4,}/g, "..."),
+  // Ellipsis replacing three dots
+  newRule("/common/punctuation/dots/ellipsis", /\.\.\./g, import_glyphs2.PUNCTUATION.common.rightSided.ellipsis),
+  // Fix multiple ellipses
+  newRule(
+    "/common/punctuation/dots/ellipsis-overload",
+    common_default.multipleEllipsis,
+    import_glyphs2.PUNCTUATION.common.rightSided.ellipsis
+  ),
+  // Apostrophe replacing single straight quote
+  newRule("/common/punctuation/apostrophe", /'/g, import_glyphs2.PUNCTUATION.common.generic.apostrophe, 200),
+  newRule(
+    "/common/symbol/section/value",
+    common_default.sectionNumeral,
+    (match) => {
+      const numero = match[1];
+      const numeral = match[2].replace(/\s+/g, "");
+      return `${numero}${import_glyphs2.SPACES.noBreakNarrow}${numeral}`;
+    },
+    1
+  ),
+  // Runt
+  newRule("/common/typography/runt", import_functions.runt, void 0, Infinity)
+];
+
+// src/typography/sets/en.ts
+var import_functions2 = require("./functions/index.cjs");
+var import_glyphs4 = require("./glyphs/index.cjs");
+
+// src/typography/expressions/en.ts
+var import_glyphs3 = require("./glyphs/index.cjs");
+var SI_PREFIX = "Y|Z|E|P|T|G|M|k|h|da|d|c|m|\u03BC|n|p|f|a|z|y";
+var SI_BASE = [
+  "g|t",
+  "m",
+  "s|min|h",
+  "N",
+  "Pa",
+  "J",
+  "W",
+  "A|V|\u03A9|F|H|C|T|Wb",
+  "Hz",
+  "mol|cd|rad|sr"
+].join("|");
+var SI_UNIT = `(?:${SI_PREFIX})?(?:${SI_BASE})`;
+var SI_OPERAND = `(?:${SI_UNIT})(?:\\^[\\d]+)?`;
+var PARTS2 = {
+  ...PARTS,
+  leftPunctuation: RegExp.escape(import_glyphs3.PUNCTUATION.get("en", "leftSided").join("")),
+  rightPunctuation: RegExp.escape(import_glyphs3.PUNCTUATION.get("en", "rightSided").join("")),
+  get leftChars() {
+    const value = PARTS2.leftPunctuation + PARTS2.leftBrackets;
+    Object.defineProperty(this, "leftChars", { value, enumerable: true, configurable: false });
+    return value;
+  },
+  get rightChars() {
+    const value = PARTS2.rightPunctuation + PARTS2.rightBrackets;
+    Object.defineProperty(this, "rightChars", { value, enumerable: true, configurable: false });
+    return value;
+  }
+};
+var EXPRESSIONS2 = {
+  ...EXPRESSIONS,
+  numberNumeral: new RegExp(`(${import_glyphs3.CHARACTERS.number})\\s*(${PARTS2.numerals})`, "g"),
+  invalidPunctuationSpacing: new RegExp(
+    `(?<=[${PARTS2.leftChars}])\\s+|(?<!\\s)\\s(?=[${PARTS2.rightChars}])`,
+    "g"
+  ),
+  siUnitMul: new RegExp(`(${SI_OPERAND})\\*(${SI_OPERAND}(?:\\/${SI_OPERAND})*)`, "g"),
+  siUnitDiv: new RegExp(`(${SI_OPERAND}(?:\\/${SI_OPERAND})*)\\*(${SI_OPERAND})`, "g"),
+  siUnitBase: new RegExp(`(\\d+)\\s*(${SI_UNIT})(?![/*])`, "g"),
+  siUnitPowAfterNum: new RegExp(`(\\d+)\\s*(${SI_UNIT})(\\d+)`, "g"),
+  siUnitPow: new RegExp(`(?<!\\d\\s*)(${SI_UNIT})(\\d+)`, "g")
+};
+var en_default = EXPRESSIONS2;
+
+// src/typography/sets/en.ts
+var locale = "en-US";
+var en_default2 = [
+  newRule("/english/currency/wallet/symbol-flip", en_default.walletSymbolAfterValue, `$2$1`),
+  newRule("/english/currency/wallet/iso-flip", en_default.walletISOBeforeValue, `$2$1`),
+  newRule("/english/currency/wallet/symbol-value", en_default.walletSymbolBeforeValue, `$1$2`),
+  newRule(
+    "/english/currency/wallet/iso-value",
+    en_default.walletISOAfterValue,
+    `$1${import_glyphs4.SPACES.noBreak}$2`
+  ),
+  newRule("/english/number/groups", import_functions2.smartNumberGrouping, [{ locale }]),
+  newRule("/english/metric/si-unit/base", en_default.siUnitBase, `$1${import_glyphs4.SPACES.noBreakNarrow}$2`),
+  newRule("/english/metric/si-unit/n*n-n", en_default.siUnitMul, `$1${import_glyphs4.CHARACTERS.middleDot}$2`),
+  newRule("/english/metric/si-unit/n-n*n", en_default.siUnitDiv, `$1${import_glyphs4.CHARACTERS.middleDot}$2`),
+  newRule(
+    "/english/metric/si-unit/pow-after-value",
+    import_functions2.wrapWithTag,
+    [
+      {
+        expression: en_default.siUnitPowAfterNum,
+        tag: "sup",
+        placement: `$1${import_glyphs4.SPACES.noBreakNarrow}$2<TAG>$3</TAG>`
+      }
+    ],
+    -1
+  ),
+  newRule(
+    "/english/metric/si-unit/pow",
+    import_functions2.wrapWithTag,
+    [
+      {
+        expression: en_default.siUnitPow,
+        tag: "sup",
+        placement: `$1<TAG>$2</TAG>`
+      }
+    ],
+    -1
+  ),
+  newRule("/english/scientific/temperature/value", en_default.temperature, `$1$2`),
+  newRule("/english/symbol/percent-like/value", en_default.percentValue, `$1$2`),
+  newRule("/english/symbol/hash/value", en_default.numberNumeral, `$1$2`),
+  newRule("/english/number/division", /(\d+\s*)(?:\/)(\s*\d+)/g, `$1${import_glyphs4.MATHS.obelus}$2`),
+  newRule(
+    "/english/number/division-times",
+    /(\d+\s*)(?:\/\*)(\s*\d+)/g,
+    `$1${import_glyphs4.MATHS.divisionTimes}$2`
+  ),
+  newRule(
+    "/english/punctuation/quotes",
+    import_functions2.smartQuotes,
+    [
+      {
+        outer: [import_glyphs4.PUNCTUATION.en.leftSided.outerQuoteOpen, import_glyphs4.PUNCTUATION.en.rightSided.outerQuoteClose],
+        inner: [import_glyphs4.PUNCTUATION.en.leftSided.innerQuoteOpen, import_glyphs4.PUNCTUATION.en.rightSided.innerQuoteClose]
+      }
+    ],
+    100
+  ),
+  newRule(
+    "/english/punctuation/dot-before-expression",
+    en_default.expressiveAposiopesis,
+    import_glyphs4.PUNCTUATION.common.rightSided.ellipsis + "$1"
+  ),
+  newRule(
+    "/english/punctuation/dot-before-expression",
+    en_default.backwardsExpressiveAposiopesis,
+    import_glyphs4.PUNCTUATION.common.rightSided.ellipsis + "$1"
+  ),
+  newRule(
+    "/english/punctuation/invalid-spacing",
+    en_default.invalidPunctuationSpacing,
+    import_glyphs4.NONE,
+    1e3
+  ),
+  newRule("/english/ligatures/fi", /fi/g, import_glyphs4.LIGATURES.fi),
+  newRule("/english/ligatures/fl", /fl/g, import_glyphs4.LIGATURES.fl),
+  newRule("/english/ligatures/ffi", /ffi/g, import_glyphs4.LIGATURES.ffi),
+  newRule("/english/ligatures/ffl", /ffl/g, import_glyphs4.LIGATURES.ffl)
+];
+
+// src/typography/sets/ru.ts
+var import_functions3 = require("./functions/index.cjs");
+var import_glyphs6 = require("./glyphs/index.cjs");
+
+// src/typography/expressions/ru.ts
+var import_glyphs5 = require("./glyphs/index.cjs");
+var SI_PREFIX2 = "\u0419|\u0417|\u042D|\u041F|\u0422|\u0413|\u041C|\u043A|\u0433|\u041C|\u043A|\u0434|\u0441|\u043C|\u043C\u043A|\u043D|\u043F|\u0444|\u0430|\u0437|\u0439";
+var SI_BASE2 = [
+  "\u0433|\u0442",
+  "\u043C",
+  "\u0441|\u043C\u0438\u043D|\u0447",
+  "\u041D",
+  "\u041F\u0430",
+  "\u0414\u0436",
+  "\u0412\u0442",
+  "\u0410|\u0412|\u041E\u043C|\u0424|\u0413\u043D|\u041A\u043B|\u0422\u043B|\u0412\u0431",
+  "\u0413\u0446",
+  "\u043C\u043E\u043B\u044C|\u043A\u0434|\u0440\u0430\u0434|\u0441\u0440"
+].join("|");
+var SI_UNIT2 = `(?:${SI_PREFIX2})?(?:${SI_BASE2})`;
+var SI_OPERAND2 = `(?:${SI_UNIT2})(?:\\^[\\d]+)?`;
+var PARTS3 = {
+  ...PARTS,
+  leftPunctuation: RegExp.escape(import_glyphs5.PUNCTUATION.get("ru", "leftSided").join("")),
+  rightPunctuation: RegExp.escape(import_glyphs5.PUNCTUATION.get("ru", "rightSided").join("")),
+  get leftChars() {
+    const value = PARTS3.leftPunctuation + PARTS3.leftBrackets;
+    Object.defineProperty(this, "leftChars", { value, enumerable: true, configurable: false });
+    return value;
+  },
+  get rightChars() {
+    const value = PARTS3.rightPunctuation + PARTS3.rightBrackets;
+    Object.defineProperty(this, "rightChars", { value, enumerable: true, configurable: false });
+    return value;
+  }
+};
+var EXPRESSIONS3 = {
+  ...EXPRESSIONS,
+  numeroNumeral: new RegExp(`(${import_glyphs5.CHARACTERS.numero})\\s*((?:${PARTS3.numerals}\\s*)*)`, "g"),
+  invalidPunctuationSpacing: new RegExp(
+    `(?<=[${PARTS3.leftChars}])\\s+|(?<!\\s)\\s(?=[${PARTS3.rightChars}])`,
+    "g"
+  ),
+  dialogEmDash: new RegExp(`(^${import_glyphs5.DASHES.em})\\s*`, "gm"),
+  attributionEmDash: new RegExp(
+    `([${PARTS3.rightPunctuation}])\\s*(${import_glyphs5.DASHES.em})\\s*([\u0430-\u044F\u0410-\u042F\u0451\u0401a-zA-Z]+)`,
+    "gi"
+  ),
+  subjectPredicateEmDash: new RegExp(
+    `([\u0430-\u044F\u0410-\u042F\u0451\u0401a-zA-Z]+)\\s+(${import_glyphs5.DASHES.em})\\s+([\u0430-\u044F\u0410-\u042F\u0451\u0401a-zA-Z]+)`,
+    "gi"
+  ),
+  siUnitMul: new RegExp(`(${SI_OPERAND2})\\*(${SI_OPERAND2}(?:\\/${SI_OPERAND2})*)`, "g"),
+  siUnitDiv: new RegExp(`(${SI_OPERAND2}(?:\\/${SI_OPERAND2})*)\\*(${SI_OPERAND2})`, "g"),
+  siUnitBase: new RegExp(`(\\d+)\\s*(${SI_UNIT2})(?![/*])`, "g"),
+  siUnitPowAfterNum: new RegExp(`(\\d+)\\s*(${SI_UNIT2})(\\d+)`, "g"),
+  siUnitPow: new RegExp(`(?<!\\d\\s*)(${SI_UNIT2})(\\d+)`, "g"),
+  date: new RegExp(`(${PARTS3.numerals})\\s(\u0432\u0432|\u0432|\u0433\u0433|\u0433|\u043C\u0435\u0441|\u043D\u0435\u0434|\u0434\u043D|\u0434)(\\.|\\s)`, "gi")
+};
+var ru_default = EXPRESSIONS3;
+
+// src/typography/sets/ru.ts
+var locale2 = "ru-RU";
+var ru_default2 = [
+  newRule("/russian/currency/wallet/symbol-flip", ru_default.walletSymbolBeforeValue, `$2$1`),
+  newRule("/russian/currency/wallet/iso-flip", ru_default.walletISOBeforeValue, `$2$1`),
+  newRule(
+    "/russian/currency/wallet/symbol-value",
+    ru_default.walletSymbolAfterValue,
+    `$1${import_glyphs6.SPACES.noBreak}$2`
+  ),
+  newRule(
+    "/russian/currency/wallet/iso-value",
+    ru_default.walletISOAfterValue,
+    `$1${import_glyphs6.SPACES.noBreak}$2`
+  ),
+  newRule(
+    "/russian/currency/rub-to-symbol",
+    /(\d+)\s*(?:рублей|рубля|рубль|руб\.?|р\.?)(?!\p{L})/giu,
+    `$1${import_glyphs6.SPACES.noBreak + import_glyphs6.WALLET.SYMBOL.ruble}`
+  ),
+  newRule(
+    "/russian/currency/eur-to-symbol",
+    /(\d+)\s*(?:евро)(?!\p{L})/giu,
+    `$1${import_glyphs6.SPACES.noBreak + import_glyphs6.WALLET.SYMBOL.euro}`
+  ),
+  newRule(
+    "/russian/currency/usd-to-symbol",
+    /(\d+)\s*(?:долларов|доллар|дол\.?)(?!\p{L})/giu,
+    `$1${import_glyphs6.SPACES.noBreak + import_glyphs6.WALLET.SYMBOL.dollar}`
+  ),
+  newRule("/russian/number/groups", import_functions3.smartNumberGrouping, [{ locale: locale2 }]),
+  newRule("/russian/number/normalize/dot->comma", /(\d+)\.(\d+)/g, "$1,$2"),
+  newRule("/russian/metric/si-unit/base", ru_default.siUnitBase, `$1${import_glyphs6.SPACES.noBreakNarrow}$2`),
+  newRule("/russian/metric/si-unit/n*n-n", ru_default.siUnitMul, `$1${import_glyphs6.CHARACTERS.middleDot}$2`),
+  newRule("/russian/metric/si-unit/n-n*n", ru_default.siUnitDiv, `$1${import_glyphs6.CHARACTERS.middleDot}$2`),
+  newRule(
+    "/russian/metric/si-unit/pow-after-value",
+    import_functions3.wrapWithTag,
+    [
+      {
+        expression: ru_default.siUnitPowAfterNum,
+        tag: "sup",
+        placement: `$1${import_glyphs6.SPACES.noBreakNarrow}$2<TAG>$3</TAG>`
+      }
+    ],
+    -1
+  ),
+  newRule(
+    "/russian/metric/si-unit/pow",
+    import_functions3.wrapWithTag,
+    [
+      {
+        expression: ru_default.siUnitPow,
+        tag: "sup",
+        placement: `$1<TAG>$2</TAG>`
+      }
+    ],
+    -1
+  ),
+  newRule(
+    "/russian/scientific/temperature/value",
+    ru_default.temperature,
+    `$1${import_glyphs6.SPACES.noBreak}$2`
+  ),
+  newRule("/russian/symbol/percent-like/value", ru_default.percentValue, `$1${import_glyphs6.SPACES.noBreak}$2`),
+  newRule("/russian/symbol/numero/value", ru_default.numeroNumeral, (match) => {
+    const numero = match[1];
+    const numeral = match[2].replace(/\s+/g, "");
+    return `${numero}${import_glyphs6.SPACES.noBreakNarrow}${numeral}`;
+  }),
+  newRule("/russian/number/division", /(\d+\s*)(?:\/)(\s*\d+)/g, `$1${import_glyphs6.MATHS.obelus}$2`),
+  newRule(
+    "/russian/number/division-times",
+    /(\d+\s*)(?:\/\*)(\s*\d+)/g,
+    `$1${import_glyphs6.MATHS.divisionTimes}$2`
+  ),
+  newRule(
+    "/russian/punctuation/dashes/dialog-em-dash",
+    ru_default.dialogEmDash,
+    `$1${import_glyphs6.SPACES.noBreak}`
+  ),
+  newRule(
+    "/russian/punctuation/dashes/attribution-em-dash",
+    ru_default.attributionEmDash,
+    `$1${import_glyphs6.SPACES.noBreak}$2${import_glyphs6.SPACES.noBreak}$3`
+  ),
+  newRule(
+    "/russian/punctuation/dashes/subject-predicate-em-dash",
+    ru_default.subjectPredicateEmDash,
+    `$1${import_glyphs6.SPACES.noBreak}$2${import_glyphs6.SPACES._}$3`
+  ),
+  newRule(
+    "/russian/punctuation/quotes",
+    import_functions3.smartQuotes,
+    [
+      {
+        outer: [import_glyphs6.PUNCTUATION.ru.leftSided.outerQuoteOpen, import_glyphs6.PUNCTUATION.ru.rightSided.outerQuoteClose],
+        inner: [import_glyphs6.PUNCTUATION.ru.leftSided.innerQuoteOpen, import_glyphs6.PUNCTUATION.ru.rightSided.innerQuoteClose]
+      }
+    ],
+    100
+  ),
+  newRule("/russian/punctuation/dot-after-quote", /\.»/g, "\xBB.", 1e3),
+  newRule(
+    "/russian/punctuation/dot-after-expression",
+    ru_default.backwardsExpressiveAposiopesis,
+    "$1.."
+  ),
+  newRule("/russian/punctuation/dot-after-expression", ru_default.expressiveAposiopesis, "$1.."),
+  newRule(
+    "/russian/punctuation/invalid-spacing",
+    ru_default.invalidPunctuationSpacing,
+    import_glyphs6.NONE,
+    1e3
+  ),
+  newRule(
+    "/russian/compositions/initials",
+    /([а-яёА-ЯЁ]\.)[\s]([а-яёА-ЯЁ]\.)[\s]([а-яёА-ЯЁ][а-яёА-ЯЁ]+)/g,
+    `$1${import_glyphs6.SPACES.thin}$2${import_glyphs6.SPACES.thin}$3`
+  ),
+  newRule(
+    "/russian/compositions/initials",
+    /([а-яёА-ЯЁ][а-яёА-ЯЁ]+)[\s]([а-яёА-ЯЁ}]\.)[\s]([а-яёА-ЯЁ]\.)/g,
+    `$1${import_glyphs6.SPACES.thin}$2${import_glyphs6.SPACES.thin}$3`
+  ),
+  newRule(
+    "/russian/text/conjunctions",
+    /\s(бы|б|же|ж|ли|ль)(?![а-яА-ЯёЁ])/gi,
+    `${import_glyphs6.SPACES.noBreak}$1`
+  ),
+  newRule(
+    "/russian/text/conjunctions",
+    /(?<=\s)(за|из|до|об|на|но|не|ни|то|от|по|со|или|для|над|под|при|что|если|через|после|перед)\s/gi,
+    `$1${import_glyphs6.SPACES.noBreak}`
+  ),
+  newRule("/russian/text/adress", /(?<=\s)(мкр-н|мкр\.)\s/gi, `$1${import_glyphs6.SPACES.noBreak}`),
+  newRule(
+    "/russian/text/adress",
+    /(?<=\s)(дом|д\.|под\.|п-д|эт\.|кв\.)\s*(\d+)/gi,
+    `$1${import_glyphs6.SPACES.noBreak}$2`
+  ),
+  newRule("/russian/text/adress", /(?<=\d+[-]?(?:й|го|му))\s*([-−]?этаж)/gi, `${import_glyphs6.SPACES.noBreak}$1`),
+  newRule(
+    "/russian/text/adress",
+    /(?<=\s)(обл|кр|ст|пос|с|д|ул|пер|пр|пр-т|просп|пл|бул|б-р|наб|ш|туп|оф|комн?|уч|вл|влад|стр|корп?)(\.|\s)([а-яА-ЯёЁa-zA-Z\d]+)/gi,
+    `$1.${import_glyphs6.SPACES.noBreak}$2`
+  ),
+  newRule(
+    "/russian/text/common-shorts",
+    /(?<=\s)(коп|см|им|рис|илл?|гл|кн|стр|ст|с|п)(\.|\s)/gi,
+    `$1.${import_glyphs6.SPACES.noBreak}.`
+  ),
+  newRule(
+    "/russian/text/organizations",
+    /(АО|ОАО|ЗАО|ООО|ПАО|НИИ|ПБОЮЛ)\s+/g,
+    `$1${import_glyphs6.SPACES.noBreak}`
+  ),
+  newRule("/russian/text/dates", ru_default.date, `$1${import_glyphs6.SPACES.noBreak}$2.`),
+  newRule(
+    "/russian/text/millions",
+    /(\d+)\s*(тыс|млн|млрд|трлн)(\.|\s)/gi,
+    `$1${import_glyphs6.SPACES.noBreak}$2.`
+  ),
+  newRule(
+    "/russian/text/no-break-hyphen",
+    /(^|[^а-яА-ЯёЁ])(кто|что|какой|который|чей|сколько|где|куда|откуда|когда|как|зачем|почему|отчего|так|этак|тогда|из)-(то|либо|нибудь|за)/gi,
+    `$1$2${import_glyphs6.DASHES.noBreakHyphen}$3`
+  ),
+  newRule(
+    "/russian/text/no-break-hyphen",
+    /(^|[^а-яА-ЯёЁ])(кое)-(кто|что|какой|где|куда|откуда|когда|как|зачем|почему)/gi,
+    `$1$2${import_glyphs6.DASHES.noBreakHyphen}$3`
+  ),
+  newRule(
+    "/russian/text/no-break-hyphen",
+    /(^|[^а-яА-ЯёЁ])(ну|скажи|пойди|дай|глянь|гляди|погоди|постой|поди|послушай|посмотри|вот|ничего|да|нет|полноте)-(ка|те|де|с|тка|тко|ста)/gi,
+    `$1$2${import_glyphs6.DASHES.noBreakHyphen}$3`
+  ),
+  newRule(
+    "/russian/text/no-break-hyphen",
+    /(^|[^а-яА-ЯёЁ])(все|всё|так|опять|довольно|[а-яА-ЯёЁ]+)-(таки)/gi,
+    `$1$2${import_glyphs6.DASHES.noBreakHyphen}$3`
+  ),
+  newRule("/russian/text/orphan-letters", /(?<![а-яА-ЯёЁ])([а-яА-ЯёЁ])\s/g, `$1${import_glyphs6.SPACES.noBreak}`)
+];
+
+// src/typography/markup/index.ts
+var markup_exports = {};
+__export(markup_exports, {
+  common: () => common_default3,
+  en: () => en_default3,
+  ru: () => ru_default3
+});
+
+// src/typography/markup/common.ts
+var import_functions4 = require("./functions/index.cjs");
+var common_default3 = [
+  // HTML Wraps
+  // Chemical
+  newRule(
+    "/common/wraps/chem",
+    import_functions4.chemNotation,
+    [{ className: "@nkardaz-typography-chem" }],
+    Infinity
+  ),
+  // Wraps for ルビ, furigana
+  newRule(
+    "/common/wraps/ruby",
+    import_functions4.rubyText,
+    [{ marker: "?:" }, { className: "@nkardaz-typography-ruby --alternate" }],
+    Infinity
+  ),
+  newRule(
+    "/common/wraps/ruby",
+    import_functions4.rubyText,
+    [{ marker: "!:" }, { className: "@nkardaz-typography-ruby --under" }],
+    Infinity
+  ),
+  newRule(
+    "/common/wraps/ruby",
+    import_functions4.rubyText,
+    [{ marker: ":" }, { className: "@nkardaz-typography-ruby --over" }],
+    Infinity
+  ),
+  // Wraps for superscript and subscript
+  newRule(
+    "/common/wraps/sup",
+    import_functions4.wrapWithTag,
+    [{ marker: "^", tag: "sup" }, { className: "@nkardaz-typography-sup" }],
+    Infinity
+  ),
+  newRule(
+    "/common/wraps/sub",
+    import_functions4.wrapWithTag,
+    [{ marker: "_", tag: "sub" }, { className: "@nkardaz-typography-sub" }],
+    Infinity
+  )
+];
+
+// src/typography/markup/en.ts
+var en_default3 = [
+  // HTML Helpers
+  // newRule('/english/number/float-value', /(\d+)\\.(\d+)/g, '$1[^$2]'),
+];
+
+// src/typography/markup/ru.ts
+var ru_default3 = [
+  // HTML Helpers
+  // newRule('/russian/number/float-value', /(\d+),(\d+)/g, '$1[^$2]'),
+];
+
+// src/api/rulesInit.ts
+var defaultTypographyRules = {};
+var defaultMarkupRules = {};
+for (const [locale3, rules] of Object.entries(sets_exports)) {
+  defaultTypographyRules[locale3] = rules;
+}
+for (const [locale3, rules] of Object.entries(markup_exports)) {
+  defaultMarkupRules[locale3] = rules;
+}
+var defaultRuleKeys = Object.keys(
+  defaultTypographyRules
+);
+function initRules(defaults, from) {
+  const keys = from.length === 0 ? Object.keys(defaults) : from;
+  for (const key of keys) {
+    if (!typographyRules[key]) {
+      typographyRules[key] = [];
+    }
+    typographyRules[key].push(...defaults[key] ?? []);
+  }
+}
+function initTypographyRules(...from) {
+  initRules(defaultTypographyRules, from);
+}
+function initMarkupRules(...from) {
+  initRules(defaultMarkupRules, from);
+}
+
+// src/api/htmlNodes.ts
+function htmlNode(text, { expression, nodes } = {}) {
+  if (!expression || !nodes) {
+    return [{ type: "text", value: text }];
+  }
+  const result = [];
+  let lastIndex = 0;
+  for (const match of text.matchAll(expression)) {
+    const matchStart = match.index;
+    if (matchStart > lastIndex) {
+      result.push({ type: "text", value: text.slice(lastIndex, matchStart) });
+    }
+    result.push(nodes(match));
+    lastIndex = matchStart + match[0].length;
+  }
+  if (lastIndex < text.length) {
+    result.push({ type: "text", value: text.slice(lastIndex) });
+  }
+  return result;
+}
+function renderNode(node) {
+  if (node.type === "text") {
+    return node.value;
+  }
+  const element = node;
+  const attrs = [];
+  if (element.className) {
+    attrs.push(`class="${element.className}"`);
+  }
+  if (element.attrs) {
+    for (const [name, value] of Object.entries(element.attrs)) {
+      attrs.push(`${name}="${value}"`);
+    }
+  }
+  const attrString = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+  const inner = element.children.map(renderNode).join("");
+  return `<${element.type}${attrString}>${inner}</${element.type}>`;
+}
+function renderNodes(nodes) {
+  return nodes.map(renderNode).join("");
+}
+function nodeToMdast(n) {
+  if (n.type === "text") {
+    return {
+      type: "text",
+      value: n.value
+    };
+  }
+  const element = n;
+  const attributes = [];
+  if (element.className) {
+    attributes.push({
+      type: "mdxJsxAttribute",
+      name: "className",
+      value: element.className
+    });
+  }
+  if (element.attrs) {
+    for (const [name, value] of Object.entries(element.attrs)) {
+      attributes.push({
+        type: "mdxJsxAttribute",
+        name,
+        value
+      });
+    }
+  }
+  return {
+    type: "mdxJsxTextElement",
+    name: element.type,
+    attributes,
+    children: element.children.map(nodeToMdast),
+    data: element.data
+  };
+}
+//# sourceMappingURL=index.cjs.map