Add 27.0 js src

27.0/js/forms/PatternRegexpToPasswordRulesConverter.js

@@ -0,0 +1,152 @@
+//# sourceURL=__InjectedScript_PatternRegexpToPasswordRulesConverter.js
+/* Copyright (c) 2026 Apple Inc. All rights reserved. */
+// Copyright (c) 2026 Apple Inc. Licensed under MIT License.
+"use strict";
+class PatternRegexpToPasswordRulesConverter {
+  static convert(t) {
+    try {
+      return this.#t(t);
+    } catch (t) {
+      return null;
+    }
+  }
+  static #t(t) {
+    const e = this.#e(t),
+      r = this.#r(e);
+    if (r) return r;
+    let s = e;
+    const a = this.#s(s);
+    if (((s = this.#a(s)), !this.#n(a))) return null;
+    const n = s.match(/^\.[\*\+]?(?:\{(\d+),(\d*)\})?$/);
+    if (n) {
+      const t = this.#l(a),
+        { min: e, max: r } = this.#i(n, 1, 2);
+      return this.#c(t, null, e, r);
+    }
+    const l = s.match(/^\[((?:[^\]\\]|\\.)*)\](?:\{(\d+),(\d*)\})?$/);
+    if (!l) return null;
+    const i = this.#l(a),
+      c = this.#o(l, i),
+      { min: o, max: u } = this.#i(l, 2, 3);
+    return this.#c(i, c, o, u);
+  }
+  static #e(t) {
+    let e = t.trim();
+    return (
+      e.startsWith("^") && (e = e.substring(1)),
+      e.endsWith("$") &&
+        !e.endsWith("\\$") &&
+        (e = e.substring(0, e.length - 1)),
+      e
+    );
+  }
+  static #r(t) {
+    return "\\d*" === t || "\\d+" === t || "[0-9]*" === t || "[0-9]+" === t
+      ? "required: digit;"
+      : "[a-z]*" === t || "[a-z]+" === t
+        ? "required: lower;"
+        : "[A-Z]*" === t || "[A-Z]+" === t
+          ? "required: upper;"
+          : null;
+  }
+  static #s(t) {
+    const e = [],
+      r = /\(\?=\.\*(?:\[((?:[^\]\\]|\\.)*)\]|(\\[dDwWsS]))\)/g;
+    let s;
+    for (; (s = r.exec(t));)
+      void 0 !== s[1] ? e.push(s[1]) : e.push(this.#u(s[2]));
+    return e;
+  }
+  static #n(t) {
+    for (const e of t)
+      for (const t of ["(?", "|", "\\D", "\\W", "\\S", "\\s"])
+        if (e.includes(t)) return !1;
+    return !0;
+  }
+  static #l(t) {
+    const e = [];
+    for (let r of t) {
+      ((r = r.replace(/\\d/g, "0-9")), (r = r.replace(/\\w/g, "a-zA-Z0-9_")));
+      const t = [];
+      let s = r;
+      (s.includes("0-9") && (t.push("digit"), (s = s.replace(/0-9/g, ""))),
+        s.includes("A-Z") && (t.push("upper"), (s = s.replace(/A-Z/g, ""))),
+        s.includes("a-z") && (t.push("lower"), (s = s.replace(/a-z/g, ""))),
+        (s = s.replace(/[a-zA-Z0-9]/g, "")),
+        t.length > 0 && 0 === s.length
+          ? e.push(t.join(", "))
+          : 0 === t.length && s.length > 0
+            ? e.push(this.#h(s))
+            : t.length > 0 &&
+              s.length > 0 &&
+              (t.push(this.#h(s)), e.push(t.join(", "))));
+    }
+    return e;
+  }
+  static #u(t) {
+    return { "\\d": "0-9", "\\w": "a-zA-Z0-9_" }[t] || t;
+  }
+  static #a(t) {
+    let e = t.replace(/\(\?=\.\*\[((?:[^\]\\]|\\.)*)\]\)/g, "");
+    return ((e = e.replace(/\(\?=\.\*(\\[dDwWsS])\)/g, "")), e);
+  }
+  static #h(t) {
+    let e = t.replace(/\\\]/g, "]").split(""),
+      r = !1,
+      s = !1,
+      a = [];
+    for (const t of e) "-" === t ? (r = !0) : "]" === t ? (s = !0) : a.push(t);
+    let n = "";
+    return (r && (n += "-"), (n += a.join("")), s && (n += "]"), `[${n}]`);
+  }
+  static #o(t, e) {
+    let r = t[1];
+    const s = [];
+    ((r = r.replace(/\\d/g, "0-9")), (r = r.replace(/\\w/g, "a-zA-Z0-9_")));
+    const a = (t) => e.some((e) => e === t || e.split(", ").includes(t));
+    (r.includes("a-z") && !a("lower") && s.push("lower"),
+      r.includes("A-Z") && !a("upper") && s.push("upper"),
+      r.includes("0-9") && !a("digit") && s.push("digit"));
+    let n = r;
+    if (
+      ((n = n.replace(/a-z/g, "")),
+      (n = n.replace(/A-Z/g, "")),
+      (n = n.replace(/0-9/g, "")),
+      (n = n.replace(/[a-zA-Z0-9]/g, "")),
+      (n = n.replace(/\\(.)/g, "$1")),
+      n)
+    ) {
+      const t = this.#h(n),
+        r = (t) => {
+          const e = t.match(/^\[(.*)\]$/);
+          return e ? "[" + [...e[1]].sort().join("") + "]" : t;
+        };
+      e.some((e) => r(e) === r(t)) || s.push(t);
+    }
+    return s.length ? s.join(", ") : null;
+  }
+  static #i(t, e, r) {
+    let s = null,
+      a = null;
+    if (t[e]) {
+      const r = parseInt(t[e], 10);
+      isNaN(r) || (s = r);
+    }
+    if (t[r]) {
+      const e = parseInt(t[r], 10);
+      isNaN(e) || (a = e);
+    }
+    return { min: s, max: a };
+  }
+  static #c(t, e, r, s) {
+    const a = [];
+    for (const e of t) a.push(`required: ${e}`);
+    return (
+      e && a.push(`allowed: ${e}`),
+      null !== r && a.push(`minlength: ${r}`),
+      null !== s && a.push(`maxlength: ${s}`),
+      a.join("; ") + ";"
+    );
+  }
+}
+0;