zumerlab
diff --git a/‎src/modules/counter.js‎
Lines changed: 118 additions & 0 deletions b/‎src/modules/counter.js‎
Lines changed: 118 additions & 0 deletions
@@ -18,19 +18,38 @@ export function unquoteDoubleStrings(s) {
  return (s || '').replace(/"([^"]*)"/g, '$1');
 }
 
+/**
+ * a, b, ..., z, aa, ab, ...
+ * @param {number} n
+ * @param {boolean} upper
+ * @returns {string}
+ */
 function alpha(n, upper = false) {
  let s = '', x = Math.max(1, n);
  while (x > 0) { x--; s = String.fromCharCode(97 + (x % 26)) + s; x = Math.floor(x / 26); }
  return upper ? s.toUpperCase() : s;
 }
 
+/**
+ * Roman numerals (1..3999)
+ * @param {number} n
+ * @param {boolean} upper
+ * @returns {string}
+ */
 function roman(n, upper = true) {
  const map = [[1000,'M'],[900,'CM'],[500,'D'],[400,'CD'],[100,'C'],[90,'XC'],[50,'L'],[40,'XL'],[10,'X'],[9,'IX'],[5,'V'],[4,'IV'],[1,'I']];
  let num = Math.max(1, Math.min(3999, n)), out = '';
  for (const [v, sym] of map) while (num >= v) { out += sym; num -= v; }
  return upper ? out : out.toLowerCase();
 }
 
+/**
+ * Format a numeric counter value according to CSS counter-style keyword.
+ * NOTE: Keeps your original clamp to 0 in decimal variants.
+ * @param {number} value
+ * @param {string} style
+ * @returns {string}
+ */
 function formatCounter(value, style) {
  switch ((style || 'decimal').toLowerCase()) {
  case 'decimal': return String(Math.max(0, value));
@@ -158,10 +177,20 @@ export function buildCounterContext(root) {
  build(rootEl, empty, empty);
 
  return {
+ /**
+     * Get top value for counter name at given node.
+     * @param {Element} node
+     * @param {string} name
+     */
  get(node, name) {
  const s = nodeCounters.get(node)?.get(name);
  return s && s.length ? s[s.length - 1] : 0;
  },
+ /**
+     * Get full stack for counter name at given node.
+     * @param {Element} node
+     * @param {string} name
+     */
  getStack(node, name) {
  const s = nodeCounters.get(node)?.get(name);
  return s ? s.slice() : [];
@@ -203,3 +232,92 @@ export function resolveCountersInContent(raw, node, ctx) {
  return '- ';
  }
 }
+
+/**
+ * Create a derived counter context that applies a pseudo's counter-reset /
+ * counter-increment *for this node only*, before resolving content.
+ * Works with ::before / ::after (and any pseudo with content).
+ *
+ * @param {Element} node
+ * @param {CSSStyleDeclaration|null} pseudoStyle getComputedStyle(node, '::before' | '::after')
+ * @param {{get(node: Element, name: string): number, getStack(node: Element, name: string): number[]}} baseCtx
+ */
+export function deriveCounterCtxForPseudo(node, pseudoStyle, baseCtx) {
+ const modStacks = new Map();
+
+ /** Parse "a 1, b -2" -> [{name:'a', num:1}, {name:'b', num:-2}] */
+ function parseListDecl(value) {
+ const out = [];
+ if (!value || value === 'none') return out;
+ for (const part of String(value).split(',')) {
+ const toks = part.trim().split(/\s+/);
+ const name = toks[0];
+ const num = Number.isFinite(Number(toks[1])) ? Number(toks[1]) : undefined;
+ if (name) out.push({ name, num });
+ }
+ return out;
+ }
+
+ const resets = parseListDecl(pseudoStyle?.counterReset);
+ const incs = parseListDecl(pseudoStyle?.counterIncrement);
+
+ function getStackDerived(name) {
+ if (modStacks.has(name)) return modStacks.get(name).slice();
+
+ // base stack at this node from the element context
+ let stack = baseCtx.getStack(node, name);
+ stack = stack.length ? stack.slice() : [];
+
+ // counter-reset (push if exists, replace if not)
+ const r = resets.find(x => x.name === name);
+ if (r) {
+ const val = Number.isFinite(r.num) ? r.num : 0;
+ if (stack.length) {
+ stack = stack.slice();
+ stack.push(val);
+ } else {
+ stack = [val];
+ }
+ }
+
+ // counter-increment (on top; create top=0 if missing)
+ const inc = incs.find(x => x.name === name);
+ if (inc) {
+ const by = Number.isFinite(inc.num) ? inc.num : 1;
+ if (stack.length === 0) stack = [0];
+ stack[stack.length - 1] += by;
+ }
+
+ modStacks.set(name, stack.slice());
+ return stack;
+ }
+
+ return {
+ get(_node, name) {
+ const s = getStackDerived(name);
+ return s.length ? s[s.length - 1] : 0;
+ },
+ getStack(_node, name) {
+ return getStackDerived(name);
+ }
+ };
+}
+
+/**
+ * Convenience helper: resolve the final text to render for a pseudo's `content`,
+ * correctly applying the pseudo's own counter-reset/increment before evaluation.
+ *
+ * @param {Element} node
+ * @param {'::before'|'::after'} pseudo
+ * @param {{get(node: Element, name: string): number, getStack(node: Element, name: string): number[]}} baseCtx
+ * @returns {string} resolved content (without surrounding double quotes)
+ */
+export function resolvePseudoContent(node, pseudo, baseCtx) {
+ let ps;
+ try { ps = getComputedStyle(node, pseudo); } catch {}
+ const raw = ps?.content;
+ if (!raw || raw === 'none' || raw === 'normal') return '';
+ const derived = deriveCounterCtxForPseudo(node, ps, baseCtx);
+ let out = resolveCountersInContent(raw, node, derived);
+ return unquoteDoubleStrings(out);
+}