1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.// Copyright 2009 The Go Authors. All rights reserved.// Use of this source code is governed by a BSD-style// license that can be found in the LICENSE file.
/** * A reader for dealing with low level text based protocols. * * Based on * [net/textproto](https://github.com/golang/go/tree/master/src/net/textproto). * * @module */
import type { BufReader, ReadLineResult } from "../io/buffer.ts";import { concat } from "../bytes/mod.ts";
// Constants created for DRYconst CHAR_SPACE: number = " ".charCodeAt(0);const CHAR_TAB: number = "\t".charCodeAt(0);const CHAR_COLON: number = ":".charCodeAt(0);
const WHITESPACES: Array<number> = [CHAR_SPACE, CHAR_TAB];
const decoder = new TextDecoder();
// FROM https://github.com/denoland/deno/blob/b34628a26ab0187a827aa4ebe256e23178e25d39/cli/js/web/headers.ts#L9const invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/g;
function str(buf: Uint8Array | null | undefined): string {  return !buf ? "" : decoder.decode(buf);}
export class TextProtoReader {  constructor(readonly r: BufReader) {}
  /** readLine() reads a single line from the TextProtoReader,   * eliding the final \n or \r\n from the returned string.   */  async readLine(): Promise<string | null> {    const s = await this.readLineSlice();    return s === null ? null : str(s);  }
  /** ReadMimeHeader reads a MIME-style header from r.   * The header is a sequence of possibly continued Key: Value lines   * ending in a blank line.   * The returned map m maps CanonicalMIMEHeaderKey(key) to a   * sequence of values in the same order encountered in the input.   *   * For example, consider this input:   *   * 	My-Key: Value 1   * 	Long-Key: Even   * 	       Longer Value   * 	My-Key: Value 2   *   * Given that input, ReadMIMEHeader returns the map:   *   * 	map[string][]string{   * 		"My-Key": {"Value 1", "Value 2"},   * 		"Long-Key": {"Even Longer Value"},   * 	}   */  async readMimeHeader(): Promise<Headers | null> {    const m = new Headers();    let line: Uint8Array | undefined;
    // The first line cannot start with a leading space.    let buf = await this.r.peek(1);    if (buf === null) {      return null;    } else if (WHITESPACES.includes(buf[0])) {      line = (await this.readLineSlice()) as Uint8Array;    }
    buf = await this.r.peek(1);    if (buf === null) {      throw new Deno.errors.UnexpectedEof();    } else if (WHITESPACES.includes(buf[0])) {      throw new Deno.errors.InvalidData(        `malformed MIME header initial line: ${str(line)}`,      );    }
    while (true) {      const kv = await this.readLineSlice(); // readContinuedLineSlice      if (kv === null) throw new Deno.errors.UnexpectedEof();      if (kv.byteLength === 0) return m;
      // Key ends at first colon      let i = kv.indexOf(CHAR_COLON);      if (i < 0) {        throw new Deno.errors.InvalidData(          `malformed MIME header line: ${str(kv)}`,        );      }
      //let key = canonicalMIMEHeaderKey(kv.subarray(0, endKey));      const key = str(kv.subarray(0, i));
      // As per RFC 7230 field-name is a token,      // tokens consist of one or more chars.      // We could throw `Deno.errors.InvalidData` here,      // but better to be liberal in what we      // accept, so if we get an empty key, skip it.      if (key == "") {        continue;      }
      // Skip initial spaces in value.      i++; // skip colon      while (        i < kv.byteLength &&        (WHITESPACES.includes(kv[i]))      ) {        i++;      }      const value = str(kv.subarray(i)).replace(        invalidHeaderCharRegex,        encodeURI,      );
      // In case of invalid header we swallow the error      // example: "Audio Mode" => invalid due to space in the key      try {        m.append(key, value);      } catch {        // Pass      }    }  }
  /** ReadMIMEHeader reads a MIME-style header from r.   *   * @deprecated (will be removed after 0.157.0)  Use readMimeHeader instead. */  readMIMEHeader(): Promise<Headers | null> {    return this.readMimeHeader();  }
  async readLineSlice(): Promise<Uint8Array | null> {    let line = new Uint8Array(0);    let r: ReadLineResult | null = null;
    do {      r = await this.r.readLine();      // TODO(ry):      // This skipSpace() is definitely misplaced, but I don't know where it      // comes from nor how to fix it.
      //TODO(SmashingQuasar): Kept skipSpace to preserve behavior but it should be looked into to check if it makes sense when this is used.
      if (r !== null && this.skipSpace(r.line) !== 0) {        line = concat(line, r.line);      }    } while (r !== null && r.more);
    return r === null ? null : line;  }
  skipSpace(l: Uint8Array): number {    let n = 0;
    for (const val of l) {      if (!WHITESPACES.includes(val)) {        n++;      }    }
    return n;  }}