@intlify/message-compiler 12.0.0-alpha.2 → 12.0.0-alpha.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/message-compiler.d.ts +189 -230
- package/dist/message-compiler.esm-browser.js +1216 -1481
- package/dist/message-compiler.esm-browser.prod.js +788 -6
- package/dist/message-compiler.esm-bundler.js +1 -1
- package/dist/message-compiler.global.js +1295 -1561
- package/dist/message-compiler.global.prod.js +803 -6
- package/dist/message-compiler.js +1200 -1464
- package/dist/message-compiler.node.js +1242 -1517
- package/package.json +38 -38
|
@@ -1,1577 +1,1302 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
import { format, isString, join
|
|
7
|
-
import { SourceMapGenerator } from
|
|
8
|
-
|
|
1
|
+
/**
|
|
2
|
+
* @intlify/message-compiler v12.0.0-alpha.4
|
|
3
|
+
* (c) 2016-present kazuya kawaguchi and contributors
|
|
4
|
+
* @license MIT
|
|
5
|
+
**/
|
|
6
|
+
import { assign, format, isString, join } from "@intlify/shared";
|
|
7
|
+
import { SourceMapGenerator } from "source-map-js";
|
|
8
|
+
//#region packages/message-compiler/src/nodes.ts
|
|
9
|
+
let NodeTypes = /* @__PURE__ */ function(NodeTypes) {
|
|
10
|
+
NodeTypes[NodeTypes["Resource"] = 0] = "Resource";
|
|
11
|
+
NodeTypes[NodeTypes["Plural"] = 1] = "Plural";
|
|
12
|
+
NodeTypes[NodeTypes["Message"] = 2] = "Message";
|
|
13
|
+
NodeTypes[NodeTypes["Text"] = 3] = "Text";
|
|
14
|
+
NodeTypes[NodeTypes["Named"] = 4] = "Named";
|
|
15
|
+
NodeTypes[NodeTypes["List"] = 5] = "List";
|
|
16
|
+
NodeTypes[NodeTypes["Linked"] = 6] = "Linked";
|
|
17
|
+
NodeTypes[NodeTypes["LinkedKey"] = 7] = "LinkedKey";
|
|
18
|
+
NodeTypes[NodeTypes["LinkedModifier"] = 8] = "LinkedModifier";
|
|
19
|
+
NodeTypes[NodeTypes["Literal"] = 9] = "Literal";
|
|
20
|
+
return NodeTypes;
|
|
21
|
+
}({});
|
|
22
|
+
//#endregion
|
|
23
|
+
//#region packages/message-compiler/src/location.ts
|
|
9
24
|
const LOCATION_STUB = {
|
|
10
|
-
|
|
11
|
-
|
|
25
|
+
start: {
|
|
26
|
+
line: 1,
|
|
27
|
+
column: 1,
|
|
28
|
+
offset: 0
|
|
29
|
+
},
|
|
30
|
+
end: {
|
|
31
|
+
line: 1,
|
|
32
|
+
column: 1,
|
|
33
|
+
offset: 0
|
|
34
|
+
}
|
|
12
35
|
};
|
|
13
36
|
function createPosition(line, column, offset) {
|
|
14
|
-
|
|
37
|
+
return {
|
|
38
|
+
line,
|
|
39
|
+
column,
|
|
40
|
+
offset
|
|
41
|
+
};
|
|
15
42
|
}
|
|
16
43
|
function createLocation(start, end, source) {
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
44
|
+
const loc = {
|
|
45
|
+
start,
|
|
46
|
+
end
|
|
47
|
+
};
|
|
48
|
+
if (source != null) loc.source = source;
|
|
49
|
+
return loc;
|
|
22
50
|
}
|
|
23
|
-
|
|
51
|
+
//#endregion
|
|
52
|
+
//#region packages/message-compiler/src/helpers.ts
|
|
53
|
+
let HelperNameMap = /* @__PURE__ */ function(HelperNameMap) {
|
|
54
|
+
HelperNameMap["LIST"] = "list";
|
|
55
|
+
HelperNameMap["NAMED"] = "named";
|
|
56
|
+
HelperNameMap["PLURAL"] = "plural";
|
|
57
|
+
HelperNameMap["LINKED"] = "linked";
|
|
58
|
+
HelperNameMap["MESSAGE"] = "message";
|
|
59
|
+
HelperNameMap["TYPE"] = "type";
|
|
60
|
+
HelperNameMap["INTERPOLATE"] = "interpolate";
|
|
61
|
+
HelperNameMap["NORMALIZE"] = "normalize";
|
|
62
|
+
HelperNameMap["VALUES"] = "values";
|
|
63
|
+
return HelperNameMap;
|
|
64
|
+
}({});
|
|
65
|
+
const RE_HTML_TAG = /<[\w\s=":;#-/]+>/;
|
|
66
|
+
const detectHtmlTag = (source) => RE_HTML_TAG.test(source);
|
|
67
|
+
//#endregion
|
|
68
|
+
//#region packages/message-compiler/src/errors.ts
|
|
24
69
|
const CompileErrorCodes = {
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
// generator error codes
|
|
42
|
-
UNHANDLED_CODEGEN_NODE_TYPE: 15,
|
|
43
|
-
// minifier error codes
|
|
44
|
-
UNHANDLED_MINIFIER_NODE_TYPE: 16
|
|
70
|
+
EXPECTED_TOKEN: 1,
|
|
71
|
+
INVALID_TOKEN_IN_PLACEHOLDER: 2,
|
|
72
|
+
UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER: 3,
|
|
73
|
+
UNKNOWN_ESCAPE_SEQUENCE: 4,
|
|
74
|
+
INVALID_UNICODE_ESCAPE_SEQUENCE: 5,
|
|
75
|
+
UNBALANCED_CLOSING_BRACE: 6,
|
|
76
|
+
UNTERMINATED_CLOSING_BRACE: 7,
|
|
77
|
+
EMPTY_PLACEHOLDER: 8,
|
|
78
|
+
NOT_ALLOW_NEST_PLACEHOLDER: 9,
|
|
79
|
+
INVALID_LINKED_FORMAT: 10,
|
|
80
|
+
MUST_HAVE_MESSAGES_IN_PLURAL: 11,
|
|
81
|
+
UNEXPECTED_EMPTY_LINKED_MODIFIER: 12,
|
|
82
|
+
UNEXPECTED_EMPTY_LINKED_KEY: 13,
|
|
83
|
+
UNEXPECTED_LEXICAL_ANALYSIS: 14,
|
|
84
|
+
UNHANDLED_CODEGEN_NODE_TYPE: 15,
|
|
85
|
+
UNHANDLED_MINIFIER_NODE_TYPE: 16
|
|
45
86
|
};
|
|
46
|
-
// Special value for higher-order compilers to pick up the last code
|
|
47
|
-
// to avoid collision of error codes.
|
|
48
|
-
// This should always be kept as the last item.
|
|
49
87
|
const COMPILE_ERROR_CODES_EXTEND_POINT = 17;
|
|
50
88
|
/** @internal */
|
|
51
89
|
const errorMessages = {
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
// generator error messages
|
|
69
|
-
[CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE]: `unhandled codegen node type: '{0}'`,
|
|
70
|
-
// minimizer error messages
|
|
71
|
-
[CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE]: `unhandled mimifier node type: '{0}'`
|
|
90
|
+
[CompileErrorCodes.EXPECTED_TOKEN]: `Expected token: '{0}'`,
|
|
91
|
+
[CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER]: `Invalid token in placeholder: '{0}'`,
|
|
92
|
+
[CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER]: `Unterminated single quote in placeholder`,
|
|
93
|
+
[CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE]: `Unknown escape sequence: \\{0}`,
|
|
94
|
+
[CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE]: `Invalid unicode escape sequence: {0}`,
|
|
95
|
+
[CompileErrorCodes.UNBALANCED_CLOSING_BRACE]: `Unbalanced closing brace`,
|
|
96
|
+
[CompileErrorCodes.UNTERMINATED_CLOSING_BRACE]: `Unterminated closing brace`,
|
|
97
|
+
[CompileErrorCodes.EMPTY_PLACEHOLDER]: `Empty placeholder`,
|
|
98
|
+
[CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER]: `Not allowed nest placeholder`,
|
|
99
|
+
[CompileErrorCodes.INVALID_LINKED_FORMAT]: `Invalid linked format`,
|
|
100
|
+
[CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL]: `Plural must have messages`,
|
|
101
|
+
[CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER]: `Unexpected empty linked modifier`,
|
|
102
|
+
[CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY]: `Unexpected empty linked key`,
|
|
103
|
+
[CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS]: `Unexpected lexical analysis in token: '{0}'`,
|
|
104
|
+
[CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE]: `unhandled codegen node type: '{0}'`,
|
|
105
|
+
[CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE]: `unhandled mimifier node type: '{0}'`
|
|
72
106
|
};
|
|
73
107
|
function createCompileError(code, loc, options = {}) {
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
error.location = loc;
|
|
82
|
-
}
|
|
83
|
-
error.domain = domain;
|
|
84
|
-
return error;
|
|
108
|
+
const { domain, messages, args } = options;
|
|
109
|
+
const msg = format((messages || errorMessages)[code] || "", ...args || []);
|
|
110
|
+
const error = new SyntaxError(String(msg));
|
|
111
|
+
error.code = code;
|
|
112
|
+
if (loc) error.location = loc;
|
|
113
|
+
error.domain = domain;
|
|
114
|
+
return error;
|
|
85
115
|
}
|
|
86
116
|
/** @internal */
|
|
87
117
|
function defaultOnError(error) {
|
|
88
|
-
|
|
118
|
+
throw error;
|
|
89
119
|
}
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
const ERROR_DOMAIN$3 = 'parser';
|
|
120
|
+
//#endregion
|
|
121
|
+
//#region packages/message-compiler/src/generator.ts
|
|
122
|
+
const ERROR_DOMAIN$3 = "parser";
|
|
94
123
|
function createCodeGenerator(ast, options) {
|
|
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
|
-
newline,
|
|
162
|
-
helper,
|
|
163
|
-
needIndent
|
|
164
|
-
};
|
|
124
|
+
const { sourceMap, filename, breakLineCode, needIndent: _needIndent } = options;
|
|
125
|
+
const location = options.location !== false;
|
|
126
|
+
const _context = {
|
|
127
|
+
filename,
|
|
128
|
+
code: "",
|
|
129
|
+
column: 1,
|
|
130
|
+
line: 1,
|
|
131
|
+
offset: 0,
|
|
132
|
+
map: void 0,
|
|
133
|
+
breakLineCode,
|
|
134
|
+
needIndent: _needIndent,
|
|
135
|
+
indentLevel: 0
|
|
136
|
+
};
|
|
137
|
+
if (location && ast.loc) _context.source = ast.loc.source;
|
|
138
|
+
const context = () => _context;
|
|
139
|
+
function push(code, node) {
|
|
140
|
+
_context.code += code;
|
|
141
|
+
if (_context.map) {
|
|
142
|
+
if (node && node.loc && node.loc !== LOCATION_STUB) addMapping(node.loc.start, getMappingName(node));
|
|
143
|
+
advancePositionWithSource(_context, code);
|
|
144
|
+
}
|
|
145
|
+
}
|
|
146
|
+
function _newline(n, withBreakLine = true) {
|
|
147
|
+
const _breakLineCode = withBreakLine ? breakLineCode : "";
|
|
148
|
+
push(_needIndent ? _breakLineCode + ` `.repeat(n) : _breakLineCode);
|
|
149
|
+
}
|
|
150
|
+
function indent(withNewLine = true) {
|
|
151
|
+
const level = ++_context.indentLevel;
|
|
152
|
+
withNewLine && _newline(level);
|
|
153
|
+
}
|
|
154
|
+
function deindent(withNewLine = true) {
|
|
155
|
+
const level = --_context.indentLevel;
|
|
156
|
+
withNewLine && _newline(level);
|
|
157
|
+
}
|
|
158
|
+
function newline() {
|
|
159
|
+
_newline(_context.indentLevel);
|
|
160
|
+
}
|
|
161
|
+
const helper = (key) => `_${key}`;
|
|
162
|
+
const needIndent = () => _context.needIndent;
|
|
163
|
+
function addMapping(loc, name) {
|
|
164
|
+
_context.map.addMapping({
|
|
165
|
+
name,
|
|
166
|
+
source: _context.filename,
|
|
167
|
+
original: {
|
|
168
|
+
line: loc.line,
|
|
169
|
+
column: loc.column - 1
|
|
170
|
+
},
|
|
171
|
+
generated: {
|
|
172
|
+
line: _context.line,
|
|
173
|
+
column: _context.column - 1
|
|
174
|
+
}
|
|
175
|
+
});
|
|
176
|
+
}
|
|
177
|
+
if (location && sourceMap) {
|
|
178
|
+
_context.map = new SourceMapGenerator();
|
|
179
|
+
_context.map.setSourceContent(filename, _context.source);
|
|
180
|
+
}
|
|
181
|
+
return {
|
|
182
|
+
context,
|
|
183
|
+
push,
|
|
184
|
+
indent,
|
|
185
|
+
deindent,
|
|
186
|
+
newline,
|
|
187
|
+
helper,
|
|
188
|
+
needIndent
|
|
189
|
+
};
|
|
165
190
|
}
|
|
166
191
|
function generateLinkedNode(generator, node) {
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
generator.push(`, undefined, _type`);
|
|
177
|
-
}
|
|
178
|
-
generator.push(`)`);
|
|
192
|
+
const { helper } = generator;
|
|
193
|
+
generator.push(`${helper("linked")}(`);
|
|
194
|
+
generateNode(generator, node.key);
|
|
195
|
+
if (node.modifier) {
|
|
196
|
+
generator.push(`, `);
|
|
197
|
+
generateNode(generator, node.modifier);
|
|
198
|
+
generator.push(`, _type`);
|
|
199
|
+
} else generator.push(`, undefined, _type`);
|
|
200
|
+
generator.push(`)`);
|
|
179
201
|
}
|
|
180
202
|
function generateMessageNode(generator, node) {
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
generator.deindent(needIndent());
|
|
193
|
-
generator.push('])');
|
|
203
|
+
const { helper, needIndent } = generator;
|
|
204
|
+
generator.push(`${helper("normalize")}([`);
|
|
205
|
+
generator.indent(needIndent());
|
|
206
|
+
const length = node.items.length;
|
|
207
|
+
for (let i = 0; i < length; i++) {
|
|
208
|
+
generateNode(generator, node.items[i]);
|
|
209
|
+
if (i === length - 1) break;
|
|
210
|
+
generator.push(", ");
|
|
211
|
+
}
|
|
212
|
+
generator.deindent(needIndent());
|
|
213
|
+
generator.push("])");
|
|
194
214
|
}
|
|
195
215
|
function generatePluralNode(generator, node) {
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
generator.push(`])`);
|
|
210
|
-
}
|
|
216
|
+
const { helper, needIndent } = generator;
|
|
217
|
+
if (node.cases.length > 1) {
|
|
218
|
+
generator.push(`${helper("plural")}([`);
|
|
219
|
+
generator.indent(needIndent());
|
|
220
|
+
const length = node.cases.length;
|
|
221
|
+
for (let i = 0; i < length; i++) {
|
|
222
|
+
generateNode(generator, node.cases[i]);
|
|
223
|
+
if (i === length - 1) break;
|
|
224
|
+
generator.push(", ");
|
|
225
|
+
}
|
|
226
|
+
generator.deindent(needIndent());
|
|
227
|
+
generator.push(`])`);
|
|
228
|
+
}
|
|
211
229
|
}
|
|
212
230
|
function generateResource(generator, node) {
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
}
|
|
216
|
-
else {
|
|
217
|
-
generator.push('null');
|
|
218
|
-
}
|
|
231
|
+
if (node.body) generateNode(generator, node.body);
|
|
232
|
+
else generator.push("null");
|
|
219
233
|
}
|
|
220
234
|
function generateNode(generator, node) {
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
});
|
|
259
|
-
}
|
|
260
|
-
}
|
|
235
|
+
const { helper } = generator;
|
|
236
|
+
switch (node.type) {
|
|
237
|
+
case 0:
|
|
238
|
+
generateResource(generator, node);
|
|
239
|
+
break;
|
|
240
|
+
case 1:
|
|
241
|
+
generatePluralNode(generator, node);
|
|
242
|
+
break;
|
|
243
|
+
case 2:
|
|
244
|
+
generateMessageNode(generator, node);
|
|
245
|
+
break;
|
|
246
|
+
case 6:
|
|
247
|
+
generateLinkedNode(generator, node);
|
|
248
|
+
break;
|
|
249
|
+
case 8:
|
|
250
|
+
generator.push(JSON.stringify(node.value), node);
|
|
251
|
+
break;
|
|
252
|
+
case 7:
|
|
253
|
+
generator.push(JSON.stringify(node.value), node);
|
|
254
|
+
break;
|
|
255
|
+
case 5:
|
|
256
|
+
generator.push(`${helper("interpolate")}(${helper("list")}(${node.index}))`, node);
|
|
257
|
+
break;
|
|
258
|
+
case 4:
|
|
259
|
+
generator.push(`${helper("interpolate")}(${helper("named")}(${JSON.stringify(node.key)}))`, node);
|
|
260
|
+
break;
|
|
261
|
+
case 9:
|
|
262
|
+
generator.push(JSON.stringify(node.value), node);
|
|
263
|
+
break;
|
|
264
|
+
case 3:
|
|
265
|
+
generator.push(JSON.stringify(node.value), node);
|
|
266
|
+
break;
|
|
267
|
+
default: throw createCompileError(CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE, null, {
|
|
268
|
+
domain: ERROR_DOMAIN$3,
|
|
269
|
+
args: [node.type]
|
|
270
|
+
});
|
|
271
|
+
}
|
|
261
272
|
}
|
|
262
|
-
// generate code from AST
|
|
263
273
|
const generate = (ast, options = {}) => {
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
delete ast.helpers;
|
|
295
|
-
const { code, map } = generator.context();
|
|
296
|
-
return {
|
|
297
|
-
ast,
|
|
298
|
-
code,
|
|
299
|
-
map: map ? map.toJSON() : undefined // eslint-disable-line @typescript-eslint/no-explicit-any
|
|
300
|
-
};
|
|
274
|
+
const mode = isString(options.mode) ? options.mode : "normal";
|
|
275
|
+
const filename = isString(options.filename) ? options.filename : "message.intl";
|
|
276
|
+
const sourceMap = !!options.sourceMap;
|
|
277
|
+
const breakLineCode = options.breakLineCode != null ? options.breakLineCode : mode === "arrow" ? ";" : "\n";
|
|
278
|
+
const needIndent = options.needIndent ? options.needIndent : mode !== "arrow";
|
|
279
|
+
const helpers = ast.helpers || [];
|
|
280
|
+
const generator = createCodeGenerator(ast, {
|
|
281
|
+
mode,
|
|
282
|
+
filename,
|
|
283
|
+
sourceMap,
|
|
284
|
+
breakLineCode,
|
|
285
|
+
needIndent
|
|
286
|
+
});
|
|
287
|
+
generator.push(mode === "normal" ? `function __msg__ (ctx) {` : `(ctx) => {`);
|
|
288
|
+
generator.indent(needIndent);
|
|
289
|
+
if (helpers.length > 0) {
|
|
290
|
+
generator.push(`const { ${join(helpers.map((s) => `${s}: _${s}`), ", ")} } = ctx`);
|
|
291
|
+
generator.newline();
|
|
292
|
+
}
|
|
293
|
+
generator.push(`return `);
|
|
294
|
+
generateNode(generator, ast);
|
|
295
|
+
generator.deindent(needIndent);
|
|
296
|
+
generator.push(`}`);
|
|
297
|
+
delete ast.helpers;
|
|
298
|
+
const { code, map } = generator.context();
|
|
299
|
+
return {
|
|
300
|
+
ast,
|
|
301
|
+
code,
|
|
302
|
+
map: map ? map.toJSON() : void 0
|
|
303
|
+
};
|
|
301
304
|
};
|
|
302
305
|
function getMappingName(node) {
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
return node.key;
|
|
313
|
-
default:
|
|
314
|
-
return undefined;
|
|
315
|
-
}
|
|
306
|
+
switch (node.type) {
|
|
307
|
+
case 3:
|
|
308
|
+
case 9:
|
|
309
|
+
case 8:
|
|
310
|
+
case 7: return node.value;
|
|
311
|
+
case 5: return node.index.toString();
|
|
312
|
+
case 4: return node.key;
|
|
313
|
+
default: return;
|
|
314
|
+
}
|
|
316
315
|
}
|
|
317
316
|
function advancePositionWithSource(pos, source, numberOfCharacters = source.length) {
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
|
|
328
|
-
pos.column =
|
|
329
|
-
lastNewLinePos === -1
|
|
330
|
-
? pos.column + numberOfCharacters
|
|
331
|
-
: numberOfCharacters - lastNewLinePos;
|
|
332
|
-
return pos;
|
|
317
|
+
let linesCount = 0;
|
|
318
|
+
let lastNewLinePos = -1;
|
|
319
|
+
for (let i = 0; i < numberOfCharacters; i++) if (source.charCodeAt(i) === 10) {
|
|
320
|
+
linesCount++;
|
|
321
|
+
lastNewLinePos = i;
|
|
322
|
+
}
|
|
323
|
+
pos.offset += numberOfCharacters;
|
|
324
|
+
pos.line += linesCount;
|
|
325
|
+
pos.column = lastNewLinePos === -1 ? pos.column + numberOfCharacters : numberOfCharacters - lastNewLinePos;
|
|
326
|
+
return pos;
|
|
333
327
|
}
|
|
334
|
-
|
|
335
|
-
|
|
336
|
-
|
|
328
|
+
//#endregion
|
|
329
|
+
//#region packages/message-compiler/src/mangler.ts
|
|
330
|
+
const ERROR_DOMAIN$2 = "minifier";
|
|
337
331
|
function mangle(node) {
|
|
338
|
-
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
|
|
342
|
-
|
|
343
|
-
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
377
|
-
|
|
378
|
-
|
|
379
|
-
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
|
|
383
|
-
|
|
384
|
-
|
|
385
|
-
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
390
|
-
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
throw createCompileError(CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE, null, {
|
|
409
|
-
domain: ERROR_DOMAIN$2,
|
|
410
|
-
args: [node.type]
|
|
411
|
-
});
|
|
412
|
-
}
|
|
413
|
-
}
|
|
414
|
-
delete node.type;
|
|
332
|
+
node.t = node.type;
|
|
333
|
+
switch (node.type) {
|
|
334
|
+
case 0: {
|
|
335
|
+
const resource = node;
|
|
336
|
+
mangle(resource.body);
|
|
337
|
+
resource.b = resource.body;
|
|
338
|
+
delete resource.body;
|
|
339
|
+
break;
|
|
340
|
+
}
|
|
341
|
+
case 1: {
|
|
342
|
+
const plural = node;
|
|
343
|
+
const cases = plural.cases;
|
|
344
|
+
for (let i = 0; i < cases.length; i++) mangle(cases[i]);
|
|
345
|
+
plural.c = cases;
|
|
346
|
+
delete plural.cases;
|
|
347
|
+
break;
|
|
348
|
+
}
|
|
349
|
+
case 2: {
|
|
350
|
+
const message = node;
|
|
351
|
+
const items = message.items;
|
|
352
|
+
for (let i = 0; i < items.length; i++) mangle(items[i]);
|
|
353
|
+
message.i = items;
|
|
354
|
+
delete message.items;
|
|
355
|
+
if (message.static) {
|
|
356
|
+
message.s = message.static;
|
|
357
|
+
delete message.static;
|
|
358
|
+
}
|
|
359
|
+
break;
|
|
360
|
+
}
|
|
361
|
+
case 3:
|
|
362
|
+
case 9:
|
|
363
|
+
case 8:
|
|
364
|
+
case 7: {
|
|
365
|
+
const valueNode = node;
|
|
366
|
+
if (valueNode.value) {
|
|
367
|
+
valueNode.v = valueNode.value;
|
|
368
|
+
delete valueNode.value;
|
|
369
|
+
}
|
|
370
|
+
break;
|
|
371
|
+
}
|
|
372
|
+
case 6: {
|
|
373
|
+
const linked = node;
|
|
374
|
+
mangle(linked.key);
|
|
375
|
+
linked.k = linked.key;
|
|
376
|
+
delete linked.key;
|
|
377
|
+
if (linked.modifier) {
|
|
378
|
+
mangle(linked.modifier);
|
|
379
|
+
linked.m = linked.modifier;
|
|
380
|
+
delete linked.modifier;
|
|
381
|
+
}
|
|
382
|
+
break;
|
|
383
|
+
}
|
|
384
|
+
case 5: {
|
|
385
|
+
const list = node;
|
|
386
|
+
list.i = list.index;
|
|
387
|
+
delete list.index;
|
|
388
|
+
break;
|
|
389
|
+
}
|
|
390
|
+
case 4: {
|
|
391
|
+
const named = node;
|
|
392
|
+
named.k = named.key;
|
|
393
|
+
delete named.key;
|
|
394
|
+
break;
|
|
395
|
+
}
|
|
396
|
+
default: throw createCompileError(CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE, null, {
|
|
397
|
+
domain: ERROR_DOMAIN$2,
|
|
398
|
+
args: [node.type]
|
|
399
|
+
});
|
|
400
|
+
}
|
|
401
|
+
delete node.type;
|
|
415
402
|
}
|
|
416
|
-
|
|
417
|
-
|
|
403
|
+
//#endregion
|
|
404
|
+
//#region packages/message-compiler/src/optimizer.ts
|
|
418
405
|
function optimize(ast) {
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
else {
|
|
424
|
-
body.cases.forEach(c => optimizeMessageNode(c));
|
|
425
|
-
}
|
|
426
|
-
return ast;
|
|
406
|
+
const body = ast.body;
|
|
407
|
+
if (body.type === 2) optimizeMessageNode(body);
|
|
408
|
+
else body.cases.forEach((c) => optimizeMessageNode(c));
|
|
409
|
+
return ast;
|
|
427
410
|
}
|
|
428
411
|
function optimizeMessageNode(message) {
|
|
429
|
-
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
|
|
444
|
-
|
|
445
|
-
|
|
446
|
-
|
|
447
|
-
|
|
448
|
-
|
|
449
|
-
|
|
450
|
-
|
|
451
|
-
const item = message.items[i];
|
|
452
|
-
if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
|
|
453
|
-
delete item.value; // optimization for size
|
|
454
|
-
}
|
|
455
|
-
}
|
|
456
|
-
}
|
|
457
|
-
}
|
|
412
|
+
if (message.items.length === 1) {
|
|
413
|
+
const item = message.items[0];
|
|
414
|
+
if (item.type === 3 || item.type === 9) {
|
|
415
|
+
message.static = item.value;
|
|
416
|
+
delete item.value;
|
|
417
|
+
}
|
|
418
|
+
} else {
|
|
419
|
+
const values = [];
|
|
420
|
+
for (let i = 0; i < message.items.length; i++) {
|
|
421
|
+
const item = message.items[i];
|
|
422
|
+
if (!(item.type === 3 || item.type === 9)) break;
|
|
423
|
+
if (item.value == null) break;
|
|
424
|
+
values.push(item.value);
|
|
425
|
+
}
|
|
426
|
+
if (values.length === message.items.length) {
|
|
427
|
+
message.static = join(values);
|
|
428
|
+
for (let i = 0; i < message.items.length; i++) {
|
|
429
|
+
const item = message.items[i];
|
|
430
|
+
if (item.type === 3 || item.type === 9) delete item.value;
|
|
431
|
+
}
|
|
432
|
+
}
|
|
433
|
+
}
|
|
458
434
|
}
|
|
459
|
-
|
|
460
|
-
const CHAR_SP = ' ';
|
|
461
|
-
const CHAR_CR = '\r';
|
|
462
|
-
const CHAR_LF = '\n';
|
|
463
|
-
const CHAR_LS = String.fromCharCode(0x2028);
|
|
464
|
-
const CHAR_PS = String.fromCharCode(0x2029);
|
|
465
435
|
function createScanner(str) {
|
|
466
|
-
|
|
467
|
-
|
|
468
|
-
|
|
469
|
-
|
|
470
|
-
|
|
471
|
-
|
|
472
|
-
|
|
473
|
-
|
|
474
|
-
|
|
475
|
-
|
|
476
|
-
|
|
477
|
-
|
|
478
|
-
|
|
479
|
-
|
|
480
|
-
|
|
481
|
-
|
|
482
|
-
|
|
483
|
-
|
|
484
|
-
|
|
485
|
-
|
|
486
|
-
|
|
487
|
-
|
|
488
|
-
|
|
489
|
-
|
|
490
|
-
|
|
491
|
-
|
|
492
|
-
|
|
493
|
-
|
|
494
|
-
|
|
495
|
-
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
|
|
500
|
-
|
|
501
|
-
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
|
|
505
|
-
|
|
506
|
-
|
|
507
|
-
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
|
|
511
|
-
|
|
512
|
-
|
|
513
|
-
|
|
514
|
-
|
|
515
|
-
|
|
516
|
-
|
|
517
|
-
|
|
518
|
-
|
|
519
|
-
|
|
520
|
-
|
|
521
|
-
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
|
|
525
|
-
|
|
526
|
-
|
|
527
|
-
next,
|
|
528
|
-
peek,
|
|
529
|
-
reset,
|
|
530
|
-
resetPeek,
|
|
531
|
-
skipToPeek
|
|
532
|
-
};
|
|
436
|
+
const _buf = str;
|
|
437
|
+
let _index = 0;
|
|
438
|
+
let _line = 1;
|
|
439
|
+
let _column = 1;
|
|
440
|
+
let _peekOffset = 0;
|
|
441
|
+
const isCRLF = (index) => _buf[index] === "\r" && _buf[index + 1] === "\n";
|
|
442
|
+
const isLF = (index) => _buf[index] === "\n";
|
|
443
|
+
const isPS = (index) => _buf[index] === "\u2029";
|
|
444
|
+
const isLS = (index) => _buf[index] === "\u2028";
|
|
445
|
+
const isLineEnd = (index) => isCRLF(index) || isLF(index) || isPS(index) || isLS(index);
|
|
446
|
+
const index = () => _index;
|
|
447
|
+
const line = () => _line;
|
|
448
|
+
const column = () => _column;
|
|
449
|
+
const peekOffset = () => _peekOffset;
|
|
450
|
+
const charAt = (offset) => isCRLF(offset) || isPS(offset) || isLS(offset) ? "\n" : _buf[offset];
|
|
451
|
+
const currentChar = () => charAt(_index);
|
|
452
|
+
const currentPeek = () => charAt(_index + _peekOffset);
|
|
453
|
+
function next() {
|
|
454
|
+
_peekOffset = 0;
|
|
455
|
+
if (isLineEnd(_index)) {
|
|
456
|
+
_line++;
|
|
457
|
+
_column = 0;
|
|
458
|
+
}
|
|
459
|
+
if (isCRLF(_index)) _index++;
|
|
460
|
+
_index++;
|
|
461
|
+
_column++;
|
|
462
|
+
return _buf[_index];
|
|
463
|
+
}
|
|
464
|
+
function peek() {
|
|
465
|
+
if (isCRLF(_index + _peekOffset)) _peekOffset++;
|
|
466
|
+
_peekOffset++;
|
|
467
|
+
return _buf[_index + _peekOffset];
|
|
468
|
+
}
|
|
469
|
+
function reset() {
|
|
470
|
+
_index = 0;
|
|
471
|
+
_line = 1;
|
|
472
|
+
_column = 1;
|
|
473
|
+
_peekOffset = 0;
|
|
474
|
+
}
|
|
475
|
+
function resetPeek(offset = 0) {
|
|
476
|
+
_peekOffset = offset;
|
|
477
|
+
}
|
|
478
|
+
function skipToPeek() {
|
|
479
|
+
const target = _index + _peekOffset;
|
|
480
|
+
while (target !== _index) next();
|
|
481
|
+
_peekOffset = 0;
|
|
482
|
+
}
|
|
483
|
+
return {
|
|
484
|
+
index,
|
|
485
|
+
line,
|
|
486
|
+
column,
|
|
487
|
+
peekOffset,
|
|
488
|
+
charAt,
|
|
489
|
+
currentChar,
|
|
490
|
+
currentPeek,
|
|
491
|
+
next,
|
|
492
|
+
peek,
|
|
493
|
+
reset,
|
|
494
|
+
resetPeek,
|
|
495
|
+
skipToPeek
|
|
496
|
+
};
|
|
533
497
|
}
|
|
534
|
-
|
|
535
|
-
|
|
536
|
-
const
|
|
498
|
+
//#endregion
|
|
499
|
+
//#region packages/message-compiler/src/tokenizer.ts
|
|
500
|
+
const EOF = void 0;
|
|
501
|
+
const DOT = ".";
|
|
537
502
|
const LITERAL_DELIMITER = "'";
|
|
538
|
-
const ERROR_DOMAIN$1 =
|
|
503
|
+
const ERROR_DOMAIN$1 = "tokenizer";
|
|
539
504
|
function createTokenizer(source, options = {}) {
|
|
540
|
-
|
|
541
|
-
|
|
542
|
-
|
|
543
|
-
|
|
544
|
-
|
|
545
|
-
|
|
546
|
-
|
|
547
|
-
|
|
548
|
-
|
|
549
|
-
|
|
550
|
-
|
|
551
|
-
|
|
552
|
-
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
|
|
556
|
-
|
|
557
|
-
|
|
558
|
-
|
|
559
|
-
|
|
560
|
-
|
|
561
|
-
|
|
562
|
-
|
|
563
|
-
|
|
564
|
-
|
|
565
|
-
|
|
566
|
-
|
|
567
|
-
|
|
568
|
-
|
|
569
|
-
|
|
570
|
-
|
|
571
|
-
|
|
572
|
-
|
|
573
|
-
|
|
574
|
-
|
|
575
|
-
|
|
576
|
-
|
|
577
|
-
|
|
578
|
-
|
|
579
|
-
|
|
580
|
-
|
|
581
|
-
|
|
582
|
-
|
|
583
|
-
|
|
584
|
-
|
|
585
|
-
|
|
586
|
-
|
|
587
|
-
|
|
588
|
-
|
|
589
|
-
|
|
590
|
-
|
|
591
|
-
|
|
592
|
-
|
|
593
|
-
|
|
594
|
-
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
|
|
600
|
-
|
|
601
|
-
|
|
602
|
-
|
|
603
|
-
|
|
604
|
-
|
|
605
|
-
|
|
606
|
-
|
|
607
|
-
|
|
608
|
-
|
|
609
|
-
|
|
610
|
-
|
|
611
|
-
|
|
612
|
-
|
|
613
|
-
|
|
614
|
-
|
|
615
|
-
|
|
616
|
-
|
|
617
|
-
|
|
618
|
-
|
|
619
|
-
|
|
620
|
-
|
|
621
|
-
|
|
622
|
-
|
|
623
|
-
|
|
624
|
-
|
|
625
|
-
|
|
626
|
-
|
|
627
|
-
|
|
628
|
-
|
|
629
|
-
|
|
630
|
-
|
|
631
|
-
|
|
632
|
-
|
|
633
|
-
|
|
634
|
-
|
|
635
|
-
|
|
636
|
-
|
|
637
|
-
|
|
638
|
-
|
|
639
|
-
|
|
640
|
-
|
|
641
|
-
|
|
642
|
-
|
|
643
|
-
|
|
644
|
-
|
|
645
|
-
|
|
646
|
-
|
|
647
|
-
|
|
648
|
-
|
|
649
|
-
|
|
650
|
-
|
|
651
|
-
|
|
652
|
-
|
|
653
|
-
|
|
654
|
-
|
|
655
|
-
|
|
656
|
-
|
|
657
|
-
|
|
658
|
-
|
|
659
|
-
|
|
660
|
-
|
|
661
|
-
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
|
|
666
|
-
|
|
667
|
-
|
|
668
|
-
|
|
669
|
-
|
|
670
|
-
|
|
671
|
-
|
|
672
|
-
|
|
673
|
-
|
|
674
|
-
|
|
675
|
-
|
|
676
|
-
|
|
677
|
-
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
|
|
682
|
-
|
|
683
|
-
|
|
684
|
-
|
|
685
|
-
|
|
686
|
-
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
|
|
690
|
-
|
|
691
|
-
|
|
692
|
-
|
|
693
|
-
|
|
694
|
-
|
|
695
|
-
|
|
696
|
-
|
|
697
|
-
|
|
698
|
-
|
|
699
|
-
|
|
700
|
-
|
|
701
|
-
|
|
702
|
-
|
|
703
|
-
|
|
704
|
-
|
|
705
|
-
|
|
706
|
-
|
|
707
|
-
|
|
708
|
-
|
|
709
|
-
|
|
710
|
-
|
|
711
|
-
|
|
712
|
-
|
|
713
|
-
|
|
714
|
-
|
|
715
|
-
|
|
716
|
-
|
|
717
|
-
|
|
718
|
-
|
|
719
|
-
|
|
720
|
-
|
|
721
|
-
|
|
722
|
-
|
|
723
|
-
|
|
724
|
-
|
|
725
|
-
|
|
726
|
-
|
|
727
|
-
|
|
728
|
-
|
|
729
|
-
|
|
730
|
-
|
|
731
|
-
|
|
732
|
-
|
|
733
|
-
|
|
734
|
-
|
|
735
|
-
|
|
736
|
-
|
|
737
|
-
|
|
738
|
-
|
|
739
|
-
|
|
740
|
-
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
|
|
744
|
-
|
|
745
|
-
|
|
746
|
-
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
|
|
750
|
-
|
|
751
|
-
|
|
752
|
-
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
|
|
759
|
-
|
|
760
|
-
|
|
761
|
-
|
|
762
|
-
|
|
763
|
-
|
|
764
|
-
|
|
765
|
-
|
|
766
|
-
|
|
767
|
-
|
|
768
|
-
|
|
769
|
-
|
|
770
|
-
|
|
771
|
-
|
|
772
|
-
|
|
773
|
-
|
|
774
|
-
|
|
775
|
-
|
|
776
|
-
|
|
777
|
-
|
|
778
|
-
|
|
779
|
-
|
|
780
|
-
|
|
781
|
-
|
|
782
|
-
|
|
783
|
-
|
|
784
|
-
|
|
785
|
-
|
|
786
|
-
|
|
787
|
-
|
|
788
|
-
|
|
789
|
-
|
|
790
|
-
|
|
791
|
-
|
|
792
|
-
|
|
793
|
-
|
|
794
|
-
|
|
795
|
-
|
|
796
|
-
|
|
797
|
-
|
|
798
|
-
|
|
799
|
-
|
|
800
|
-
|
|
801
|
-
|
|
802
|
-
|
|
803
|
-
|
|
804
|
-
|
|
805
|
-
|
|
806
|
-
|
|
807
|
-
|
|
808
|
-
|
|
809
|
-
|
|
810
|
-
|
|
811
|
-
|
|
812
|
-
|
|
813
|
-
|
|
814
|
-
|
|
815
|
-
|
|
816
|
-
|
|
817
|
-
|
|
818
|
-
|
|
819
|
-
|
|
820
|
-
|
|
821
|
-
|
|
822
|
-
|
|
823
|
-
|
|
824
|
-
|
|
825
|
-
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
|
|
830
|
-
|
|
831
|
-
|
|
832
|
-
|
|
833
|
-
|
|
834
|
-
|
|
835
|
-
|
|
836
|
-
|
|
837
|
-
|
|
838
|
-
|
|
839
|
-
|
|
840
|
-
|
|
841
|
-
|
|
842
|
-
|
|
843
|
-
|
|
844
|
-
|
|
845
|
-
|
|
846
|
-
|
|
847
|
-
|
|
848
|
-
|
|
849
|
-
|
|
850
|
-
|
|
851
|
-
|
|
852
|
-
|
|
853
|
-
|
|
854
|
-
|
|
855
|
-
|
|
856
|
-
|
|
857
|
-
|
|
858
|
-
|
|
859
|
-
|
|
860
|
-
|
|
861
|
-
|
|
862
|
-
|
|
863
|
-
|
|
864
|
-
|
|
865
|
-
|
|
866
|
-
|
|
867
|
-
|
|
868
|
-
|
|
869
|
-
|
|
870
|
-
|
|
871
|
-
|
|
872
|
-
|
|
873
|
-
|
|
874
|
-
|
|
875
|
-
|
|
876
|
-
|
|
877
|
-
|
|
878
|
-
|
|
879
|
-
|
|
880
|
-
|
|
881
|
-
|
|
882
|
-
|
|
883
|
-
|
|
884
|
-
|
|
885
|
-
|
|
886
|
-
|
|
887
|
-
|
|
888
|
-
|
|
889
|
-
|
|
890
|
-
|
|
891
|
-
|
|
892
|
-
|
|
893
|
-
|
|
894
|
-
|
|
895
|
-
|
|
896
|
-
|
|
897
|
-
|
|
898
|
-
|
|
899
|
-
|
|
900
|
-
|
|
901
|
-
|
|
902
|
-
|
|
903
|
-
|
|
904
|
-
|
|
905
|
-
|
|
906
|
-
|
|
907
|
-
|
|
908
|
-
|
|
909
|
-
|
|
910
|
-
|
|
911
|
-
|
|
912
|
-
|
|
913
|
-
|
|
914
|
-
|
|
915
|
-
|
|
916
|
-
|
|
917
|
-
|
|
918
|
-
|
|
919
|
-
|
|
920
|
-
|
|
921
|
-
|
|
922
|
-
|
|
923
|
-
|
|
924
|
-
|
|
925
|
-
|
|
926
|
-
|
|
927
|
-
|
|
928
|
-
|
|
929
|
-
|
|
930
|
-
|
|
931
|
-
|
|
932
|
-
|
|
933
|
-
|
|
934
|
-
|
|
935
|
-
|
|
936
|
-
|
|
937
|
-
|
|
938
|
-
|
|
939
|
-
|
|
940
|
-
|
|
941
|
-
|
|
942
|
-
|
|
943
|
-
|
|
944
|
-
|
|
945
|
-
|
|
946
|
-
|
|
947
|
-
|
|
948
|
-
|
|
949
|
-
|
|
950
|
-
|
|
951
|
-
|
|
952
|
-
|
|
953
|
-
|
|
954
|
-
|
|
955
|
-
|
|
956
|
-
|
|
957
|
-
|
|
958
|
-
|
|
959
|
-
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
|
|
963
|
-
|
|
964
|
-
|
|
965
|
-
|
|
966
|
-
|
|
967
|
-
|
|
968
|
-
|
|
969
|
-
|
|
970
|
-
|
|
971
|
-
|
|
972
|
-
|
|
973
|
-
|
|
974
|
-
|
|
975
|
-
|
|
976
|
-
|
|
977
|
-
|
|
978
|
-
|
|
979
|
-
|
|
980
|
-
|
|
981
|
-
|
|
982
|
-
|
|
983
|
-
|
|
984
|
-
|
|
985
|
-
|
|
986
|
-
|
|
987
|
-
|
|
988
|
-
|
|
989
|
-
|
|
990
|
-
|
|
991
|
-
|
|
992
|
-
|
|
993
|
-
|
|
994
|
-
|
|
995
|
-
|
|
996
|
-
|
|
997
|
-
|
|
998
|
-
|
|
999
|
-
|
|
1000
|
-
|
|
1001
|
-
|
|
1002
|
-
|
|
1003
|
-
|
|
1004
|
-
|
|
1005
|
-
|
|
1006
|
-
|
|
1007
|
-
|
|
1008
|
-
|
|
1009
|
-
|
|
1010
|
-
|
|
1011
|
-
|
|
1012
|
-
|
|
1013
|
-
|
|
1014
|
-
|
|
1015
|
-
|
|
1016
|
-
|
|
1017
|
-
|
|
1018
|
-
|
|
1019
|
-
|
|
1020
|
-
|
|
1021
|
-
|
|
1022
|
-
|
|
1023
|
-
|
|
1024
|
-
|
|
1025
|
-
|
|
1026
|
-
|
|
1027
|
-
|
|
1028
|
-
|
|
1029
|
-
|
|
1030
|
-
|
|
1031
|
-
|
|
1032
|
-
|
|
1033
|
-
|
|
1034
|
-
|
|
1035
|
-
|
|
1036
|
-
|
|
1037
|
-
|
|
1038
|
-
|
|
1039
|
-
|
|
1040
|
-
|
|
1041
|
-
|
|
1042
|
-
|
|
1043
|
-
return readToken(scnr, context);
|
|
1044
|
-
}
|
|
1045
|
-
if ((validNamedIdentifier = isNamedIdentifierStart(scnr, context))) {
|
|
1046
|
-
token = getToken(context, 4 /* TokenTypes.Named */, readNamedIdentifier(scnr));
|
|
1047
|
-
skipSpaces(scnr);
|
|
1048
|
-
return token;
|
|
1049
|
-
}
|
|
1050
|
-
if ((validListIdentifier = isListIdentifierStart(scnr, context))) {
|
|
1051
|
-
token = getToken(context, 5 /* TokenTypes.List */, readListIdentifier(scnr));
|
|
1052
|
-
skipSpaces(scnr);
|
|
1053
|
-
return token;
|
|
1054
|
-
}
|
|
1055
|
-
if ((validLiteral = isLiteralStart(scnr, context))) {
|
|
1056
|
-
token = getToken(context, 6 /* TokenTypes.Literal */, readLiteral(scnr));
|
|
1057
|
-
skipSpaces(scnr);
|
|
1058
|
-
return token;
|
|
1059
|
-
}
|
|
1060
|
-
if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {
|
|
1061
|
-
// TODO: we should be re-designed invalid cases, when we will extend message syntax near the future ...
|
|
1062
|
-
token = getToken(context, 12 /* TokenTypes.InvalidPlace */, readInvalidIdentifier(scnr));
|
|
1063
|
-
emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);
|
|
1064
|
-
skipSpaces(scnr);
|
|
1065
|
-
return token;
|
|
1066
|
-
}
|
|
1067
|
-
break;
|
|
1068
|
-
}
|
|
1069
|
-
}
|
|
1070
|
-
return token;
|
|
1071
|
-
}
|
|
1072
|
-
// TODO: We need refactoring of token parsing ...
|
|
1073
|
-
function readTokenInLinked(scnr, context) {
|
|
1074
|
-
const { currentType } = context;
|
|
1075
|
-
let token = null;
|
|
1076
|
-
const ch = scnr.currentChar();
|
|
1077
|
-
if ((currentType === 7 /* TokenTypes.LinkedAlias */ ||
|
|
1078
|
-
currentType === 8 /* TokenTypes.LinkedDot */ ||
|
|
1079
|
-
currentType === 11 /* TokenTypes.LinkedModifier */ ||
|
|
1080
|
-
currentType === 9 /* TokenTypes.LinkedDelimiter */) &&
|
|
1081
|
-
(ch === CHAR_LF || ch === CHAR_SP)) {
|
|
1082
|
-
emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
|
|
1083
|
-
}
|
|
1084
|
-
switch (ch) {
|
|
1085
|
-
case "@" /* TokenChars.LinkedAlias */:
|
|
1086
|
-
scnr.next();
|
|
1087
|
-
token = getToken(context, 7 /* TokenTypes.LinkedAlias */, "@" /* TokenChars.LinkedAlias */);
|
|
1088
|
-
context.inLinked = true;
|
|
1089
|
-
return token;
|
|
1090
|
-
case "." /* TokenChars.LinkedDot */:
|
|
1091
|
-
skipSpaces(scnr);
|
|
1092
|
-
scnr.next();
|
|
1093
|
-
return getToken(context, 8 /* TokenTypes.LinkedDot */, "." /* TokenChars.LinkedDot */);
|
|
1094
|
-
case ":" /* TokenChars.LinkedDelimiter */:
|
|
1095
|
-
skipSpaces(scnr);
|
|
1096
|
-
scnr.next();
|
|
1097
|
-
return getToken(context, 9 /* TokenTypes.LinkedDelimiter */, ":" /* TokenChars.LinkedDelimiter */);
|
|
1098
|
-
default:
|
|
1099
|
-
if (isPluralStart(scnr)) {
|
|
1100
|
-
token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
|
|
1101
|
-
// reset
|
|
1102
|
-
context.braceNest = 0;
|
|
1103
|
-
context.inLinked = false;
|
|
1104
|
-
return token;
|
|
1105
|
-
}
|
|
1106
|
-
if (isLinkedDotStart(scnr, context) ||
|
|
1107
|
-
isLinkedDelimiterStart(scnr, context)) {
|
|
1108
|
-
skipSpaces(scnr);
|
|
1109
|
-
return readTokenInLinked(scnr, context);
|
|
1110
|
-
}
|
|
1111
|
-
if (isLinkedModifierStart(scnr, context)) {
|
|
1112
|
-
skipSpaces(scnr);
|
|
1113
|
-
return getToken(context, 11 /* TokenTypes.LinkedModifier */, readLinkedModifier(scnr));
|
|
1114
|
-
}
|
|
1115
|
-
if (isLinkedReferStart(scnr, context)) {
|
|
1116
|
-
skipSpaces(scnr);
|
|
1117
|
-
if (ch === "{" /* TokenChars.BraceLeft */) {
|
|
1118
|
-
// scan the placeholder
|
|
1119
|
-
return readTokenInPlaceholder(scnr, context) || token;
|
|
1120
|
-
}
|
|
1121
|
-
else {
|
|
1122
|
-
return getToken(context, 10 /* TokenTypes.LinkedKey */, readLinkedRefer(scnr));
|
|
1123
|
-
}
|
|
1124
|
-
}
|
|
1125
|
-
if (currentType === 7 /* TokenTypes.LinkedAlias */) {
|
|
1126
|
-
emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
|
|
1127
|
-
}
|
|
1128
|
-
context.braceNest = 0;
|
|
1129
|
-
context.inLinked = false;
|
|
1130
|
-
return readToken(scnr, context);
|
|
1131
|
-
}
|
|
1132
|
-
}
|
|
1133
|
-
// TODO: We need refactoring of token parsing ...
|
|
1134
|
-
function readToken(scnr, context) {
|
|
1135
|
-
let token = { type: 13 /* TokenTypes.EOF */ };
|
|
1136
|
-
if (context.braceNest > 0) {
|
|
1137
|
-
return readTokenInPlaceholder(scnr, context) || getEndToken(context);
|
|
1138
|
-
}
|
|
1139
|
-
if (context.inLinked) {
|
|
1140
|
-
return readTokenInLinked(scnr, context) || getEndToken(context);
|
|
1141
|
-
}
|
|
1142
|
-
const ch = scnr.currentChar();
|
|
1143
|
-
switch (ch) {
|
|
1144
|
-
case "{" /* TokenChars.BraceLeft */:
|
|
1145
|
-
return readTokenInPlaceholder(scnr, context) || getEndToken(context);
|
|
1146
|
-
case "}" /* TokenChars.BraceRight */:
|
|
1147
|
-
emitError(CompileErrorCodes.UNBALANCED_CLOSING_BRACE, currentPosition(), 0);
|
|
1148
|
-
scnr.next();
|
|
1149
|
-
return getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
|
|
1150
|
-
case "@" /* TokenChars.LinkedAlias */:
|
|
1151
|
-
return readTokenInLinked(scnr, context) || getEndToken(context);
|
|
1152
|
-
default: {
|
|
1153
|
-
if (isPluralStart(scnr)) {
|
|
1154
|
-
token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
|
|
1155
|
-
// reset
|
|
1156
|
-
context.braceNest = 0;
|
|
1157
|
-
context.inLinked = false;
|
|
1158
|
-
return token;
|
|
1159
|
-
}
|
|
1160
|
-
if (isTextStart(scnr)) {
|
|
1161
|
-
return getToken(context, 0 /* TokenTypes.Text */, readText(scnr));
|
|
1162
|
-
}
|
|
1163
|
-
break;
|
|
1164
|
-
}
|
|
1165
|
-
}
|
|
1166
|
-
return token;
|
|
1167
|
-
}
|
|
1168
|
-
function nextToken() {
|
|
1169
|
-
const { currentType, offset, startLoc, endLoc } = _context;
|
|
1170
|
-
_context.lastType = currentType;
|
|
1171
|
-
_context.lastOffset = offset;
|
|
1172
|
-
_context.lastStartLoc = startLoc;
|
|
1173
|
-
_context.lastEndLoc = endLoc;
|
|
1174
|
-
_context.offset = currentOffset();
|
|
1175
|
-
_context.startLoc = currentPosition();
|
|
1176
|
-
if (_scnr.currentChar() === EOF) {
|
|
1177
|
-
return getToken(_context, 13 /* TokenTypes.EOF */);
|
|
1178
|
-
}
|
|
1179
|
-
return readToken(_scnr, _context);
|
|
1180
|
-
}
|
|
1181
|
-
return {
|
|
1182
|
-
nextToken,
|
|
1183
|
-
currentOffset,
|
|
1184
|
-
currentPosition,
|
|
1185
|
-
context
|
|
1186
|
-
};
|
|
505
|
+
const location = options.location !== false;
|
|
506
|
+
const _scnr = createScanner(source);
|
|
507
|
+
const currentOffset = () => _scnr.index();
|
|
508
|
+
const currentPosition = () => createPosition(_scnr.line(), _scnr.column(), _scnr.index());
|
|
509
|
+
const _initLoc = currentPosition();
|
|
510
|
+
const _initOffset = currentOffset();
|
|
511
|
+
const _context = {
|
|
512
|
+
currentType: 13,
|
|
513
|
+
offset: _initOffset,
|
|
514
|
+
startLoc: _initLoc,
|
|
515
|
+
endLoc: _initLoc,
|
|
516
|
+
lastType: 13,
|
|
517
|
+
lastOffset: _initOffset,
|
|
518
|
+
lastStartLoc: _initLoc,
|
|
519
|
+
lastEndLoc: _initLoc,
|
|
520
|
+
braceNest: 0,
|
|
521
|
+
inLinked: false,
|
|
522
|
+
text: ""
|
|
523
|
+
};
|
|
524
|
+
const context = () => _context;
|
|
525
|
+
const { onError } = options;
|
|
526
|
+
function emitError(code, pos, offset, ...args) {
|
|
527
|
+
const ctx = context();
|
|
528
|
+
pos.column += offset;
|
|
529
|
+
pos.offset += offset;
|
|
530
|
+
if (onError) onError(createCompileError(code, location ? createLocation(ctx.startLoc, pos) : null, {
|
|
531
|
+
domain: ERROR_DOMAIN$1,
|
|
532
|
+
args
|
|
533
|
+
}));
|
|
534
|
+
}
|
|
535
|
+
function getToken(context, type, value) {
|
|
536
|
+
context.endLoc = currentPosition();
|
|
537
|
+
context.currentType = type;
|
|
538
|
+
const token = { type };
|
|
539
|
+
if (location) token.loc = createLocation(context.startLoc, context.endLoc);
|
|
540
|
+
if (value != null) token.value = value;
|
|
541
|
+
return token;
|
|
542
|
+
}
|
|
543
|
+
const getEndToken = (context) => getToken(context, 13);
|
|
544
|
+
function eat(scnr, ch) {
|
|
545
|
+
if (scnr.currentChar() === ch) {
|
|
546
|
+
scnr.next();
|
|
547
|
+
return ch;
|
|
548
|
+
} else {
|
|
549
|
+
emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
|
|
550
|
+
return "";
|
|
551
|
+
}
|
|
552
|
+
}
|
|
553
|
+
function peekSpaces(scnr) {
|
|
554
|
+
let buf = "";
|
|
555
|
+
while (scnr.currentPeek() === " " || scnr.currentPeek() === "\n") {
|
|
556
|
+
buf += scnr.currentPeek();
|
|
557
|
+
scnr.peek();
|
|
558
|
+
}
|
|
559
|
+
return buf;
|
|
560
|
+
}
|
|
561
|
+
function skipSpaces(scnr) {
|
|
562
|
+
const buf = peekSpaces(scnr);
|
|
563
|
+
scnr.skipToPeek();
|
|
564
|
+
return buf;
|
|
565
|
+
}
|
|
566
|
+
function isIdentifierStart(ch) {
|
|
567
|
+
if (ch === EOF) return false;
|
|
568
|
+
const cc = ch.charCodeAt(0);
|
|
569
|
+
return cc >= 97 && cc <= 122 || cc >= 65 && cc <= 90 || cc === 95;
|
|
570
|
+
}
|
|
571
|
+
function isNumberStart(ch) {
|
|
572
|
+
if (ch === EOF) return false;
|
|
573
|
+
const cc = ch.charCodeAt(0);
|
|
574
|
+
return cc >= 48 && cc <= 57;
|
|
575
|
+
}
|
|
576
|
+
function isNamedIdentifierStart(scnr, context) {
|
|
577
|
+
const { currentType } = context;
|
|
578
|
+
if (currentType !== 2) return false;
|
|
579
|
+
peekSpaces(scnr);
|
|
580
|
+
const ret = isIdentifierStart(scnr.currentPeek());
|
|
581
|
+
scnr.resetPeek();
|
|
582
|
+
return ret;
|
|
583
|
+
}
|
|
584
|
+
function isListIdentifierStart(scnr, context) {
|
|
585
|
+
const { currentType } = context;
|
|
586
|
+
if (currentType !== 2) return false;
|
|
587
|
+
peekSpaces(scnr);
|
|
588
|
+
const ret = isNumberStart(scnr.currentPeek() === "-" ? scnr.peek() : scnr.currentPeek());
|
|
589
|
+
scnr.resetPeek();
|
|
590
|
+
return ret;
|
|
591
|
+
}
|
|
592
|
+
function isLiteralStart(scnr, context) {
|
|
593
|
+
const { currentType } = context;
|
|
594
|
+
if (currentType !== 2) return false;
|
|
595
|
+
peekSpaces(scnr);
|
|
596
|
+
const ret = scnr.currentPeek() === LITERAL_DELIMITER;
|
|
597
|
+
scnr.resetPeek();
|
|
598
|
+
return ret;
|
|
599
|
+
}
|
|
600
|
+
function isLinkedDotStart(scnr, context) {
|
|
601
|
+
const { currentType } = context;
|
|
602
|
+
if (currentType !== 7) return false;
|
|
603
|
+
peekSpaces(scnr);
|
|
604
|
+
const ret = scnr.currentPeek() === ".";
|
|
605
|
+
scnr.resetPeek();
|
|
606
|
+
return ret;
|
|
607
|
+
}
|
|
608
|
+
function isLinkedModifierStart(scnr, context) {
|
|
609
|
+
const { currentType } = context;
|
|
610
|
+
if (currentType !== 8) return false;
|
|
611
|
+
peekSpaces(scnr);
|
|
612
|
+
const ret = isIdentifierStart(scnr.currentPeek());
|
|
613
|
+
scnr.resetPeek();
|
|
614
|
+
return ret;
|
|
615
|
+
}
|
|
616
|
+
function isLinkedDelimiterStart(scnr, context) {
|
|
617
|
+
const { currentType } = context;
|
|
618
|
+
if (!(currentType === 7 || currentType === 11)) return false;
|
|
619
|
+
peekSpaces(scnr);
|
|
620
|
+
const ret = scnr.currentPeek() === ":";
|
|
621
|
+
scnr.resetPeek();
|
|
622
|
+
return ret;
|
|
623
|
+
}
|
|
624
|
+
function isLinkedReferStart(scnr, context) {
|
|
625
|
+
const { currentType } = context;
|
|
626
|
+
if (currentType !== 9) return false;
|
|
627
|
+
const fn = () => {
|
|
628
|
+
const ch = scnr.currentPeek();
|
|
629
|
+
if (ch === "{") return isIdentifierStart(scnr.peek());
|
|
630
|
+
else if (ch === "@" || ch === "|" || ch === ":" || ch === "." || ch === " " || !ch) return false;
|
|
631
|
+
else if (ch === "\n") {
|
|
632
|
+
scnr.peek();
|
|
633
|
+
return fn();
|
|
634
|
+
} else return isTextStart(scnr, false);
|
|
635
|
+
};
|
|
636
|
+
const ret = fn();
|
|
637
|
+
scnr.resetPeek();
|
|
638
|
+
return ret;
|
|
639
|
+
}
|
|
640
|
+
function isPluralStart(scnr) {
|
|
641
|
+
peekSpaces(scnr);
|
|
642
|
+
const ret = scnr.currentPeek() === "|";
|
|
643
|
+
scnr.resetPeek();
|
|
644
|
+
return ret;
|
|
645
|
+
}
|
|
646
|
+
function isTextStart(scnr, reset = true) {
|
|
647
|
+
const fn = (hasSpace = false, prev = "") => {
|
|
648
|
+
const ch = scnr.currentPeek();
|
|
649
|
+
if (ch === "{") return hasSpace;
|
|
650
|
+
else if (ch === "@" || !ch) return hasSpace;
|
|
651
|
+
else if (ch === "|") return !(prev === " " || prev === "\n");
|
|
652
|
+
else if (ch === " ") {
|
|
653
|
+
scnr.peek();
|
|
654
|
+
return fn(true, " ");
|
|
655
|
+
} else if (ch === "\n") {
|
|
656
|
+
scnr.peek();
|
|
657
|
+
return fn(true, "\n");
|
|
658
|
+
} else return true;
|
|
659
|
+
};
|
|
660
|
+
const ret = fn();
|
|
661
|
+
reset && scnr.resetPeek();
|
|
662
|
+
return ret;
|
|
663
|
+
}
|
|
664
|
+
function takeChar(scnr, fn) {
|
|
665
|
+
const ch = scnr.currentChar();
|
|
666
|
+
if (ch === EOF) return EOF;
|
|
667
|
+
if (fn(ch)) {
|
|
668
|
+
scnr.next();
|
|
669
|
+
return ch;
|
|
670
|
+
}
|
|
671
|
+
return null;
|
|
672
|
+
}
|
|
673
|
+
function isIdentifier(ch) {
|
|
674
|
+
const cc = ch.charCodeAt(0);
|
|
675
|
+
return cc >= 97 && cc <= 122 || cc >= 65 && cc <= 90 || cc >= 48 && cc <= 57 || cc === 95 || cc === 36;
|
|
676
|
+
}
|
|
677
|
+
function takeIdentifierChar(scnr) {
|
|
678
|
+
return takeChar(scnr, isIdentifier);
|
|
679
|
+
}
|
|
680
|
+
function isNamedIdentifier(ch) {
|
|
681
|
+
const cc = ch.charCodeAt(0);
|
|
682
|
+
return cc >= 97 && cc <= 122 || cc >= 65 && cc <= 90 || cc >= 48 && cc <= 57 || cc === 95 || cc === 36 || cc === 45;
|
|
683
|
+
}
|
|
684
|
+
function takeNamedIdentifierChar(scnr) {
|
|
685
|
+
return takeChar(scnr, isNamedIdentifier);
|
|
686
|
+
}
|
|
687
|
+
function isDigit(ch) {
|
|
688
|
+
const cc = ch.charCodeAt(0);
|
|
689
|
+
return cc >= 48 && cc <= 57;
|
|
690
|
+
}
|
|
691
|
+
function takeDigit(scnr) {
|
|
692
|
+
return takeChar(scnr, isDigit);
|
|
693
|
+
}
|
|
694
|
+
function isHexDigit(ch) {
|
|
695
|
+
const cc = ch.charCodeAt(0);
|
|
696
|
+
return cc >= 48 && cc <= 57 || cc >= 65 && cc <= 70 || cc >= 97 && cc <= 102;
|
|
697
|
+
}
|
|
698
|
+
function takeHexDigit(scnr) {
|
|
699
|
+
return takeChar(scnr, isHexDigit);
|
|
700
|
+
}
|
|
701
|
+
function getDigits(scnr) {
|
|
702
|
+
let ch = "";
|
|
703
|
+
let num = "";
|
|
704
|
+
while (ch = takeDigit(scnr)) num += ch;
|
|
705
|
+
return num;
|
|
706
|
+
}
|
|
707
|
+
function readText(scnr) {
|
|
708
|
+
let buf = "";
|
|
709
|
+
while (true) {
|
|
710
|
+
const ch = scnr.currentChar();
|
|
711
|
+
if (ch === "\\") {
|
|
712
|
+
const nextCh = scnr.peek();
|
|
713
|
+
if (nextCh === "{" || nextCh === "}" || nextCh === "@" || nextCh === "|" || nextCh === "\\") {
|
|
714
|
+
buf += ch + nextCh;
|
|
715
|
+
scnr.next();
|
|
716
|
+
scnr.next();
|
|
717
|
+
} else {
|
|
718
|
+
scnr.resetPeek();
|
|
719
|
+
buf += ch;
|
|
720
|
+
scnr.next();
|
|
721
|
+
}
|
|
722
|
+
} else if (ch === "{" || ch === "}" || ch === "@" || ch === "|" || !ch) break;
|
|
723
|
+
else if (ch === " " || ch === "\n") if (isTextStart(scnr)) {
|
|
724
|
+
buf += ch;
|
|
725
|
+
scnr.next();
|
|
726
|
+
} else if (isPluralStart(scnr)) break;
|
|
727
|
+
else {
|
|
728
|
+
buf += ch;
|
|
729
|
+
scnr.next();
|
|
730
|
+
}
|
|
731
|
+
else {
|
|
732
|
+
buf += ch;
|
|
733
|
+
scnr.next();
|
|
734
|
+
}
|
|
735
|
+
}
|
|
736
|
+
return buf;
|
|
737
|
+
}
|
|
738
|
+
function readNamedIdentifier(scnr) {
|
|
739
|
+
skipSpaces(scnr);
|
|
740
|
+
let ch = "";
|
|
741
|
+
let name = "";
|
|
742
|
+
while (ch = takeNamedIdentifierChar(scnr)) name += ch;
|
|
743
|
+
const currentChar = scnr.currentChar();
|
|
744
|
+
if (currentChar && currentChar !== "}" && currentChar !== EOF && currentChar !== " " && currentChar !== "\n" && currentChar !== " ") {
|
|
745
|
+
const invalidPart = readInvalidIdentifier(scnr);
|
|
746
|
+
emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, name + invalidPart);
|
|
747
|
+
return name + invalidPart;
|
|
748
|
+
}
|
|
749
|
+
if (scnr.currentChar() === EOF) emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
|
|
750
|
+
return name;
|
|
751
|
+
}
|
|
752
|
+
function readListIdentifier(scnr) {
|
|
753
|
+
skipSpaces(scnr);
|
|
754
|
+
let value = "";
|
|
755
|
+
if (scnr.currentChar() === "-") {
|
|
756
|
+
scnr.next();
|
|
757
|
+
value += `-${getDigits(scnr)}`;
|
|
758
|
+
} else value += getDigits(scnr);
|
|
759
|
+
if (scnr.currentChar() === EOF) emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
|
|
760
|
+
return value;
|
|
761
|
+
}
|
|
762
|
+
function isLiteral(ch) {
|
|
763
|
+
return ch !== LITERAL_DELIMITER && ch !== "\n";
|
|
764
|
+
}
|
|
765
|
+
function readLiteral(scnr) {
|
|
766
|
+
skipSpaces(scnr);
|
|
767
|
+
eat(scnr, `'`);
|
|
768
|
+
let ch = "";
|
|
769
|
+
let literal = "";
|
|
770
|
+
while (ch = takeChar(scnr, isLiteral)) if (ch === "\\") literal += readEscapeSequence(scnr);
|
|
771
|
+
else literal += ch;
|
|
772
|
+
const current = scnr.currentChar();
|
|
773
|
+
if (current === "\n" || current === EOF) {
|
|
774
|
+
emitError(CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER, currentPosition(), 0);
|
|
775
|
+
if (current === "\n") {
|
|
776
|
+
scnr.next();
|
|
777
|
+
eat(scnr, `'`);
|
|
778
|
+
}
|
|
779
|
+
return literal;
|
|
780
|
+
}
|
|
781
|
+
eat(scnr, `'`);
|
|
782
|
+
return literal;
|
|
783
|
+
}
|
|
784
|
+
function readEscapeSequence(scnr) {
|
|
785
|
+
const ch = scnr.currentChar();
|
|
786
|
+
switch (ch) {
|
|
787
|
+
case "\\":
|
|
788
|
+
case `'`:
|
|
789
|
+
scnr.next();
|
|
790
|
+
return `\\${ch}`;
|
|
791
|
+
case "u": return readUnicodeEscapeSequence(scnr, ch, 4);
|
|
792
|
+
case "U": return readUnicodeEscapeSequence(scnr, ch, 6);
|
|
793
|
+
default:
|
|
794
|
+
emitError(CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE, currentPosition(), 0, ch);
|
|
795
|
+
return "";
|
|
796
|
+
}
|
|
797
|
+
}
|
|
798
|
+
function readUnicodeEscapeSequence(scnr, unicode, digits) {
|
|
799
|
+
eat(scnr, unicode);
|
|
800
|
+
let sequence = "";
|
|
801
|
+
for (let i = 0; i < digits; i++) {
|
|
802
|
+
const ch = takeHexDigit(scnr);
|
|
803
|
+
if (!ch) {
|
|
804
|
+
emitError(CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE, currentPosition(), 0, `\\${unicode}${sequence}${scnr.currentChar()}`);
|
|
805
|
+
break;
|
|
806
|
+
}
|
|
807
|
+
sequence += ch;
|
|
808
|
+
}
|
|
809
|
+
return `\\${unicode}${sequence}`;
|
|
810
|
+
}
|
|
811
|
+
function isInvalidIdentifier(ch) {
|
|
812
|
+
return ch !== "{" && ch !== "}" && ch !== " " && ch !== "\n";
|
|
813
|
+
}
|
|
814
|
+
function readInvalidIdentifier(scnr) {
|
|
815
|
+
skipSpaces(scnr);
|
|
816
|
+
let ch = "";
|
|
817
|
+
let identifiers = "";
|
|
818
|
+
while (ch = takeChar(scnr, isInvalidIdentifier)) identifiers += ch;
|
|
819
|
+
return identifiers;
|
|
820
|
+
}
|
|
821
|
+
function readLinkedModifier(scnr) {
|
|
822
|
+
let ch = "";
|
|
823
|
+
let name = "";
|
|
824
|
+
while (ch = takeIdentifierChar(scnr)) name += ch;
|
|
825
|
+
return name;
|
|
826
|
+
}
|
|
827
|
+
function readLinkedRefer(scnr) {
|
|
828
|
+
const fn = (buf) => {
|
|
829
|
+
const ch = scnr.currentChar();
|
|
830
|
+
if (ch === "{" || ch === "@" || ch === "|" || ch === "(" || ch === ")" || !ch) return buf;
|
|
831
|
+
else if (ch === " ") return buf;
|
|
832
|
+
else if (ch === "\n" || ch === DOT) {
|
|
833
|
+
buf += ch;
|
|
834
|
+
scnr.next();
|
|
835
|
+
return fn(buf);
|
|
836
|
+
} else {
|
|
837
|
+
buf += ch;
|
|
838
|
+
scnr.next();
|
|
839
|
+
return fn(buf);
|
|
840
|
+
}
|
|
841
|
+
};
|
|
842
|
+
return fn("");
|
|
843
|
+
}
|
|
844
|
+
function readPlural(scnr) {
|
|
845
|
+
skipSpaces(scnr);
|
|
846
|
+
const plural = eat(scnr, "|");
|
|
847
|
+
skipSpaces(scnr);
|
|
848
|
+
return plural;
|
|
849
|
+
}
|
|
850
|
+
function readTokenInPlaceholder(scnr, context) {
|
|
851
|
+
let token = null;
|
|
852
|
+
switch (scnr.currentChar()) {
|
|
853
|
+
case "{":
|
|
854
|
+
if (context.braceNest >= 1) emitError(CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER, currentPosition(), 0);
|
|
855
|
+
scnr.next();
|
|
856
|
+
token = getToken(context, 2, "{");
|
|
857
|
+
skipSpaces(scnr);
|
|
858
|
+
context.braceNest++;
|
|
859
|
+
return token;
|
|
860
|
+
case "}":
|
|
861
|
+
if (context.braceNest > 0 && context.currentType === 2) emitError(CompileErrorCodes.EMPTY_PLACEHOLDER, currentPosition(), 0);
|
|
862
|
+
scnr.next();
|
|
863
|
+
token = getToken(context, 3, "}");
|
|
864
|
+
context.braceNest--;
|
|
865
|
+
context.braceNest > 0 && skipSpaces(scnr);
|
|
866
|
+
if (context.inLinked && context.braceNest === 0) context.inLinked = false;
|
|
867
|
+
return token;
|
|
868
|
+
case "@":
|
|
869
|
+
if (context.braceNest > 0) emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
|
|
870
|
+
token = readTokenInLinked(scnr, context) || getEndToken(context);
|
|
871
|
+
context.braceNest = 0;
|
|
872
|
+
return token;
|
|
873
|
+
default: {
|
|
874
|
+
let validNamedIdentifier = true;
|
|
875
|
+
let validListIdentifier = true;
|
|
876
|
+
let validLiteral = true;
|
|
877
|
+
if (isPluralStart(scnr)) {
|
|
878
|
+
if (context.braceNest > 0) emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
|
|
879
|
+
token = getToken(context, 1, readPlural(scnr));
|
|
880
|
+
context.braceNest = 0;
|
|
881
|
+
context.inLinked = false;
|
|
882
|
+
return token;
|
|
883
|
+
}
|
|
884
|
+
if (context.braceNest > 0 && (context.currentType === 4 || context.currentType === 5 || context.currentType === 6)) {
|
|
885
|
+
emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
|
|
886
|
+
context.braceNest = 0;
|
|
887
|
+
return readToken(scnr, context);
|
|
888
|
+
}
|
|
889
|
+
if (validNamedIdentifier = isNamedIdentifierStart(scnr, context)) {
|
|
890
|
+
token = getToken(context, 4, readNamedIdentifier(scnr));
|
|
891
|
+
skipSpaces(scnr);
|
|
892
|
+
return token;
|
|
893
|
+
}
|
|
894
|
+
if (validListIdentifier = isListIdentifierStart(scnr, context)) {
|
|
895
|
+
token = getToken(context, 5, readListIdentifier(scnr));
|
|
896
|
+
skipSpaces(scnr);
|
|
897
|
+
return token;
|
|
898
|
+
}
|
|
899
|
+
if (validLiteral = isLiteralStart(scnr, context)) {
|
|
900
|
+
token = getToken(context, 6, readLiteral(scnr));
|
|
901
|
+
skipSpaces(scnr);
|
|
902
|
+
return token;
|
|
903
|
+
}
|
|
904
|
+
if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {
|
|
905
|
+
token = getToken(context, 12, readInvalidIdentifier(scnr));
|
|
906
|
+
emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);
|
|
907
|
+
skipSpaces(scnr);
|
|
908
|
+
return token;
|
|
909
|
+
}
|
|
910
|
+
break;
|
|
911
|
+
}
|
|
912
|
+
}
|
|
913
|
+
return token;
|
|
914
|
+
}
|
|
915
|
+
function readTokenInLinked(scnr, context) {
|
|
916
|
+
const { currentType } = context;
|
|
917
|
+
let token = null;
|
|
918
|
+
const ch = scnr.currentChar();
|
|
919
|
+
if ((currentType === 7 || currentType === 8 || currentType === 11 || currentType === 9) && (ch === "\n" || ch === " ")) emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
|
|
920
|
+
switch (ch) {
|
|
921
|
+
case "@":
|
|
922
|
+
scnr.next();
|
|
923
|
+
token = getToken(context, 7, "@");
|
|
924
|
+
context.inLinked = true;
|
|
925
|
+
return token;
|
|
926
|
+
case ".":
|
|
927
|
+
skipSpaces(scnr);
|
|
928
|
+
scnr.next();
|
|
929
|
+
return getToken(context, 8, ".");
|
|
930
|
+
case ":":
|
|
931
|
+
skipSpaces(scnr);
|
|
932
|
+
scnr.next();
|
|
933
|
+
return getToken(context, 9, ":");
|
|
934
|
+
default:
|
|
935
|
+
if (isPluralStart(scnr)) {
|
|
936
|
+
token = getToken(context, 1, readPlural(scnr));
|
|
937
|
+
context.braceNest = 0;
|
|
938
|
+
context.inLinked = false;
|
|
939
|
+
return token;
|
|
940
|
+
}
|
|
941
|
+
if (isLinkedDotStart(scnr, context) || isLinkedDelimiterStart(scnr, context)) {
|
|
942
|
+
skipSpaces(scnr);
|
|
943
|
+
return readTokenInLinked(scnr, context);
|
|
944
|
+
}
|
|
945
|
+
if (isLinkedModifierStart(scnr, context)) {
|
|
946
|
+
skipSpaces(scnr);
|
|
947
|
+
return getToken(context, 11, readLinkedModifier(scnr));
|
|
948
|
+
}
|
|
949
|
+
if (isLinkedReferStart(scnr, context)) {
|
|
950
|
+
skipSpaces(scnr);
|
|
951
|
+
if (ch === "{") return readTokenInPlaceholder(scnr, context) || token;
|
|
952
|
+
else return getToken(context, 10, readLinkedRefer(scnr));
|
|
953
|
+
}
|
|
954
|
+
if (currentType === 7) emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
|
|
955
|
+
context.braceNest = 0;
|
|
956
|
+
context.inLinked = false;
|
|
957
|
+
return readToken(scnr, context);
|
|
958
|
+
}
|
|
959
|
+
}
|
|
960
|
+
function readToken(scnr, context) {
|
|
961
|
+
let token = { type: 13 };
|
|
962
|
+
if (context.braceNest > 0) return readTokenInPlaceholder(scnr, context) || getEndToken(context);
|
|
963
|
+
if (context.inLinked) return readTokenInLinked(scnr, context) || getEndToken(context);
|
|
964
|
+
switch (scnr.currentChar()) {
|
|
965
|
+
case "{": return readTokenInPlaceholder(scnr, context) || getEndToken(context);
|
|
966
|
+
case "}":
|
|
967
|
+
emitError(CompileErrorCodes.UNBALANCED_CLOSING_BRACE, currentPosition(), 0);
|
|
968
|
+
scnr.next();
|
|
969
|
+
return getToken(context, 3, "}");
|
|
970
|
+
case "@": return readTokenInLinked(scnr, context) || getEndToken(context);
|
|
971
|
+
default:
|
|
972
|
+
if (isPluralStart(scnr)) {
|
|
973
|
+
token = getToken(context, 1, readPlural(scnr));
|
|
974
|
+
context.braceNest = 0;
|
|
975
|
+
context.inLinked = false;
|
|
976
|
+
return token;
|
|
977
|
+
}
|
|
978
|
+
if (isTextStart(scnr)) return getToken(context, 0, readText(scnr));
|
|
979
|
+
break;
|
|
980
|
+
}
|
|
981
|
+
return token;
|
|
982
|
+
}
|
|
983
|
+
function nextToken() {
|
|
984
|
+
const { currentType, offset, startLoc, endLoc } = _context;
|
|
985
|
+
_context.lastType = currentType;
|
|
986
|
+
_context.lastOffset = offset;
|
|
987
|
+
_context.lastStartLoc = startLoc;
|
|
988
|
+
_context.lastEndLoc = endLoc;
|
|
989
|
+
_context.offset = currentOffset();
|
|
990
|
+
_context.startLoc = currentPosition();
|
|
991
|
+
if (_scnr.currentChar() === EOF) return getToken(_context, 13);
|
|
992
|
+
return readToken(_scnr, _context);
|
|
993
|
+
}
|
|
994
|
+
return {
|
|
995
|
+
nextToken,
|
|
996
|
+
currentOffset,
|
|
997
|
+
currentPosition,
|
|
998
|
+
context
|
|
999
|
+
};
|
|
1000
|
+
}
|
|
1001
|
+
//#endregion
|
|
1002
|
+
//#region packages/message-compiler/src/parser.ts
|
|
1003
|
+
const ERROR_DOMAIN = "parser";
|
|
1004
|
+
const KNOWN_ESCAPES = /\\\\|\\'|\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{6})/g;
|
|
1005
|
+
const TEXT_ESCAPES = /\\([\\@{}|])/g;
|
|
1006
|
+
function fromTextEscapeSequence(_match, char) {
|
|
1007
|
+
return char;
|
|
1187
1008
|
}
|
|
1188
|
-
|
|
1189
|
-
const ERROR_DOMAIN = 'parser';
|
|
1190
|
-
// Backslash backslash, backslash quote, uHHHH, UHHHHHH.
|
|
1191
|
-
const KNOWN_ESCAPES = /(?:\\\\|\\'|\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{6}))/g;
|
|
1192
1009
|
function fromEscapeSequence(match, codePoint4, codePoint6) {
|
|
1193
|
-
|
|
1194
|
-
|
|
1195
|
-
|
|
1196
|
-
|
|
1197
|
-
|
|
1198
|
-
|
|
1199
|
-
|
|
1200
|
-
|
|
1201
|
-
|
|
1202
|
-
if (codePoint <= 0xd7ff || codePoint >= 0xe000) {
|
|
1203
|
-
return String.fromCodePoint(codePoint);
|
|
1204
|
-
}
|
|
1205
|
-
// invalid ...
|
|
1206
|
-
// Replace them with U+FFFD REPLACEMENT CHARACTER.
|
|
1207
|
-
return '�';
|
|
1208
|
-
}
|
|
1209
|
-
}
|
|
1010
|
+
switch (match) {
|
|
1011
|
+
case `\\\\`: return `\\`;
|
|
1012
|
+
case `\\'`: return `'`;
|
|
1013
|
+
default: {
|
|
1014
|
+
const codePoint = parseInt(codePoint4 || codePoint6, 16);
|
|
1015
|
+
if (codePoint <= 55295 || codePoint >= 57344) return String.fromCodePoint(codePoint);
|
|
1016
|
+
return "�";
|
|
1017
|
+
}
|
|
1018
|
+
}
|
|
1210
1019
|
}
|
|
1211
1020
|
function createParser(options = {}) {
|
|
1212
|
-
|
|
1213
|
-
|
|
1214
|
-
|
|
1215
|
-
|
|
1216
|
-
|
|
1217
|
-
|
|
1218
|
-
|
|
1219
|
-
|
|
1220
|
-
|
|
1221
|
-
|
|
1222
|
-
|
|
1223
|
-
|
|
1224
|
-
|
|
1225
|
-
|
|
1226
|
-
|
|
1227
|
-
|
|
1228
|
-
|
|
1229
|
-
|
|
1230
|
-
|
|
1231
|
-
|
|
1232
|
-
|
|
1233
|
-
|
|
1234
|
-
|
|
1235
|
-
|
|
1236
|
-
|
|
1237
|
-
|
|
1238
|
-
|
|
1239
|
-
|
|
1240
|
-
|
|
1241
|
-
|
|
1242
|
-
|
|
1243
|
-
|
|
1244
|
-
|
|
1245
|
-
|
|
1246
|
-
|
|
1247
|
-
|
|
1248
|
-
|
|
1249
|
-
|
|
1250
|
-
|
|
1251
|
-
|
|
1252
|
-
|
|
1253
|
-
|
|
1254
|
-
|
|
1255
|
-
|
|
1256
|
-
|
|
1257
|
-
|
|
1258
|
-
|
|
1259
|
-
|
|
1260
|
-
|
|
1261
|
-
|
|
1262
|
-
|
|
1263
|
-
|
|
1264
|
-
|
|
1265
|
-
|
|
1266
|
-
|
|
1267
|
-
|
|
1268
|
-
|
|
1269
|
-
|
|
1270
|
-
|
|
1271
|
-
|
|
1272
|
-
|
|
1273
|
-
|
|
1274
|
-
|
|
1275
|
-
|
|
1276
|
-
|
|
1277
|
-
|
|
1278
|
-
|
|
1279
|
-
|
|
1280
|
-
|
|
1281
|
-
|
|
1282
|
-
|
|
1283
|
-
|
|
1284
|
-
|
|
1285
|
-
|
|
1286
|
-
|
|
1287
|
-
|
|
1288
|
-
|
|
1289
|
-
|
|
1290
|
-
|
|
1291
|
-
|
|
1292
|
-
|
|
1293
|
-
|
|
1294
|
-
|
|
1295
|
-
|
|
1296
|
-
|
|
1297
|
-
|
|
1298
|
-
|
|
1299
|
-
|
|
1300
|
-
|
|
1301
|
-
|
|
1302
|
-
|
|
1303
|
-
|
|
1304
|
-
|
|
1305
|
-
|
|
1306
|
-
|
|
1307
|
-
|
|
1308
|
-
|
|
1309
|
-
|
|
1310
|
-
|
|
1311
|
-
|
|
1312
|
-
|
|
1313
|
-
|
|
1314
|
-
|
|
1315
|
-
|
|
1316
|
-
|
|
1317
|
-
|
|
1318
|
-
|
|
1319
|
-
|
|
1320
|
-
|
|
1321
|
-
|
|
1322
|
-
|
|
1323
|
-
|
|
1324
|
-
|
|
1325
|
-
|
|
1326
|
-
|
|
1327
|
-
|
|
1328
|
-
|
|
1329
|
-
|
|
1330
|
-
|
|
1331
|
-
|
|
1332
|
-
|
|
1333
|
-
|
|
1334
|
-
|
|
1335
|
-
|
|
1336
|
-
|
|
1337
|
-
|
|
1338
|
-
|
|
1339
|
-
|
|
1340
|
-
|
|
1341
|
-
|
|
1342
|
-
|
|
1343
|
-
|
|
1344
|
-
|
|
1345
|
-
|
|
1346
|
-
|
|
1347
|
-
|
|
1348
|
-
|
|
1349
|
-
|
|
1350
|
-
|
|
1351
|
-
|
|
1352
|
-
|
|
1353
|
-
|
|
1354
|
-
|
|
1355
|
-
|
|
1356
|
-
|
|
1357
|
-
|
|
1358
|
-
|
|
1359
|
-
|
|
1360
|
-
|
|
1361
|
-
|
|
1362
|
-
|
|
1363
|
-
|
|
1364
|
-
|
|
1365
|
-
|
|
1366
|
-
|
|
1367
|
-
|
|
1368
|
-
|
|
1369
|
-
|
|
1370
|
-
|
|
1371
|
-
|
|
1372
|
-
|
|
1373
|
-
|
|
1374
|
-
|
|
1375
|
-
|
|
1376
|
-
|
|
1377
|
-
|
|
1378
|
-
|
|
1379
|
-
|
|
1380
|
-
|
|
1381
|
-
|
|
1382
|
-
|
|
1383
|
-
|
|
1384
|
-
|
|
1385
|
-
|
|
1386
|
-
|
|
1387
|
-
|
|
1388
|
-
|
|
1389
|
-
|
|
1390
|
-
|
|
1391
|
-
|
|
1392
|
-
|
|
1393
|
-
|
|
1394
|
-
|
|
1395
|
-
|
|
1396
|
-
|
|
1397
|
-
|
|
1398
|
-
|
|
1399
|
-
|
|
1400
|
-
|
|
1401
|
-
|
|
1402
|
-
|
|
1403
|
-
|
|
1404
|
-
|
|
1405
|
-
|
|
1406
|
-
|
|
1407
|
-
|
|
1408
|
-
|
|
1409
|
-
|
|
1410
|
-
|
|
1411
|
-
|
|
1412
|
-
|
|
1413
|
-
|
|
1414
|
-
|
|
1415
|
-
nextToken = parsed.nextConsumeToken || null;
|
|
1416
|
-
break;
|
|
1417
|
-
}
|
|
1418
|
-
}
|
|
1419
|
-
} while (context.currentType !== 13 /* TokenTypes.EOF */ &&
|
|
1420
|
-
context.currentType !== 1 /* TokenTypes.Pipe */);
|
|
1421
|
-
// adjust message node loc
|
|
1422
|
-
const endOffset = context.currentType === 1 /* TokenTypes.Pipe */
|
|
1423
|
-
? context.lastOffset
|
|
1424
|
-
: tokenizer.currentOffset();
|
|
1425
|
-
const endLoc = context.currentType === 1 /* TokenTypes.Pipe */
|
|
1426
|
-
? context.lastEndLoc
|
|
1427
|
-
: tokenizer.currentPosition();
|
|
1428
|
-
endNode(node, endOffset, endLoc);
|
|
1429
|
-
return node;
|
|
1430
|
-
}
|
|
1431
|
-
function parsePlural(tokenizer, offset, loc, msgNode) {
|
|
1432
|
-
const context = tokenizer.context();
|
|
1433
|
-
let hasEmptyMessage = msgNode.items.length === 0;
|
|
1434
|
-
const node = startNode(1 /* NodeTypes.Plural */, offset, loc);
|
|
1435
|
-
node.cases = [];
|
|
1436
|
-
node.cases.push(msgNode);
|
|
1437
|
-
do {
|
|
1438
|
-
const msg = parseMessage(tokenizer);
|
|
1439
|
-
if (!hasEmptyMessage) {
|
|
1440
|
-
hasEmptyMessage = msg.items.length === 0;
|
|
1441
|
-
}
|
|
1442
|
-
node.cases.push(msg);
|
|
1443
|
-
} while (context.currentType !== 13 /* TokenTypes.EOF */);
|
|
1444
|
-
if (hasEmptyMessage) {
|
|
1445
|
-
emitError(tokenizer, CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL, loc, 0);
|
|
1446
|
-
}
|
|
1447
|
-
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
1448
|
-
return node;
|
|
1449
|
-
}
|
|
1450
|
-
function parseResource(tokenizer) {
|
|
1451
|
-
const context = tokenizer.context();
|
|
1452
|
-
const { offset, startLoc } = context;
|
|
1453
|
-
const msgNode = parseMessage(tokenizer);
|
|
1454
|
-
if (context.currentType === 13 /* TokenTypes.EOF */) {
|
|
1455
|
-
return msgNode;
|
|
1456
|
-
}
|
|
1457
|
-
else {
|
|
1458
|
-
return parsePlural(tokenizer, offset, startLoc, msgNode);
|
|
1459
|
-
}
|
|
1460
|
-
}
|
|
1461
|
-
function parse(source) {
|
|
1462
|
-
const tokenizer = createTokenizer(source, assign({}, options));
|
|
1463
|
-
const context = tokenizer.context();
|
|
1464
|
-
const node = startNode(0 /* NodeTypes.Resource */, context.offset, context.startLoc);
|
|
1465
|
-
if (location && node.loc) {
|
|
1466
|
-
node.loc.source = source;
|
|
1467
|
-
}
|
|
1468
|
-
node.body = parseResource(tokenizer);
|
|
1469
|
-
if (options.onCacheKey) {
|
|
1470
|
-
node.cacheKey = options.onCacheKey(source);
|
|
1471
|
-
}
|
|
1472
|
-
// assert whether achieved to EOF
|
|
1473
|
-
if (context.currentType !== 13 /* TokenTypes.EOF */) {
|
|
1474
|
-
emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || '');
|
|
1475
|
-
}
|
|
1476
|
-
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
1477
|
-
return node;
|
|
1478
|
-
}
|
|
1479
|
-
return { parse };
|
|
1021
|
+
const location = options.location !== false;
|
|
1022
|
+
const { onError } = options;
|
|
1023
|
+
function emitError(tokenzer, code, start, offset, ...args) {
|
|
1024
|
+
const end = tokenzer.currentPosition();
|
|
1025
|
+
end.offset += offset;
|
|
1026
|
+
end.column += offset;
|
|
1027
|
+
if (onError) onError(createCompileError(code, location ? createLocation(start, end) : null, {
|
|
1028
|
+
domain: ERROR_DOMAIN,
|
|
1029
|
+
args
|
|
1030
|
+
}));
|
|
1031
|
+
}
|
|
1032
|
+
function startNode(type, offset, loc) {
|
|
1033
|
+
const node = { type };
|
|
1034
|
+
if (location) {
|
|
1035
|
+
node.start = offset;
|
|
1036
|
+
node.end = offset;
|
|
1037
|
+
node.loc = {
|
|
1038
|
+
start: loc,
|
|
1039
|
+
end: loc
|
|
1040
|
+
};
|
|
1041
|
+
}
|
|
1042
|
+
return node;
|
|
1043
|
+
}
|
|
1044
|
+
function endNode(node, offset, pos, type) {
|
|
1045
|
+
if (type) node.type = type;
|
|
1046
|
+
if (location) {
|
|
1047
|
+
node.end = offset;
|
|
1048
|
+
if (node.loc) node.loc.end = pos;
|
|
1049
|
+
}
|
|
1050
|
+
}
|
|
1051
|
+
function parseText(tokenizer, value) {
|
|
1052
|
+
const context = tokenizer.context();
|
|
1053
|
+
const node = startNode(3, context.offset, context.startLoc);
|
|
1054
|
+
node.value = value.replace(TEXT_ESCAPES, fromTextEscapeSequence);
|
|
1055
|
+
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
1056
|
+
return node;
|
|
1057
|
+
}
|
|
1058
|
+
function parseList(tokenizer, index) {
|
|
1059
|
+
const { lastOffset: offset, lastStartLoc: loc } = tokenizer.context();
|
|
1060
|
+
const node = startNode(5, offset, loc);
|
|
1061
|
+
node.index = parseInt(index, 10);
|
|
1062
|
+
tokenizer.nextToken();
|
|
1063
|
+
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
1064
|
+
return node;
|
|
1065
|
+
}
|
|
1066
|
+
function parseNamed(tokenizer, key) {
|
|
1067
|
+
const { lastOffset: offset, lastStartLoc: loc } = tokenizer.context();
|
|
1068
|
+
const node = startNode(4, offset, loc);
|
|
1069
|
+
node.key = key;
|
|
1070
|
+
tokenizer.nextToken();
|
|
1071
|
+
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
1072
|
+
return node;
|
|
1073
|
+
}
|
|
1074
|
+
function parseLiteral(tokenizer, value) {
|
|
1075
|
+
const { lastOffset: offset, lastStartLoc: loc } = tokenizer.context();
|
|
1076
|
+
const node = startNode(9, offset, loc);
|
|
1077
|
+
node.value = value.replace(KNOWN_ESCAPES, fromEscapeSequence);
|
|
1078
|
+
tokenizer.nextToken();
|
|
1079
|
+
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
1080
|
+
return node;
|
|
1081
|
+
}
|
|
1082
|
+
function parseLinkedModifier(tokenizer) {
|
|
1083
|
+
const token = tokenizer.nextToken();
|
|
1084
|
+
const context = tokenizer.context();
|
|
1085
|
+
const { lastOffset: offset, lastStartLoc: loc } = context;
|
|
1086
|
+
const node = startNode(8, offset, loc);
|
|
1087
|
+
if (token.type !== 11) {
|
|
1088
|
+
emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER, context.lastStartLoc, 0);
|
|
1089
|
+
node.value = "";
|
|
1090
|
+
endNode(node, offset, loc);
|
|
1091
|
+
return {
|
|
1092
|
+
nextConsumeToken: token,
|
|
1093
|
+
node
|
|
1094
|
+
};
|
|
1095
|
+
}
|
|
1096
|
+
if (token.value == null) emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
|
|
1097
|
+
node.value = token.value || "";
|
|
1098
|
+
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
1099
|
+
return { node };
|
|
1100
|
+
}
|
|
1101
|
+
function parseLinkedKey(tokenizer, value) {
|
|
1102
|
+
const context = tokenizer.context();
|
|
1103
|
+
const node = startNode(7, context.offset, context.startLoc);
|
|
1104
|
+
node.value = value;
|
|
1105
|
+
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
1106
|
+
return node;
|
|
1107
|
+
}
|
|
1108
|
+
function parseLinked(tokenizer) {
|
|
1109
|
+
const context = tokenizer.context();
|
|
1110
|
+
const linkedNode = startNode(6, context.offset, context.startLoc);
|
|
1111
|
+
let token = tokenizer.nextToken();
|
|
1112
|
+
if (token.type === 8) {
|
|
1113
|
+
const parsed = parseLinkedModifier(tokenizer);
|
|
1114
|
+
linkedNode.modifier = parsed.node;
|
|
1115
|
+
token = parsed.nextConsumeToken || tokenizer.nextToken();
|
|
1116
|
+
}
|
|
1117
|
+
if (token.type !== 9) emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
|
|
1118
|
+
token = tokenizer.nextToken();
|
|
1119
|
+
if (token.type === 2) token = tokenizer.nextToken();
|
|
1120
|
+
switch (token.type) {
|
|
1121
|
+
case 10:
|
|
1122
|
+
if (token.value == null) emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
|
|
1123
|
+
linkedNode.key = parseLinkedKey(tokenizer, token.value || "");
|
|
1124
|
+
break;
|
|
1125
|
+
case 4:
|
|
1126
|
+
if (token.value == null) emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
|
|
1127
|
+
linkedNode.key = parseNamed(tokenizer, token.value || "");
|
|
1128
|
+
break;
|
|
1129
|
+
case 5:
|
|
1130
|
+
if (token.value == null) emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
|
|
1131
|
+
linkedNode.key = parseList(tokenizer, token.value || "");
|
|
1132
|
+
break;
|
|
1133
|
+
case 6:
|
|
1134
|
+
if (token.value == null) emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
|
|
1135
|
+
linkedNode.key = parseLiteral(tokenizer, token.value || "");
|
|
1136
|
+
break;
|
|
1137
|
+
default: {
|
|
1138
|
+
emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY, context.lastStartLoc, 0);
|
|
1139
|
+
const nextContext = tokenizer.context();
|
|
1140
|
+
const emptyLinkedKeyNode = startNode(7, nextContext.offset, nextContext.startLoc);
|
|
1141
|
+
emptyLinkedKeyNode.value = "";
|
|
1142
|
+
endNode(emptyLinkedKeyNode, nextContext.offset, nextContext.startLoc);
|
|
1143
|
+
linkedNode.key = emptyLinkedKeyNode;
|
|
1144
|
+
endNode(linkedNode, nextContext.offset, nextContext.startLoc);
|
|
1145
|
+
return {
|
|
1146
|
+
nextConsumeToken: token,
|
|
1147
|
+
node: linkedNode
|
|
1148
|
+
};
|
|
1149
|
+
}
|
|
1150
|
+
}
|
|
1151
|
+
endNode(linkedNode, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
1152
|
+
return { node: linkedNode };
|
|
1153
|
+
}
|
|
1154
|
+
function parseMessage(tokenizer) {
|
|
1155
|
+
const context = tokenizer.context();
|
|
1156
|
+
const node = startNode(2, context.currentType === 1 ? tokenizer.currentOffset() : context.offset, context.currentType === 1 ? context.endLoc : context.startLoc);
|
|
1157
|
+
node.items = [];
|
|
1158
|
+
let nextToken = null;
|
|
1159
|
+
do {
|
|
1160
|
+
const token = nextToken || tokenizer.nextToken();
|
|
1161
|
+
nextToken = null;
|
|
1162
|
+
switch (token.type) {
|
|
1163
|
+
case 0:
|
|
1164
|
+
if (token.value == null) emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
|
|
1165
|
+
node.items.push(parseText(tokenizer, token.value || ""));
|
|
1166
|
+
break;
|
|
1167
|
+
case 5:
|
|
1168
|
+
if (token.value == null) emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
|
|
1169
|
+
node.items.push(parseList(tokenizer, token.value || ""));
|
|
1170
|
+
break;
|
|
1171
|
+
case 4:
|
|
1172
|
+
if (token.value == null) emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
|
|
1173
|
+
node.items.push(parseNamed(tokenizer, token.value || ""));
|
|
1174
|
+
break;
|
|
1175
|
+
case 6:
|
|
1176
|
+
if (token.value == null) emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
|
|
1177
|
+
node.items.push(parseLiteral(tokenizer, token.value || ""));
|
|
1178
|
+
break;
|
|
1179
|
+
case 7: {
|
|
1180
|
+
const parsed = parseLinked(tokenizer);
|
|
1181
|
+
node.items.push(parsed.node);
|
|
1182
|
+
nextToken = parsed.nextConsumeToken || null;
|
|
1183
|
+
break;
|
|
1184
|
+
}
|
|
1185
|
+
}
|
|
1186
|
+
} while (context.currentType !== 13 && context.currentType !== 1);
|
|
1187
|
+
endNode(node, context.currentType === 1 ? context.lastOffset : tokenizer.currentOffset(), context.currentType === 1 ? context.lastEndLoc : tokenizer.currentPosition());
|
|
1188
|
+
return node;
|
|
1189
|
+
}
|
|
1190
|
+
function parsePlural(tokenizer, offset, loc, msgNode) {
|
|
1191
|
+
const context = tokenizer.context();
|
|
1192
|
+
let hasEmptyMessage = msgNode.items.length === 0;
|
|
1193
|
+
const node = startNode(1, offset, loc);
|
|
1194
|
+
node.cases = [];
|
|
1195
|
+
node.cases.push(msgNode);
|
|
1196
|
+
do {
|
|
1197
|
+
const msg = parseMessage(tokenizer);
|
|
1198
|
+
if (!hasEmptyMessage) hasEmptyMessage = msg.items.length === 0;
|
|
1199
|
+
node.cases.push(msg);
|
|
1200
|
+
} while (context.currentType !== 13);
|
|
1201
|
+
if (hasEmptyMessage) emitError(tokenizer, CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL, loc, 0);
|
|
1202
|
+
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
1203
|
+
return node;
|
|
1204
|
+
}
|
|
1205
|
+
function parseResource(tokenizer) {
|
|
1206
|
+
const context = tokenizer.context();
|
|
1207
|
+
const { offset, startLoc } = context;
|
|
1208
|
+
const msgNode = parseMessage(tokenizer);
|
|
1209
|
+
if (context.currentType === 13) return msgNode;
|
|
1210
|
+
else return parsePlural(tokenizer, offset, startLoc, msgNode);
|
|
1211
|
+
}
|
|
1212
|
+
function parse(source) {
|
|
1213
|
+
const tokenizer = createTokenizer(source, assign({}, options));
|
|
1214
|
+
const context = tokenizer.context();
|
|
1215
|
+
const node = startNode(0, context.offset, context.startLoc);
|
|
1216
|
+
if (location && node.loc) node.loc.source = source;
|
|
1217
|
+
node.body = parseResource(tokenizer);
|
|
1218
|
+
if (options.onCacheKey) node.cacheKey = options.onCacheKey(source);
|
|
1219
|
+
if (context.currentType !== 13) emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || "");
|
|
1220
|
+
endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
|
|
1221
|
+
return node;
|
|
1222
|
+
}
|
|
1223
|
+
return { parse };
|
|
1480
1224
|
}
|
|
1481
1225
|
function getTokenCaption(token) {
|
|
1482
|
-
|
|
1483
|
-
|
|
1484
|
-
|
|
1485
|
-
const name = (token.value || '').replace(/\r?\n/gu, '\\n');
|
|
1486
|
-
return name.length > 10 ? name.slice(0, 9) + '…' : name;
|
|
1226
|
+
if (token.type === 13) return "EOF";
|
|
1227
|
+
const name = (token.value || "").replace(/\r?\n/gu, "\\n");
|
|
1228
|
+
return name.length > 10 ? name.slice(0, 9) + "…" : name;
|
|
1487
1229
|
}
|
|
1488
|
-
|
|
1489
|
-
|
|
1490
|
-
) {
|
|
1491
|
-
|
|
1492
|
-
|
|
1493
|
-
|
|
1494
|
-
|
|
1495
|
-
|
|
1496
|
-
|
|
1497
|
-
|
|
1498
|
-
|
|
1499
|
-
|
|
1500
|
-
|
|
1230
|
+
//#endregion
|
|
1231
|
+
//#region packages/message-compiler/src/transformer.ts
|
|
1232
|
+
function createTransformer(ast, _options = {}) {
|
|
1233
|
+
const _context = {
|
|
1234
|
+
ast,
|
|
1235
|
+
helpers: /* @__PURE__ */ new Set()
|
|
1236
|
+
};
|
|
1237
|
+
const context = () => _context;
|
|
1238
|
+
const helper = (name) => {
|
|
1239
|
+
_context.helpers.add(name);
|
|
1240
|
+
return name;
|
|
1241
|
+
};
|
|
1242
|
+
return {
|
|
1243
|
+
context,
|
|
1244
|
+
helper
|
|
1245
|
+
};
|
|
1501
1246
|
}
|
|
1502
1247
|
function traverseNodes(nodes, transformer) {
|
|
1503
|
-
|
|
1504
|
-
traverseNode(nodes[i], transformer);
|
|
1505
|
-
}
|
|
1248
|
+
for (let i = 0; i < nodes.length; i++) traverseNode(nodes[i], transformer);
|
|
1506
1249
|
}
|
|
1507
1250
|
function traverseNode(node, transformer) {
|
|
1508
|
-
|
|
1509
|
-
|
|
1510
|
-
|
|
1511
|
-
|
|
1512
|
-
|
|
1513
|
-
|
|
1514
|
-
|
|
1515
|
-
|
|
1516
|
-
|
|
1517
|
-
|
|
1518
|
-
|
|
1519
|
-
|
|
1520
|
-
|
|
1521
|
-
|
|
1522
|
-
|
|
1523
|
-
|
|
1524
|
-
|
|
1525
|
-
|
|
1526
|
-
|
|
1527
|
-
|
|
1528
|
-
|
|
1529
|
-
|
|
1530
|
-
transformer.helper("named" /* HelperNameMap.NAMED */);
|
|
1531
|
-
break;
|
|
1532
|
-
}
|
|
1533
|
-
// TODO: if we need post-hook of transform, should be implemented to here
|
|
1251
|
+
switch (node.type) {
|
|
1252
|
+
case 1:
|
|
1253
|
+
traverseNodes(node.cases, transformer);
|
|
1254
|
+
transformer.helper("plural");
|
|
1255
|
+
break;
|
|
1256
|
+
case 2:
|
|
1257
|
+
traverseNodes(node.items, transformer);
|
|
1258
|
+
break;
|
|
1259
|
+
case 6:
|
|
1260
|
+
traverseNode(node.key, transformer);
|
|
1261
|
+
transformer.helper("linked");
|
|
1262
|
+
transformer.helper("type");
|
|
1263
|
+
break;
|
|
1264
|
+
case 5:
|
|
1265
|
+
transformer.helper("interpolate");
|
|
1266
|
+
transformer.helper("list");
|
|
1267
|
+
break;
|
|
1268
|
+
case 4:
|
|
1269
|
+
transformer.helper("interpolate");
|
|
1270
|
+
transformer.helper("named");
|
|
1271
|
+
break;
|
|
1272
|
+
}
|
|
1534
1273
|
}
|
|
1535
|
-
|
|
1536
|
-
|
|
1537
|
-
)
|
|
1538
|
-
|
|
1539
|
-
|
|
1540
|
-
|
|
1541
|
-
ast.body && traverseNode(ast.body, transformer);
|
|
1542
|
-
// set meta information
|
|
1543
|
-
const context = transformer.context();
|
|
1544
|
-
ast.helpers = Array.from(context.helpers);
|
|
1274
|
+
function transform(ast, _options = {}) {
|
|
1275
|
+
const transformer = createTransformer(ast);
|
|
1276
|
+
transformer.helper("normalize");
|
|
1277
|
+
ast.body && traverseNode(ast.body, transformer);
|
|
1278
|
+
const context = transformer.context();
|
|
1279
|
+
ast.helpers = Array.from(context.helpers);
|
|
1545
1280
|
}
|
|
1546
|
-
|
|
1281
|
+
//#endregion
|
|
1282
|
+
//#region packages/message-compiler/src/compiler.ts
|
|
1547
1283
|
function baseCompile(source, options = {}) {
|
|
1548
|
-
|
|
1549
|
-
|
|
1550
|
-
|
|
1551
|
-
|
|
1552
|
-
|
|
1553
|
-
|
|
1554
|
-
|
|
1555
|
-
|
|
1556
|
-
|
|
1557
|
-
|
|
1558
|
-
|
|
1559
|
-
|
|
1560
|
-
|
|
1561
|
-
|
|
1562
|
-
|
|
1563
|
-
|
|
1564
|
-
// optimize ASTs
|
|
1565
|
-
enableOptimize && optimize(ast);
|
|
1566
|
-
// minimize ASTs
|
|
1567
|
-
enableMangle && mangle(ast);
|
|
1568
|
-
// In JIT mode, no ast transform, no code generation.
|
|
1569
|
-
return { ast, code: '' };
|
|
1570
|
-
}
|
|
1284
|
+
const assignedOptions = assign({}, options);
|
|
1285
|
+
const jit = !!assignedOptions.jit;
|
|
1286
|
+
const enableMangle = !!assignedOptions.mangle;
|
|
1287
|
+
const enableOptimize = assignedOptions.optimize == null ? true : assignedOptions.optimize;
|
|
1288
|
+
const ast = createParser(assignedOptions).parse(source);
|
|
1289
|
+
if (!jit) {
|
|
1290
|
+
transform(ast, assignedOptions);
|
|
1291
|
+
return generate(ast, assignedOptions);
|
|
1292
|
+
} else {
|
|
1293
|
+
enableOptimize && optimize(ast);
|
|
1294
|
+
enableMangle && mangle(ast);
|
|
1295
|
+
return {
|
|
1296
|
+
ast,
|
|
1297
|
+
code: ""
|
|
1298
|
+
};
|
|
1299
|
+
}
|
|
1571
1300
|
}
|
|
1572
|
-
|
|
1573
|
-
|
|
1574
|
-
const RE_HTML_TAG = /<\/?[\w\s="/.':;#-\/]+>/;
|
|
1575
|
-
const detectHtmlTag = (source) => RE_HTML_TAG.test(source);
|
|
1576
|
-
|
|
1577
|
-
export { COMPILE_ERROR_CODES_EXTEND_POINT, CompileErrorCodes, ERROR_DOMAIN, LOCATION_STUB, baseCompile, createCompileError, createLocation, createParser, createPosition, defaultOnError, detectHtmlTag, errorMessages, mangle, optimize };
|
|
1301
|
+
//#endregion
|
|
1302
|
+
export { COMPILE_ERROR_CODES_EXTEND_POINT, CompileErrorCodes, ERROR_DOMAIN, HelperNameMap, LOCATION_STUB, NodeTypes, baseCompile, createCompileError, createLocation, createParser, createPosition, defaultOnError, detectHtmlTag, errorMessages, mangle, optimize };
|