parseman 0.19.0 → 0.20.0

package/dist/plugin/index.cjs

@@ -406,9 +406,9 @@ function asciiFoldEq(a, b) {
 }
 function literal(value, opts = {}) {
   const caseInsensitive = opts.caseInsensitive ?? false;
-  const firstSet = value.length > 0 ? fromChar(value.codePointAt(0)) : empty();
+  const firstSet2 = value.length > 0 ? fromChar(value.codePointAt(0)) : empty();
   const meta = {
-    firstSet,
+    firstSet: firstSet2,
     canMatchNewline: value.includes("\n"),
     isTrivia: false
   };
@@ -420,7 +420,7 @@ function literal(value, opts = {}) {
     meta.firstSet = firstLower !== void 0 && firstUpper !== void 0 ? firstLower === firstUpper ? { kind: "ranges", ranges: [{ lo: firstLower, hi: firstLower }] } : { kind: "ranges", ranges: [
       { lo: firstLower, hi: firstLower },
       { lo: firstUpper, hi: firstUpper }
-    ] } : firstSet;
+    ] } : firstSet2;
   }
   return {
     _tag: "literal",
@@ -443,68 +443,66 @@ function literal(value, opts = {}) {
   };
 }
 
-// src/combinators/regex.ts
-var firstSetAnalyzer = null;
-function registerRegexAnalyzer(analyzer) {
-  firstSetAnalyzer = analyzer;
-}
-var permissiveFirstSet = () => ({ firstSet: any(), canMatchNewline: true });
-var SCAN_BAIL_AT = 64;
+// src/regex/classes.ts
+var CLASS_ESCAPES = { t: 9, n: 10, r: 13, f: 12, v: 11, "0": 0 };
 var SPACE_RANGES = [
   [9, 13],
   [32, 32],
   [160, 160],
   [5760, 5760],
   [8192, 8202],
-  [8232, 8233],
+  [8232, 8232],
+  [8233, 8233],
   [8239, 8239],
   [8287, 8287],
   [12288, 12288],
   [65279, 65279]
 ];
-var CLASS_ESCAPES = { t: 9, n: 10, r: 13, f: 12, v: 11, "0": 0 };
 function shorthandRanges(ch) {
   if (ch === "d") return [[48, 57]];
   if (ch === "s") return SPACE_RANGES;
   return [[48, 57], [65, 90], [97, 122], [95, 95]];
 }
