修复商品规则适配与安全随机密码生成

app/lib/product-fields.js

@@ -36,8 +36,8 @@ function r(n) {
     .filter((e) => e.value !== ``);
 }
 /**
- * 将后端 PCRE 风格 regexpr 的可表达部分转换为 JS RegExp。
- * 不支持的高级构造标记 patternServerOnly，不能假装浏览器已经完成等价验证。
+ * 只转换能确认等价的 ASCII PCRE 子集，不能把“JS 能编译”当作跨引擎语义相同。
+ * Unicode、换行模式、未知 escape、POSIX/补集及高级分组均交给后端最终校验。
  */
 function i(e) {
   let n = t(e).trim();
@@ -74,70 +74,56 @@ function i(e) {
   }
   if (!/^[imsuxADSUXJnr]*$/.test(r))
     throw Error(`自定义字段验证规则修饰符无效`);
-  let o = /^\(\?([imsx]+)\)/.exec(n);
-  o && ((r += o[1]), (n = n.slice(o[0].length)));
-  let s = [...new Set(r.replace(/[^imsu]/g, ``))].join(``);
-  if (
-    /\(\?(?:[>('|&R0-9]|P[=>]|[imsx-]+:)|\(\*|\\[KCG]|(?:[+*?]|\{\d+(?:,\d*)?\})\+/.test(
-      n,
-    ) ||
-    r.includes(`r`) ||
-    (r.includes(`J`) && /\(\?</.test(n))
-  )
-    return {
-      pattern: n,
-      patternFlags: s || void 0,
-      patternServerOnly: !0,
-    };
-  // 逐字符翻译锚点、扩展空白模式和非捕获/非贪婪约定；字符组内不执行这些改写。
-  let c = ``,
+  const serverOnly = { pattern: n, patternServerOnly: !0 };
+  // 除 i 外的修饰符涉及字符/换行/量词等引擎差异；宁可多一次后端验证，也不误拒合法值。
+  if (/[^i]/.test(r)) return serverOnly;
+  let s = r ? `i` : ``,
+    c = ``,
     l = !1;
   for (let e = 0; e < n.length; e++) {
     let t = n[e];
+    if (t.charCodeAt(0) > 127) return serverOnly;
     if (t === `\\`) {
-      let t = n[++e],
-        r = {
-          A: `(?<![\\s\\S])`,
-          z: `(?![\\s\\S])`,
-          Z: `(?=\\n?(?![\\s\\S]))`,
-        };
-      c += !l && t && r[t] ? r[t] : `\\${t ?? ``}`;
+      let t = n[++e];
+      if (t === `d`) c += l ? `0-9` : `[0-9]`;
+      else if (!l && t === `A`) c += `(?<![\\s\\S])`;
+      else if (!l && t === `z`) c += `(?![\\s\\S])`;
+      else if (!l && t === `Z`) c += `(?=\\n?(?![\\s\\S]))`;
+      else if (t && (`nrtf`.includes(t) || `\\^$.*+?()[]{}|/-`.includes(t)))
+        c += `\\${t}`;
+      else return serverOnly;
       continue;
     }
-    if (
-      (t === `[` && !l ? (l = !0) : t === `]` && l && (l = !1),
-      !l && r.includes(`x`))
-    ) {
-      if (/\s/.test(t)) continue;
-      if (t === `#`) {
-        for (
-          ;
-          e < n.length &&
-          n[e] !==
-            `
-`;
-        )
-          e++;
-        continue;
-      }
+    if (t === `[`) {
+      // 嵌套方括号可能是 POSIX 类；否定字符组还涉及非 ASCII 编码宽度，不作猜测。
+      if (l || n[e + 1] === `^`) return serverOnly;
+      l = !0;
+    } else if (t === `]`) {
+      if (!l) return serverOnly;
+      l = !1;
     }
-    if (!l && t === `$` && r.includes(`D`) && !s.includes(`m`)) {
-      c += `(?![\\s\\S])`;
+    if (l) {
+      c += t;
       continue;
     }
-    if (!l && t === `(` && r.includes(`n`) && n[e + 1] !== `?`) {
+    if (t === `.` || (t === `(` && n[e + 1] === `*`)) return serverOnly;
+    if (t === `(` && n[e + 1] === `?`) {
+      if (n[e + 2] !== `:`) return serverOnly;
       c += `(?:`;
+      e += 2;
       continue;
     }
-    ((c += t),
-      !l &&
-        r.includes(`U`) &&
-        (`*+`.includes(t) ||
-          (t === `?` && e > 0 && n[e - 1] !== `(`) ||
-          (t === `}` && /\{\d+(?:,\d*)?\}$/.test(c))) &&
-        (n[e + 1] === `?` ? e++ : (c += `?`)));
+    if (t === `{`) {
+      const quantifier = /^\{\d+(?:,\d*)?\}/.exec(n.slice(e));
+      if (!quantifier || n[e + quantifier[0].length] === `+`) return serverOnly;
+      c += quantifier[0];
+      e += quantifier[0].length - 1;
+      continue;
+    }
+    if (t === `}` || (`*+?`.includes(t) && n[e + 1] === `+`)) return serverOnly;
+    // PCRE 默认 $ 只允许最终 LF 前；JS 原生 $ 还会放行 CR/Unicode 行分隔符。
+    c += t === `$` ? `(?=\\n?(?![\\s\\S]))` : t;
   }
-  r.includes(`A`) && (c = `(?<![\\s\\S])(?:${c})`);
   try {
     new RegExp(c, s);
   } catch {