strings.js
4.68 KB
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
"use strict";
// https://infra.spec.whatwg.org/#ascii-whitespace
const asciiWhitespaceRe = /^[\t\n\f\r ]$/;
exports.asciiWhitespaceRe = asciiWhitespaceRe;
// https://infra.spec.whatwg.org/#ascii-lowercase
exports.asciiLowercase = s => {
return s.replace(/[A-Z]/g, l => l.toLowerCase());
};
// https://infra.spec.whatwg.org/#ascii-uppercase
exports.asciiUppercase = s => {
return s.replace(/[a-z]/g, l => l.toUpperCase());
};
// https://infra.spec.whatwg.org/#strip-newlines
exports.stripNewlines = s => {
return s.replace(/[\n\r]+/g, "");
};
// https://infra.spec.whatwg.org/#strip-leading-and-trailing-ascii-whitespace
exports.stripLeadingAndTrailingASCIIWhitespace = s => {
return s.replace(/^[ \t\n\f\r]+/, "").replace(/[ \t\n\f\r]+$/, "");
};
// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
exports.stripAndCollapseASCIIWhitespace = s => {
return s.replace(/[ \t\n\f\r]+/g, " ").replace(/^[ \t\n\f\r]+/, "").replace(/[ \t\n\f\r]+$/, "");
};
// https://html.spec.whatwg.org/multipage/infrastructure.html#valid-simple-colour
exports.isValidSimpleColor = s => {
return /^#[a-fA-F\d]{6}$/.test(s);
};
// https://infra.spec.whatwg.org/#ascii-case-insensitive
exports.asciiCaseInsensitiveMatch = (a, b) => {
if (a.length !== b.length) {
return false;
}
for (let i = 0; i < a.length; ++i) {
if ((a.charCodeAt(i) | 32) !== (b.charCodeAt(i) | 32)) {
return false;
}
}
return true;
};
// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#rules-for-parsing-integers
// Error is represented as null.
const parseInteger = exports.parseInteger = input => {
// The implementation here is slightly different from the spec's. We want to use parseInt(), but parseInt() trims
// Unicode whitespace in addition to just ASCII ones, so we make sure that the trimmed prefix contains only ASCII
// whitespace ourselves.
const numWhitespace = input.length - input.trimStart().length;
if (/[^\t\n\f\r ]/.test(input.slice(0, numWhitespace))) {
return null;
}
// We don't allow hexadecimal numbers here.
// eslint-disable-next-line radix
const value = parseInt(input, 10);
if (Number.isNaN(value)) {
return null;
}
// parseInt() returns -0 for "-0". Normalize that here.
return value === 0 ? 0 : value;
};
// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#rules-for-parsing-non-negative-integers
// Error is represented as null.
exports.parseNonNegativeInteger = input => {
const value = parseInteger(input);
if (value === null) {
return null;
}
if (value < 0) {
return null;
}
return value;
};
// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-floating-point-number
const floatingPointNumRe = /^-?(?:\d+|\d*\.\d+)(?:[eE][-+]?\d+)?$/;
exports.isValidFloatingPointNumber = str => floatingPointNumRe.test(str);
// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#rules-for-parsing-floating-point-number-values
// Error is represented as null.
exports.parseFloatingPointNumber = str => {
// The implementation here is slightly different from the spec's. We need to use parseFloat() in order to retain
// accuracy, but parseFloat() trims Unicode whitespace in addition to just ASCII ones, so we make sure that the
// trimmed prefix contains only ASCII whitespace ourselves.
const numWhitespace = str.length - str.trimStart().length;
if (/[^\t\n\f\r ]/.test(str.slice(0, numWhitespace))) {
return null;
}
const parsed = parseFloat(str);
return isFinite(parsed) ? parsed : null;
};
// https://infra.spec.whatwg.org/#split-on-ascii-whitespace
exports.splitOnASCIIWhitespace = str => {
let position = 0;
const tokens = [];
while (position < str.length && asciiWhitespaceRe.test(str[position])) {
position++;
}
if (position === str.length) {
return tokens;
}
while (position < str.length) {
const start = position;
while (position < str.length && !asciiWhitespaceRe.test(str[position])) {
position++;
}
tokens.push(str.slice(start, position));
while (position < str.length && asciiWhitespaceRe.test(str[position])) {
position++;
}
}
return tokens;
};
// https://infra.spec.whatwg.org/#split-on-commas
exports.splitOnCommas = str => {
let position = 0;
const tokens = [];
while (position < str.length) {
let start = position;
while (position < str.length && str[position] !== ",") {
position++;
}
let end = position;
while (start < str.length && asciiWhitespaceRe.test(str[start])) {
start++;
}
while (end > start && asciiWhitespaceRe.test(str[end - 1])) {
end--;
}
tokens.push(str.slice(start, end));
if (position < str.length) {
position++;
}
}
return tokens;
};