@push.rocks/smartlinuxrepo 0.0.0-stage → 0.1.0

package/ts/debian/mailaddress.ts

@@ -0,0 +1,754 @@
+import { decodeRune, RUNE_ERROR, utf8ByteString } from './gostring.js';
+
+/**
+ * A port of Go 1.27.2 `net/mail.ParseAddress` (Gitea 28.2.0's toolchain,
+ * `go.mod`), used for the Debian `Maintainer` name. Inputs and outputs are
+ * byte strings (see `gostring.ts`). Only success and the parsed name matter
+ * to the caller, so error texts are not ported.
+ */
+
+export interface IMailAddress {
+  name: string;
+  address: string;
+}
+
+class MailError extends Error {}
+
+/** Go `mail.ParseAddress`; `null` where Go returns an error. */
+export function parseMailAddress(addressArg: string): IMailAddress | null {
+  try {
+    return new AddrParser(addressArg).parseSingleAddress();
+  } catch (error) {
+    if (error instanceof MailError) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+function fail(messageArg: string): never {
+  throw new MailError(messageArg);
+}
+
+class AddrParser {
+  constructor(public s: string) {}
+
+  public parseSingleAddress(): IMailAddress {
+    const addrs = this.parseAddress(true);
+    if (!this.skipCFWS()) {
+      fail('misformatted parenthetical comment');
+    }
+    if (!this.empty()) {
+      fail('expected single address');
+    }
+    if (addrs.length === 0) {
+      fail('empty group');
+    }
+    if (addrs.length > 1) {
+      fail('group with multiple addresses');
+    }
+    return addrs[0];
+  }
+
+  private parseAddress(handleGroupArg: boolean): IMailAddress[] {
+    this.skipSpace();
+    if (this.empty()) {
+      fail('no address');
+    }
+    const spec = this.tryConsumeAddrSpec();
+    if (spec !== null) {
+      let displayName = '';
+      this.skipSpace();
+      if (!this.empty() && this.peek() === '(') {
+        displayName = this.consumeDisplayNameComment();
+      }
+      return [{ name: displayName, address: spec }];
+    }
+
+    let displayName = '';
+    if (this.peek() !== '<') {
+      displayName = this.consumePhrase();
+    }
+    this.skipSpace();
+    if (handleGroupArg && this.consume(':')) {
+      return this.consumeGroupList();
+    }
+    if (!this.consume('<')) {
+      fail('no angle-addr');
+    }
+    const angleSpec = this.tryConsumeAddrSpec();
+    if (angleSpec === null) {
+      // Go returns the addr-spec error here
+      fail('invalid addr-spec');
+    }
+    if (!this.consume('>')) {
+      fail('unclosed angle-addr');
+    }
+    return [{ name: displayName, address: angleSpec }];
+  }
+
+  private consumeGroupList(): IMailAddress[] {
+    const group: IMailAddress[] = [];
+    this.skipSpace();
+    if (this.consume(';')) {
+      if (!this.skipCFWS()) {
+        fail('misformatted parenthetical comment');
+      }
+      return group;
+    }
+    for (;;) {
+      this.skipSpace();
+      group.push(...this.parseAddress(false));
+      if (!this.skipCFWS()) {
+        fail('misformatted parenthetical comment');
+      }
+      if (this.consume(';')) {
+        if (!this.skipCFWS()) {
+          fail('misformatted parenthetical comment');
+        }
+        break;
+      }
+      if (!this.consume(',')) {
+        fail('expected comma');
+      }
+    }
+    return group;
+  }
+
+  /** `consumeAddrSpec`, restoring the parser state on failure; `null` for Go's error. */
+  private tryConsumeAddrSpec(): string | null {
+    const orig = this.s;
+    try {
+      return this.consumeAddrSpec();
+    } catch (error) {
+      if (error instanceof MailError) {
+        this.s = orig;
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  private consumeAddrSpec(): string {
+    let localPart: string;
+    this.skipSpace();
+    if (this.empty()) {
+      fail('no addr-spec');
+    }
+    if (this.peek() === '"') {
+      localPart = this.consumeQuotedString();
+      if (localPart === '') {
+        fail('empty quoted string in addr-spec');
+      }
+    } else {
+      localPart = this.consumeAtom(true, false);
+    }
+    if (!this.consume('@')) {
+      fail('missing @ in addr-spec');
+    }
+    let domain: string;
+    this.skipSpace();
+    if (this.empty()) {
+      fail('no domain in addr-spec');
+    }
+    if (this.peek() === '[') {
+      domain = this.consumeDomainLiteral();
+    } else {
+      domain = this.consumeAtom(true, false);
+    }
+    return `${localPart}@${domain}`;
+  }
+
+  private consumePhrase(): string {
+    const words: string[] = [];
+    let sb = '';
+    let failed = false;
+    for (;;) {
+      if (words.length > 0) {
+        if (!this.skipCFWS()) {
+          fail('misformatted parenthetical comment');
+        }
+      }
+      let word: string;
+      let isEncoded = false;
+      this.skipSpace();
+      if (this.empty()) {
+        break;
+      }
+      try {
+        if (this.peek() === '"') {
+          word = this.consumeQuotedString();
+        } else {
+          word = this.consumeAtom(true, true);
+          [word, isEncoded] = decodeRfc2047Word(word);
+        }
+      } catch (error) {
+        if (!(error instanceof MailError)) {
+          throw error;
+        }
+        failed = true;
+        break;
+      }
+      if (isEncoded) {
+        sb += word;
+      } else if (sb.length > 0) {
+        words.push(sb);
+        sb = '';
+        words.push(word);
+      } else {
+        words.push(word);
+      }
+    }
+    if (sb.length > 0) {
+      words.push(sb);
+    }
+    // Go ignores the error once at least one word was read
+    if (failed && words.length === 0) {
+      fail('missing word in phrase');
+    }
+    return words.join(' ');
+  }
+
+  private consumeQuotedString(): string {
+    let i = 1;
+    let qs = '';
+    let escaped = false;
+    for (;;) {
+      const [rune, size] = decodeRune(this.s, i);
+      if (size === 0) {
+        fail('unclosed quoted-string');
+      }
+      if (size === 1 && rune === RUNE_ERROR) {
+        fail('invalid utf-8 in quoted-string');
+      }
+      if (escaped) {
+        if (!isVchar(rune) && !isWsp(rune)) {
+          fail('bad character in quoted-string');
+        }
+        qs += this.s.slice(i, i + size);
+        escaped = false;
+      } else if (isQtext(rune) || isWsp(rune)) {
+        qs += this.s.slice(i, i + size);
+      } else if (rune === 0x22) {
+        break;
+      } else if (rune === 0x5c) {
+        escaped = true;
+      } else {
+        fail('bad character in quoted-string');
+      }
+      i += size;
+    }
+    this.s = this.s.slice(i + 1);
+    return qs;
+  }
+
+  private consumeAtom(dotArg: boolean, permissiveArg: boolean): string {
+    let i = 0;
+    for (;;) {
+      const [rune, size] = decodeRune(this.s, i);
+      if (size === 1 && rune === RUNE_ERROR) {
+        fail('invalid utf-8 in address');
+      }
+      if (size === 0 || !isAtext(rune, dotArg)) {
+        break;
+      }
+      i += size;
+    }
+    if (i === 0) {
+      fail('invalid string');
+    }
+    const atom = this.s.slice(0, i);
+    this.s = this.s.slice(i);
+    if (!permissiveArg) {
+      if (atom.startsWith('.')) {
+        fail('leading dot in atom');
+      }
+      if (atom.includes('..')) {
+        fail('double dot in atom');
+      }
+      if (atom.endsWith('.')) {
+        fail('trailing dot in atom');
+      }
+    }
+    return atom;
+  }
+
+  private consumeDomainLiteral(): string {
+    if (!this.consume('[')) {
+      fail('missing "[" in domain-literal');
+    }
+    const dtextStart = this.s;
+    let dtextLength = 0;
+    for (;;) {
+      if (this.empty()) {
+        fail('unclosed domain-literal');
+      }
+      if (this.peek() === ']') {
+        break;
+      }
+      const [rune, size] = decodeRune(this.s, 0);
+      if (size === 1 && rune === RUNE_ERROR) {
+        fail('invalid utf-8 in domain-literal');
+      }
+      if (!isDtext(rune)) {
+        fail('bad character in domain-literal');
+      }
+      dtextLength += size;
+      this.s = this.s.slice(size);
+    }
+    const dtext = dtextStart.slice(0, dtextLength);
+    if (!this.consume(']')) {
+      fail('unclosed domain-literal');
+    }
+    if (dtext.startsWith('IPv6:')) {
+      if (parseNetIp(dtext.slice(5)) === null) {
+        fail('invalid IPv6 address in domain-literal');
+      }
+    } else {
+      const ip = parseNetIp(dtext);
+      if (ip === null || !isIpv4Mapped(ip)) {
+        fail('invalid IP address in domain-literal');
+      }
+    }
+    return `[${dtext}]`;
+  }
+
+  private consumeDisplayNameComment(): string {
+    if (!this.consume('(')) {
+      fail('comment does not start with (');
+    }
+    const [comment, ok] = this.consumeComment();
+    if (!ok) {
+      fail('misformatted parenthetical comment');
+    }
+    const words = comment.split(/[ \t]+/).filter((word) => word.length > 0);
+    for (let index = 0; index < words.length; index++) {
+      const [decoded, isEncoded] = decodeRfc2047Word(words[index]);
+      if (isEncoded) {
+        words[index] = decoded;
+      }
+    }
+    return words.join(' ');
+  }
+
+  private consume(charArg: string): boolean {
+    if (this.empty() || this.peek() !== charArg) {
+      return false;
+    }
+    this.s = this.s.slice(1);
+    return true;
+  }
+
+  private skipSpace(): void {
+    this.s = this.s.replace(/^[ \t]+/, '');
+  }
+
+  private peek(): string {
+    return this.s[0];
+  }
+
+  private empty(): boolean {
+    return this.s.length === 0;
+  }
+
+  private skipCFWS(): boolean {
+    this.skipSpace();
+    for (;;) {
+      if (!this.consume('(')) {
+        break;
+      }
+      const [, ok] = this.consumeComment();
+      if (!ok) {
+        return false;
+      }
+      this.skipSpace();
+    }
+    return true;
+  }
+
+  private consumeComment(): [string, boolean] {
+    let depth = 1;
+    let comment = '';
+    for (;;) {
+      if (this.empty() || depth === 0) {
+        break;
+      }
+      if (this.peek() === '\\' && this.s.length > 1) {
+        this.s = this.s.slice(1);
+      } else if (this.peek() === '(') {
+        depth += 1;
+      } else if (this.peek() === ')') {
+        depth -= 1;
+      }
+      if (depth > 0) {
+        comment += this.s[0];
+      }
+      this.s = this.s.slice(1);
+    }
+    return [comment, depth === 0];
+  }
+}
+
+/**
+ * Go `addrParser.decodeRFC2047Word` with the default decoder: `[word, true]`
+ * for a decoded encoded-word; `[s, false]` for anything that is not a valid
+ * encoded-word; a charset other than UTF-8, ISO-8859-1 and US-ASCII throws
+ * (Go returns that error with `isEncoded` true).
+ */
+function decodeRfc2047Word(wordArg: string): [string, boolean] {
+  if (
+    wordArg.length < 8 ||
+    !wordArg.startsWith('=?') ||
+    !wordArg.endsWith('?=') ||
+    wordArg.split('?').length - 1 !== 4
+  ) {
+    return [wordArg, false];
+  }
+  const inner = wordArg.slice(2, -2);
+  const firstMark = inner.indexOf('?');
+  const charset = inner.slice(0, firstMark);
+  if (charset === '') {
+    return [wordArg, false];
+  }
+  const rest = inner.slice(firstMark + 1);
+  const secondMark = rest.indexOf('?');
+  const encoding = rest.slice(0, secondMark);
+  const text = rest.slice(secondMark + 1);
+  if (encoding.length !== 1) {
+    return [wordArg, false];
+  }
+  let content: string | null;
+  if (encoding === 'B' || encoding === 'b') {
+    content = decodeStdBase64(text);
+  } else if (encoding === 'Q' || encoding === 'q') {
+    content = decodeQ(text);
+  } else {
+    content = null;
+  }
+  if (content === null) {
+    return [wordArg, false];
+  }
+  if (equalFoldAscii(charset, 'utf-8')) {
+    return [content, true];
+  }
+  if (equalFoldAscii(charset, 'iso-8859-1')) {
+    // each byte becomes the rune of the same value (Go `buf.WriteRune(rune(c))`)
+    return [utf8ByteString(content), true];
+  }
+  if (equalFoldAscii(charset, 'us-ascii')) {
+    let converted = '';
+    for (let i = 0; i < content.length; i++) {
+      const byte = content.charCodeAt(i);
+      converted += byte >= 0x80 ? '\xef\xbf\xbd' : content[i];
+    }
+    return [converted, true];
+  }
+  fail('charset not supported');
+}
+
+/**
+ * Go `strings.EqualFold(target, s)` for an ASCII lowercase target: each rune
+ * of `s` must fold to the target letter. Among the letters of the three
+ * charset names only `s` has a non-ASCII fold partner, U+017F.
+ */
+function equalFoldAscii(valueArg: string, targetArg: string): boolean {
+  let i = 0;
+  for (const target of targetArg) {
+    const [rune, size] = decodeRune(valueArg, i);
+    if (size === 0) {
+      return false;
+    }
+    i += size;
+    const code = target.charCodeAt(0);
+    if (rune === code) {
+      continue;
+    }
+    if (code >= 0x61 && code <= 0x7a && rune === code - 0x20) {
+      continue;
+    }
+    if (target === 's' && rune === 0x17f) {
+      continue;
+    }
+    return false;
+  }
+  return i === valueArg.length;
+}
+
+const BASE64_ALPHABET = /^[A-Za-z0-9+/]*$/;
+
+/** Go `base64.StdEncoding.DecodeString` (padding required, trailing bits ignored); `null` on error. */
+function decodeStdBase64(textArg: string): string | null {
+  // Go skips CR and LF; an atom holds neither
+  if (textArg.length % 4 !== 0) {
+    return null;
+  }
+  let body = textArg;
+  if (body.endsWith('==')) {
+    body = body.slice(0, -2);
+    if (body.length % 4 !== 2) {
+      return null;
+    }
+  } else if (body.endsWith('=')) {
+    body = body.slice(0, -1);
+    if (body.length % 4 !== 3) {
+      return null;
+    }
+  }
+  if (!BASE64_ALPHABET.test(body)) {
+    return null;
+  }
+  return Buffer.from(body, 'base64').toString('latin1');
+}
+
+/** Go `mime.qDecode`; `null` on error. */
+function decodeQ(textArg: string): string | null {
+  let decoded = '';
+  for (let i = 0; i < textArg.length; i++) {
+    const c = textArg.charCodeAt(i);
+    if (c === 0x5f) {
+      decoded += ' ';
+    } else if (c === 0x3d) {
+      if (i + 2 >= textArg.length) {
+        return null;
+      }
+      const high = hexValue(textArg.charCodeAt(i + 1));
+      const low = hexValue(textArg.charCodeAt(i + 2));
+      if (high < 0 || low < 0) {
+        return null;
+      }
+      decoded += String.fromCharCode((high << 4) | low);
+      i += 2;
+    } else if ((c >= 0x20 && c <= 0x7e) || c === 0x0a || c === 0x0d || c === 0x09) {
+      decoded += textArg[i];
+    } else {
+      return null;
+    }
+  }
+  return decoded;
+}
+
+function hexValue(codeArg: number): number {
+  if (codeArg >= 0x30 && codeArg <= 0x39) {
+    return codeArg - 0x30;
+  }
+  if (codeArg >= 0x41 && codeArg <= 0x46) {
+    return codeArg - 0x41 + 10;
+  }
+  if (codeArg >= 0x61 && codeArg <= 0x66) {
+    return codeArg - 0x61 + 10;
+  }
+  return -1;
+}
+
+function isAtext(runeArg: number, dotArg: boolean): boolean {
+  if (runeArg === 0x2e) {
+    return dotArg;
+  }
+  // RFC 5322 3.2.3 specials: ( ) < > [ ] : ; @ \ , "
+  if ('()<>[]:;@\\,"'.includes(String.fromCharCode(runeArg)) && runeArg < 0x80) {
+    return false;
+  }
+  return isVchar(runeArg);
+}
+
+function isQtext(runeArg: number): boolean {
+  if (runeArg === 0x5c || runeArg === 0x22) {
+    return false;
+  }
+  return isVchar(runeArg);
+}
+
+function isVchar(runeArg: number): boolean {
+  return (runeArg >= 0x21 && runeArg <= 0x7e) || runeArg >= 0x80;
+}
+
+function isWsp(runeArg: number): boolean {
+  return runeArg === 0x20 || runeArg === 0x09;
+}
+
+function isDtext(runeArg: number): boolean {
+  if (runeArg === 0x5b || runeArg === 0x5d || runeArg === 0x5c) {
+    return false;
+  }
+  return isVchar(runeArg);
+}
+
+// ---------------------------------------------------------------- net.ParseIP
+
+/**
+ * Go `net.ParseIP` (through `netip.ParseAddr`, zones refused): the 16-byte
+ * form, or `null`.
+ */
+function parseNetIp(valueArg: string): Uint8Array | null {
+  for (let i = 0; i < valueArg.length; i++) {
+    const c = valueArg[i];
+    if (c === '.') {
+      const fields = parseIpv4Fields(valueArg, 0, valueArg.length);
+      if (fields === null) {
+        return null;
+      }
+      const ip = new Uint8Array(16);
+      ip[10] = 0xff;
+      ip[11] = 0xff;
+      ip.set(fields, 12);
+      return ip;
+    }
+    if (c === ':') {
+      return parseIpv6(valueArg);
+    }
+    if (c === '%') {
+      return null;
+    }
+  }
+  return null;
+}
+
+function isIpv4Mapped(ipArg: Uint8Array): boolean {
+  for (let i = 0; i < 10; i++) {
+    if (ipArg[i] !== 0) {
+      return false;
+    }
+  }
+  return ipArg[10] === 0xff && ipArg[11] === 0xff;
+}
+
+/** Go `netip.parseIPv4Fields`. */
+function parseIpv4Fields(inArg: string, offArg: number, endArg: number): Uint8Array | null {
+  const fields = new Uint8Array(4);
+  let value = 0;
+  let pos = 0;
+  let digits = 0;
+  const s = inArg.slice(offArg, endArg);
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c >= 0x30 && c <= 0x39) {
+      if (digits === 1 && value === 0) {
+        return null;
+      }
+      value = value * 10 + (c - 0x30);
+      digits += 1;
+      if (value > 255) {
+        return null;
+      }
+    } else if (c === 0x2e) {
+      if (i === 0 || i === s.length - 1 || s[i - 1] === '.') {
+        return null;
+      }
+      if (pos === 3) {
+        return null;
+      }
+      fields[pos] = value;
+      pos += 1;
+      value = 0;
+      digits = 0;
+    } else {
+      return null;
+    }
+  }
+  if (pos < 3) {
+    return null;
+  }
+  fields[3] = value;
+  return fields;
+}
+
+/** Go `netip.parseIPv6`; a zone makes `net.ParseIP` fail, so any zone is `null`. */
+function parseIpv6(inArg: string): Uint8Array | null {
+  let s = inArg;
+  const percent = s.indexOf('%');
+  if (percent !== -1) {
+    // an empty zone is an error, a non-empty zone is refused by net.ParseIP
+    return null;
+  }
+  const ip = new Uint8Array(16);
+  let ellipsis = -1;
+  if (s.length >= 2 && s[0] === ':' && s[1] === ':') {
+    ellipsis = 0;
+    s = s.slice(2);
+    if (s.length === 0) {
+      return ip;
+    }
+  }
+  let i = 0;
+  while (i < 16) {
+    let off = 0;
+    let acc = 0;
+    for (; off < s.length; off++) {
+      const c = s.charCodeAt(off);
+      if (c >= 0x30 && c <= 0x39) {
+        acc = acc * 16 + (c - 0x30);
+      } else if (c >= 0x61 && c <= 0x66) {
+        acc = acc * 16 + (c - 0x61 + 10);
+      } else if (c >= 0x41 && c <= 0x46) {
+        acc = acc * 16 + (c - 0x41 + 10);
+      } else {
+        break;
+      }
+      if (off > 3) {
+        return null;
+      }
+      if (acc > 0xffff) {
+        return null;
+      }
+    }
+    if (off === 0) {
+      return null;
+    }
+    if (off < s.length && s[off] === '.') {
+      if (ellipsis < 0 && i !== 12) {
+        return null;
+      }
+      if (i + 4 > 16) {
+        return null;
+      }
+      const end = inArg.length;
+      const fields = parseIpv4Fields(inArg, end - s.length, end);
+      if (fields === null) {
+        return null;
+      }
+      ip.set(fields, i);
+      s = '';
+      i += 4;
+      break;
+    }
+    ip[i] = acc >> 8;
+    ip[i + 1] = acc & 0xff;
+    i += 2;
+    s = s.slice(off);
+    if (s.length === 0) {
+      break;
+    }
+    if (s[0] !== ':') {
+      return null;
+    } else if (s.length === 1) {
+      return null;
+    }
+    s = s.slice(1);
+    if (s[0] === ':') {
+      if (ellipsis >= 0) {
+        return null;
+      }
+      ellipsis = i;
+      s = s.slice(1);
+      if (s.length === 0) {
+        break;
+      }
+    }
+  }
+  if (s.length !== 0) {
+    return null;
+  }
+  if (i < 16) {
+    if (ellipsis < 0) {
+      return null;
+    }
+    const n = 16 - i;
+    for (let j = i - 1; j >= ellipsis; j--) {
+      ip[j + n] = ip[j];
+    }
+    ip.fill(0, ellipsis, ellipsis + n);
+  } else if (ellipsis >= 0) {
+    return null;
+  }
+  return ip;
+}