-function inRanges(cp, ranges) {
-  for (let i = 0; i < ranges.length; i++) {
-    const [lo, hi] = ranges[i];
-    if (cp >= lo && cp <= hi) return true;
-  }
-  return false;
+function readUnicodeEscape(body, i) {
+  if (body[i] !== "\\" || body[i + 1] !== "u") return null;
+  const hex = body.slice(i + 2, i + 6);
+  if (!/^[0-9a-fA-F]{4}$/.test(hex)) return null;
+  return { cp: Number.parseInt(hex, 16), next: i + 6 };
 }
-function readClassRanges(body) {
-  if (body.startsWith("^")) return null;
+function parseClassRanges(body) {
   const ranges = [];
   let i = 0;
   const readAtom = () => {
     const ch = body[i];
     if (ch === void 0) return null;
     if (ch === "\\") {
-      const esc = body[i + 1];
-      if (esc === void 0) return null;
+      const uni = readUnicodeEscape(body, i);
+      if (uni) {
+        i = uni.next;
+        return { cp: uni.cp };
+      }
+      const e = body[i + 1];
+      if (e === void 0) return null;
       i += 2;
-      if (esc === "d" || esc === "w" || esc === "s") return { ranges: shorthandRanges(esc) };
-      if (esc in CLASS_ESCAPES) return { cp: CLASS_ESCAPES[esc] };
-      if (esc >= "a" && esc <= "z" || esc >= "A" && esc <= "Z") return null;
-      return { cp: esc.charCodeAt(0) };
+      if (e in CLASS_ESCAPES) return { cp: CLASS_ESCAPES[e] };
+      if (e === "d" || e === "w" || e === "s") return { set: shorthandRanges(e) };
+      if (e >= "a" && e <= "z" || e >= "A" && e <= "Z") return null;
+      return { cp: e.codePointAt(0) };
     }
-    i++;
-    return { cp: ch.charCodeAt(0) };
+    i += ch.length;
+    return { cp: ch.codePointAt(0) };
   };
   while (i < body.length) {
     const lo = readAtom();
-    if (!lo) return null;
-    if ("ranges" in lo) {
-      ranges.push(...lo.ranges);
+    if (lo === null) return null;
+    if ("set" in lo) {
+      ranges.push(...lo.set);
       continue;
     }
     if (body[i] === "-" && body[i + 1] !== void 0 && body[i + 1] !== "]") {
-      i++;
+      i += 1;
       const hi = readAtom();
-      if (!hi || "ranges" in hi) return null;
+      if (hi === null || "set" in hi) return null;
       ranges.push([lo.cp, hi.cp]);
     } else {
       ranges.push([lo.cp, lo.cp]);
@@ -512,6 +510,25 @@ function readClassRanges(body) {
   }
   return ranges.length ? ranges : null;
 }
+
+// src/combinators/regex.ts
+var firstSetAnalyzer = null;
+function registerRegexAnalyzer(analyzer) {
+  firstSetAnalyzer = analyzer;
+}
+var permissiveFirstSet = () => ({ firstSet: any(), canMatchNewline: true });
+var SCAN_BAIL_AT = 64;
+function inRanges(cp, ranges) {
+  for (let i = 0; i < ranges.length; i++) {
+    const [lo, hi] = ranges[i];
+    if (cp >= lo && cp <= hi) return true;
+  }
+  return false;
+}
+function readClassRanges(body) {
+  if (body.startsWith("^")) return null;
+  return parseClassRanges(body);
+}
 function shortScanner(source, flags) {
   if (/[imsuvy]/.test(flags)) return null;
   let ranges = null;
@@ -545,8 +562,8 @@ function regex(pattern, flags = "") {
   const resolvedFlags = typeof pattern === "string" ? flags : pattern.flags;
   const anchored = new RegExp(source, "y" + resolvedFlags.replace(/[gy]/g, ""));
   const scan = shortScanner(source, resolvedFlags);
-  const { firstSet, canMatchNewline } = (firstSetAnalyzer ?? permissiveFirstSet)(source);
-  const meta = { firstSet, canMatchNewline, isTrivia: false };
+  const { firstSet: firstSet2, canMatchNewline } = (firstSetAnalyzer ?? permissiveFirstSet)(source);
+  const meta = { firstSet: firstSet2, canMatchNewline, isTrivia: false };
   return {
     _tag: "regex",
     _meta: meta,
@@ -574,111 +591,266 @@ function regex(pattern, flags = "") {
   };
 }
 
-// src/combinators/regex-analyze.ts
-var import_regexp_tree = __toESM(require("regexp-tree"), 1);
-function firstSetFromRegex(pattern) {
-  try {
-    const ast = import_regexp_tree.default.parse(`/${pattern}/`);
-    return extractFirstSet(ast.body);
-  } catch {
-    return { firstSet: any(), canMatchNewline: true };
-  }
+// src/regex/first-set.ts
+var ANY = { t: "any" };
+var EMPTY2 = { t: "empty" };
+function charNode(set, nl) {
+  return { t: "char", set, nl };
 }
-function canBeEmpty(node2) {
-  if (!node2) return true;
-  switch (node2.type) {
-    case "Repetition": {
-      const q = node2.quantifier;
-      return q.kind === "*" || q.kind === "?" || q.kind === "Range" && (q.from ?? 1) === 0;
+function rangesToSet(ranges) {
+  let fs2 = empty();
+  for (const [lo, hi] of ranges) fs2 = union(fs2, fromRange(lo, hi));
+  return fs2;
+}
+function rangesHaveNewline(ranges) {
+  return ranges.some(([lo, hi]) => lo <= 10 && 10 <= hi);
+}
+var BAIL = /* @__PURE__ */ Symbol("regex-bail");
+function parseRegex(src) {
+  let i = 0;
+  const parseAlt = () => {
+    const arms = [parseSeq()];
+    while (src[i] === "|") {
+      i++;
+      arms.push(parseSeq());
     }
-    case "Alternative": {
-      const exprs = node2.expressions;
-      return !exprs || exprs.length === 0 || exprs.every((e) => canBeEmpty(e));
+    return arms.length === 1 ? arms[0] : { t: "alt", arms };
+  };
+  const parseSeq = () => {
+    const parts = [];
+    while (i < src.length) {
+      const ch = src[i];
+      if (ch === "|" || ch === ")") break;
+      parts.push(parseQuantified());
+    }
+    if (parts.length === 0) return EMPTY2;
+    return parts.length === 1 ? parts[0] : { t: "seq", parts };
+  };
+  const parseQuantified = () => {
+    const atom = parseAtom();
+    const ch = src[i];
+    let min = null;
+    if (ch === "*") {
+      min = 0;
+      i++;
+    } else if (ch === "+") {
+      min = 1;
+      i++;
+    } else if (ch === "?") {
+      min = 0;
+      i++;
+    } else if (ch === "{") {
+      min = parseBraceQuantifier();
     }
-    case "Group":
-      return canBeEmpty(node2.expression);
-    case "Disjunction":
-      return canBeEmpty(node2.left) || canBeEmpty(node2.right);
-    default:
-      return false;
-  }
-}
-function extractFirstSet(node2) {
-  if (!node2) return { firstSet: empty(), canMatchNewline: false };
-  switch (node2.type) {
-    case "Disjunction": {
-      const left = extractFirstSet(node2.left);
-      const right = extractFirstSet(node2.right);
-      return {
-        firstSet: union(left.firstSet, right.firstSet),
-        canMatchNewline: left.canMatchNewline || right.canMatchNewline
-      };
+    if (min === null) return atom;
+    if (src[i] === "?") i++;
+    return { t: "rep", node: atom, min };
+  };
+  const parseBraceQuantifier = () => {
+    const close = src.indexOf("}", i);
+    if (close === -1) return null;
+    const m = /^(\d+)(?:,(\d*))?$/.exec(src.slice(i + 1, close));
+    if (!m) return null;
+    i = close + 1;
+    return Number.parseInt(m[1], 10);
+  };
+  const parseAtom = () => {
+    const ch = src[i];
+    switch (ch) {
+      case "(":
+        return parseGroup();
+      case "[":
+        return parseClass();
+      case ".":
+        i++;
+        return charNode(any(), false);
+      // `.` matches any char except line terminators
+      case "\\":
+        return parseEscape();
+      case "^":
+      case "$":
+        i++;
+        return EMPTY2;
+      // anchors are zero-width
+      case "{":
+        i++;
+        return charNode(fromRange(123, 123), false);
+      // a `{` with nothing to quantify is a literal brace
+      default:
+        i += ch.length;
+        return charNode(fromRange(ch.codePointAt(0), ch.codePointAt(0)), ch === "\n");
     }
-    case "Alternative": {
-      const exprs = node2.expressions;
-      if (!exprs || exprs.length === 0) return { firstSet: empty(), canMatchNewline: false };
-      let fs2 = empty();
-      let canNL = false;
-      for (const expr of exprs) {
-        const r = extractFirstSet(expr);
-        fs2 = union(fs2, r.firstSet);
-        canNL = canNL || r.canMatchNewline;
-        if (!canBeEmpty(expr)) break;
-      }
-      return { firstSet: fs2, canMatchNewline: canNL };
+  };
+  const parseGroup = () => {
+    i++;
+    let lookaround = false;
+    if (src[i] === "?") {
+      const c1 = src[i + 1];
+      if (c1 === ":") i += 2;
+      else if (c1 === "=" || c1 === "!") {
+        i += 2;
+        lookaround = true;
+      } else if (c1 === "<") {
+        const c2 = src[i + 2];
+        if (c2 === "=" || c2 === "!") {
+          i += 3;
+          lookaround = true;
+        } else {
+          const gt = src.indexOf(">", i);
+          if (gt === -1) throw BAIL;
+          i = gt + 1;
+        }
+      } else throw BAIL;
     }
-    case "Char": {
-      const kind = node2.kind;
-      if (kind === "simple") {
-        const code = node2.codePoint ?? node2.value.codePointAt(0) ?? 0;
-        return { firstSet: fromRange(code, code), canMatchNewline: code === 10 };
-      }
-      if (kind === "meta") {
-        const val = node2.value;
-        if (val === ".") return { firstSet: any(), canMatchNewline: false };
-        if (val === "d") return { firstSet: fromRange(48, 57), canMatchNewline: false };
-        if (val === "D") return { firstSet: any(), canMatchNewline: true };
-        if (val === "w") return {
-          firstSet: union(
-            union(fromRange(48, 57), fromRange(65, 90)),
-            union(fromRange(97, 122), fromRange(95, 95))
-          ),
-          canMatchNewline: false
-        };
-        if (val === "s") return { firstSet: fromRange(9, 13), canMatchNewline: true };
-        if (val === "n") return { firstSet: fromRange(10, 10), canMatchNewline: true };
+    const inner = parseAlt();
+    if (src[i] !== ")") throw BAIL;
+    i++;
+    return lookaround ? EMPTY2 : inner;
+  };
+  const parseClass = () => {
+    let k = i + 1;
+    const negated = src[k] === "^";
+    if (negated) k++;
+    let body = "";
+    while (k < src.length && src[k] !== "]") {
+      if (src[k] === "\\") {
+        body += src[k] + (src[k + 1] ?? "");
+        k += 2;
+      } else {
+        body += src[k];
+        k++;
       }
-      return { firstSet: any(), canMatchNewline: true };
     }
-    case "CharacterClass": {
-      const expressions = node2.expressions;
+    if (src[k] !== "]") throw BAIL;
+    i = k + 1;
+    if (negated) return charNode(any(), true);
+    const ranges = parseClassRanges(body);
+    if (!ranges) return charNode(any(), true);
+    return charNode(rangesToSet(ranges), rangesHaveNewline(ranges));
+  };
+  const parseEscape = () => {
+    const e = src[i + 1];
+    if (e === void 0) throw BAIL;
+    if (e === "u" && /^[0-9a-fA-F]{4}$/.test(src.slice(i + 2, i + 6))) {
+      const cp = Number.parseInt(src.slice(i + 2, i + 6), 16);
+      i += 6;
+      return charNode(fromRange(cp, cp), cp === 10);
+    }
+    if (e === "x" && /^[0-9a-fA-F]{2}$/.test(src.slice(i + 2, i + 4))) {
+      const cp = Number.parseInt(src.slice(i + 2, i + 4), 16);
+      i += 4;
+      return charNode(fromRange(cp, cp), cp === 10);
+    }
+    i += 2;
+    switch (e) {
+      case "d":
+        return charNode(rangesToSet(shorthandRanges("d")), false);
+      case "w":
+        return charNode(rangesToSet(shorthandRanges("w")), false);
+      case "s":
+        return charNode(rangesToSet(shorthandRanges("s")), true);
+      case "D":
+      case "W":
+      case "S":
+        return charNode(any(), true);
+      // negated shorthand → widen
+      case "b":
+      case "B":
+        return EMPTY2;
+      // word boundary: zero-width
+      case "n":
+        return charNode(fromRange(10, 10), true);
+      case "r":
+        return charNode(fromRange(13, 13), false);
+      case "t":
+        return charNode(fromRange(9, 9), false);
+      case "f":
+        return charNode(fromRange(12, 12), false);
+      case "v":
+        return charNode(fromRange(11, 11), false);
+      case "0":
+        return charNode(fromRange(0, 0), false);
+      default:
+        if (e >= "1" && e <= "9") return ANY;
+        return charNode(fromRange(e.codePointAt(0), e.codePointAt(0)), e === "\n");
+    }
+  };
+  const node2 = parseAlt();
+  if (i < src.length) throw BAIL;
+  return node2;
+}
+function nullable(n) {
+  switch (n.t) {
+    case "char":
+      return false;
+    case "any":
+      return true;
+    case "empty":
+      return true;
+    case "seq":
+      return n.parts.every(nullable);
+    case "alt":
+      return n.arms.some(nullable);
+    case "rep":
+      return n.min === 0 || nullable(n.node);
+  }
+}
+function firstSet(n) {
+  switch (n.t) {
+    case "char":
+      return n.set;
+    case "any":
+      return any();
+    case "empty":
+      return empty();
+    case "rep":
+      return firstSet(n.node);
+    case "alt": {
+      let fs2 = empty();
+      for (const arm of n.arms) fs2 = union(fs2, firstSet(arm));
+      return fs2;
+    }
+    case "seq": {
       let fs2 = empty();
-      let canNL = false;
-      for (const expr of expressions) {
-        if (expr.type === "ClassRange") {
-          const from = expr.from.codePoint;
-          const to = expr.to.codePoint;
-          fs2 = union(fs2, fromRange(from, to));
-          if (from <= 10 && 10 <= to) canNL = true;
-        } else if (expr.type === "Char") {
-          const r = extractFirstSet(expr);
-          fs2 = union(fs2, r.firstSet);
-          canNL = canNL || r.canMatchNewline;
-        }
+      for (const part of n.parts) {
+        fs2 = union(fs2, firstSet(part));
+        if (!nullable(part)) break;
       }
-      if (node2.negative) return { firstSet: any(), canMatchNewline: true };
-      return { firstSet: fs2, canMatchNewline: canNL };
+      return fs2;
     }
-    case "Repetition": {
-      return extractFirstSet(node2.expression);
-    }
-    case "Group": {
-      return extractFirstSet(node2.expression);
+  }
+}
+function firstCanBeNewline(n) {
+  switch (n.t) {
+    case "char":
+      return n.nl;
+    case "any":
+      return true;
+    case "empty":
+      return false;
+    case "rep":
+      return firstCanBeNewline(n.node);
+    case "alt":
+      return n.arms.some(firstCanBeNewline);
+    case "seq": {
+      for (const part of n.parts) {
+        if (firstCanBeNewline(part)) return true;
+        if (!nullable(part)) break;
+      }
+      return false;
     }
-    default:
-      return { firstSet: any(), canMatchNewline: true };
   }
 }
+function firstSetFromRegex(source) {
+  let ast;
+  try {
+    ast = parseRegex(source);
+  } catch {
+    return { firstSet: any(), canMatchNewline: true };
+  }
+  if (nullable(ast)) return { firstSet: any(), canMatchNewline: true };
+  return { firstSet: firstSet(ast), canMatchNewline: firstCanBeNewline(ast) };
+}
 
 // src/combinators/keywords.ts
 function word(str, boundary = "_0-9A-Za-z") {
@@ -693,19 +865,19 @@ function keywords(words, opts = {}) {
   const boundary = opts.boundary ? `(?![${opts.boundary}])` : "";
   const flags = opts.caseInsensitive ? "iuy" : "uy";
   const re = new RegExp(`(?:${alt})${boundary}`, flags);
-  let firstSet = empty();
+  let firstSet2 = empty();
   for (const w of sorted) {
     if (w.length === 0) continue;
     const cp = w.codePointAt(0);
-    firstSet = union(firstSet, fromChar(cp));
+    firstSet2 = union(firstSet2, fromChar(cp));
     if (opts.caseInsensitive) {
       const u = String.fromCodePoint(cp).toUpperCase().codePointAt(0);
       const l = String.fromCodePoint(cp).toLowerCase().codePointAt(0);
-      if (u !== void 0) firstSet = union(firstSet, fromChar(u));
-      if (l !== void 0) firstSet = union(firstSet, fromChar(l));
+      if (u !== void 0) firstSet2 = union(firstSet2, fromChar(u));
+      if (l !== void 0) firstSet2 = union(firstSet2, fromChar(l));
     }
   }
-  const meta = { firstSet, canMatchNewline: false, isTrivia: false };
+  const meta = { firstSet: firstSet2, canMatchNewline: false, isTrivia: false };
   return {
     _tag: "keywords",
     _meta: meta,
@@ -2009,77 +2181,11 @@ function expect(combinator, label2) {
 
 // src/compiler/scannable-run.ts
 var BACKSLASH = 92;
-var CLASS_ESCAPES2 = { t: 9, n: 10, r: 13, f: 12, v: 11, "0": 0 };
 var META = new Set("()[]{}*+?|^$.".split(""));
-var SPACE_RANGES2 = [
-  [9, 13],
-  [32, 32],
-  [160, 160],
-  [5760, 5760],
-  [8192, 8202],
-  [8232, 8232],
-  [8233, 8233],
-  [8239, 8239],
-  [8287, 8287],
-  [12288, 12288],
-  [65279, 65279]
-];
-function shorthandRanges2(ch) {
-  if (ch === "d") return [[48, 57]];
-  if (ch === "s") return SPACE_RANGES2;
-  return [[48, 57], [65, 90], [97, 122], [95, 95]];
-}
-function readUnicodeEscape(body, i) {
-  if (body[i] !== "\\" || body[i + 1] !== "u") return null;
-  const hex = body.slice(i + 2, i + 6);
-  if (!/^[0-9a-fA-F]{4}$/.test(hex)) return null;
-  return { cp: Number.parseInt(hex, 16), next: i + 6 };
-}
-function parseClassRanges(body) {
-  const ranges = [];
-  let i = 0;
-  const readAtom = () => {
-    const ch = body[i];
-    if (ch === void 0) return null;
-    if (ch === "\\") {
-      const uni = readUnicodeEscape(body, i);
-      if (uni) {
-        i = uni.next;
-        return { cp: uni.cp };
-      }
-      const e = body[i + 1];
-      if (e === void 0) return null;
-      i += 2;
-      if (e in CLASS_ESCAPES2) return { cp: CLASS_ESCAPES2[e] };
-      if (e === "d" || e === "w" || e === "s") return { set: shorthandRanges2(e) };
-      if (e >= "a" && e <= "z" || e >= "A" && e <= "Z") return null;
-      return { cp: e.codePointAt(0) };
-    }
-    i += ch.length;
-    return { cp: ch.codePointAt(0) };
-  };
-  while (i < body.length) {
-    const lo = readAtom();
-    if (lo === null) return null;
-    if ("set" in lo) {
-      ranges.push(...lo.set);
-      continue;
-    }
-    if (body[i] === "-" && body[i + 1] !== void 0 && body[i + 1] !== "]") {
-      i += 1;
-      const hi = readAtom();
-      if (hi === null || "set" in hi) return null;
-      ranges.push([lo.cp, hi.cp]);
-    } else {
-      ranges.push([lo.cp, lo.cp]);
-    }
-  }
-  return ranges.length ? ranges : null;
-}
 function classToRanges(cls) {
-  if (cls === "\\d") return shorthandRanges2("d");
-  if (cls === "\\w") return shorthandRanges2("w");
-  if (cls === "\\s") return shorthandRanges2("s");
+  if (cls === "\\d") return shorthandRanges("d");
+  if (cls === "\\w") return shorthandRanges("w");
+  if (cls === "\\s") return shorthandRanges("s");
   const body = cls.slice(1, -1);
   if (body.startsWith("^")) return null;
   return parseClassRanges(body);
@@ -2097,7 +2203,7 @@ function literalCodePoints(frag) {
     if (ch === "\\") {
       const e = frag[i + 1];
       if (e === void 0) return null;
-      out.push(e in CLASS_ESCAPES2 ? CLASS_ESCAPES2[e] : e.codePointAt(0));
+      out.push(e in CLASS_ESCAPES ? CLASS_ESCAPES[e] : e.codePointAt(0));
       i += 2;
       continue;
     }
@@ -2190,7 +2296,7 @@ function parseSeqParts(source) {
       if (e === "d" || e === "w" || e === "s") {
         flush();
         i += 2;
-        i += runFrom(shorthandRanges2(e), false, source[i]);
+        i += runFrom(shorthandRanges(e), false, source[i]);
         continue;
       }
       const uni = readUnicodeEscape(source, i);
@@ -2199,8 +2305,8 @@ function parseSeqParts(source) {
         cp2 = uni.cp;
         i = uni.next;
       } else if (e === void 0) return null;
-      else if (e in CLASS_ESCAPES2) {
-        cp2 = CLASS_ESCAPES2[e];
+      else if (e in CLASS_ESCAPES) {
+        cp2 = CLASS_ESCAPES[e];
         i += 2;
       } else if (e >= "a" && e <= "z" || e >= "A" && e <= "Z") return null;
       else {
@@ -2307,7 +2413,7 @@ function rangesSubset(sub, sup) {
 }
 function parseClassOperand(body) {
   if (body === "\\d" || body === "\\w" || body === "\\s") {
-    return { ranges: shorthandRanges2(body[1]), negated: false };
+    return { ranges: shorthandRanges(body[1]), negated: false };
   }
   if (body.length >= 2 && body[0] === "[" && body[body.length - 1] === "]") {
     let inner = body.slice(1, -1);
@@ -2740,7 +2846,7 @@ function parseScanShapeCore(source) {
   }
   m = /^\\([dws])([+*])$/.exec(source);
   if (m) {
-    return { kind: "chars", ranges: shorthandRanges2(m[1]), minOne: m[2] === "+" };
+    return { kind: "chars", ranges: shorthandRanges(m[1]), minOne: m[2] === "+" };
   }
   m = /^(\[(?:\\.|[^\]])+\]|\\[dws])(\[(?:\\.|[^\]])+\]|\\[dws])\*$/.exec(source);
   if (m) {