summaryrefslogtreecommitdiffstats
path: root/intl/l10n/FluentSyntax.jsm
diff options
context:
space:
mode:
Diffstat (limited to 'intl/l10n/FluentSyntax.jsm')
-rw-r--r--intl/l10n/FluentSyntax.jsm1957
1 files changed, 1957 insertions, 0 deletions
diff --git a/intl/l10n/FluentSyntax.jsm b/intl/l10n/FluentSyntax.jsm
new file mode 100644
index 0000000000..ec60dd5283
--- /dev/null
+++ b/intl/l10n/FluentSyntax.jsm
@@ -0,0 +1,1957 @@
+/* vim: set ts=2 et sw=2 tw=80 filetype=javascript: */
+
+/* Copyright 2019 Mozilla Foundation and others
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+/* fluent-syntax@0.12.0 */
+
+/*
+ * Base class for all Fluent AST nodes.
+ *
+ * All productions described in the ASDL subclass BaseNode, including Span and
+ * Annotation.
+ *
+ */
+class BaseNode {
+ constructor() {}
+
+ equals(other, ignoredFields = ["span"]) {
+ const thisKeys = new Set(Object.keys(this));
+ const otherKeys = new Set(Object.keys(other));
+ if (ignoredFields) {
+ for (const fieldName of ignoredFields) {
+ thisKeys.delete(fieldName);
+ otherKeys.delete(fieldName);
+ }
+ }
+ if (thisKeys.size !== otherKeys.size) {
+ return false;
+ }
+ for (const fieldName of thisKeys) {
+ if (!otherKeys.has(fieldName)) {
+ return false;
+ }
+ const thisVal = this[fieldName];
+ const otherVal = other[fieldName];
+ if (typeof thisVal !== typeof otherVal) {
+ return false;
+ }
+ if (thisVal instanceof Array) {
+ if (thisVal.length !== otherVal.length) {
+ return false;
+ }
+ for (let i = 0; i < thisVal.length; ++i) {
+ if (!scalarsEqual(thisVal[i], otherVal[i], ignoredFields)) {
+ return false;
+ }
+ }
+ } else if (!scalarsEqual(thisVal, otherVal, ignoredFields)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ clone() {
+ function visit(value) {
+ if (value instanceof BaseNode) {
+ return value.clone();
+ }
+ if (Array.isArray(value)) {
+ return value.map(visit);
+ }
+ return value;
+ }
+ const clone = Object.create(this.constructor.prototype);
+ for (const prop of Object.keys(this)) {
+ clone[prop] = visit(this[prop]);
+ }
+ return clone;
+ }
+}
+
+function scalarsEqual(thisVal, otherVal, ignoredFields) {
+ if (thisVal instanceof BaseNode) {
+ return thisVal.equals(otherVal, ignoredFields);
+ }
+ return thisVal === otherVal;
+}
+
+/*
+ * Base class for AST nodes which can have Spans.
+ */
+class SyntaxNode extends BaseNode {
+ addSpan(start, end) {
+ this.span = new Span(start, end);
+ }
+}
+
+class Resource extends SyntaxNode {
+ constructor(body = []) {
+ super();
+ this.type = "Resource";
+ this.body = body;
+ }
+}
+
+/*
+ * An abstract base class for useful elements of Resource.body.
+ */
+class Entry extends SyntaxNode {}
+
+class Message extends Entry {
+ constructor(id, value = null, attributes = [], comment = null) {
+ super();
+ this.type = "Message";
+ this.id = id;
+ this.value = value;
+ this.attributes = attributes;
+ this.comment = comment;
+ }
+}
+
+class Term extends Entry {
+ constructor(id, value, attributes = [], comment = null) {
+ super();
+ this.type = "Term";
+ this.id = id;
+ this.value = value;
+ this.attributes = attributes;
+ this.comment = comment;
+ }
+}
+
+class Pattern extends SyntaxNode {
+ constructor(elements) {
+ super();
+ this.type = "Pattern";
+ this.elements = elements;
+ }
+}
+
+/*
+ * An abstract base class for elements of Patterns.
+ */
+class PatternElement extends SyntaxNode {}
+
+class TextElement extends PatternElement {
+ constructor(value) {
+ super();
+ this.type = "TextElement";
+ this.value = value;
+ }
+}
+
+class Placeable extends PatternElement {
+ constructor(expression) {
+ super();
+ this.type = "Placeable";
+ this.expression = expression;
+ }
+}
+
+/*
+ * An abstract base class for expressions.
+ */
+class Expression extends SyntaxNode {}
+
+// An abstract base class for Literals.
+class Literal extends Expression {
+ constructor(value) {
+ super();
+ // The "value" field contains the exact contents of the literal,
+ // character-for-character.
+ this.value = value;
+ }
+
+ parse() {
+ return {value: this.value};
+ }
+}
+
+class StringLiteral extends Literal {
+ constructor(value) {
+ super(value);
+ this.type = "StringLiteral";
+ }
+
+ parse() {
+ // Backslash backslash, backslash double quote, uHHHH, UHHHHHH.
+ const KNOWN_ESCAPES =
+ /(?:\\\\|\\"|\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{6}))/g;
+
+ function from_escape_sequence(match, codepoint4, codepoint6) {
+ switch (match) {
+ case "\\\\":
+ return "\\";
+ case "\\\"":
+ return "\"";
+ default:
+ let codepoint = parseInt(codepoint4 || codepoint6, 16);
+ if (codepoint <= 0xD7FF || 0xE000 <= codepoint) {
+ // It's a Unicode scalar value.
+ return String.fromCodePoint(codepoint);
+ }
+ // Escape sequences reresenting surrogate code points are
+ // well-formed but invalid in Fluent. Replace them with U+FFFD
+ // REPLACEMENT CHARACTER.
+ return "�";
+ }
+ }
+
+ let value = this.value.replace(KNOWN_ESCAPES, from_escape_sequence);
+ return {value};
+ }
+}
+
+class NumberLiteral extends Literal {
+ constructor(value) {
+ super(value);
+ this.type = "NumberLiteral";
+ }
+
+ parse() {
+ let value = parseFloat(this.value);
+ let decimal_position = this.value.indexOf(".");
+ let precision = decimal_position > 0
+ ? this.value.length - decimal_position - 1
+ : 0;
+ return {value, precision};
+ }
+}
+
+class MessageReference extends Expression {
+ constructor(id, attribute = null) {
+ super();
+ this.type = "MessageReference";
+ this.id = id;
+ this.attribute = attribute;
+ }
+}
+
+class TermReference extends Expression {
+ constructor(id, attribute = null, args = null) {
+ super();
+ this.type = "TermReference";
+ this.id = id;
+ this.attribute = attribute;
+ this.arguments = args;
+ }
+}
+
+class VariableReference extends Expression {
+ constructor(id) {
+ super();
+ this.type = "VariableReference";
+ this.id = id;
+ }
+}
+
+class FunctionReference extends Expression {
+ constructor(id, args) {
+ super();
+ this.type = "FunctionReference";
+ this.id = id;
+ this.arguments = args;
+ }
+}
+
+class SelectExpression extends Expression {
+ constructor(selector, variants) {
+ super();
+ this.type = "SelectExpression";
+ this.selector = selector;
+ this.variants = variants;
+ }
+}
+
+class CallArguments extends SyntaxNode {
+ constructor(positional = [], named = []) {
+ super();
+ this.type = "CallArguments";
+ this.positional = positional;
+ this.named = named;
+ }
+}
+
+class Attribute extends SyntaxNode {
+ constructor(id, value) {
+ super();
+ this.type = "Attribute";
+ this.id = id;
+ this.value = value;
+ }
+}
+
+class Variant extends SyntaxNode {
+ constructor(key, value, def = false) {
+ super();
+ this.type = "Variant";
+ this.key = key;
+ this.value = value;
+ this.default = def;
+ }
+}
+
+class NamedArgument extends SyntaxNode {
+ constructor(name, value) {
+ super();
+ this.type = "NamedArgument";
+ this.name = name;
+ this.value = value;
+ }
+}
+
+class Identifier extends SyntaxNode {
+ constructor(name) {
+ super();
+ this.type = "Identifier";
+ this.name = name;
+ }
+}
+
+class BaseComment extends Entry {
+ constructor(content) {
+ super();
+ this.type = "BaseComment";
+ this.content = content;
+ }
+}
+
+class Comment extends BaseComment {
+ constructor(content) {
+ super(content);
+ this.type = "Comment";
+ }
+}
+
+class GroupComment extends BaseComment {
+ constructor(content) {
+ super(content);
+ this.type = "GroupComment";
+ }
+}
+class ResourceComment extends BaseComment {
+ constructor(content) {
+ super(content);
+ this.type = "ResourceComment";
+ }
+}
+
+class Junk extends SyntaxNode {
+ constructor(content) {
+ super();
+ this.type = "Junk";
+ this.annotations = [];
+ this.content = content;
+ }
+
+ addAnnotation(annot) {
+ this.annotations.push(annot);
+ }
+}
+
+class Span extends BaseNode {
+ constructor(start, end) {
+ super();
+ this.type = "Span";
+ this.start = start;
+ this.end = end;
+ }
+}
+
+class Annotation extends SyntaxNode {
+ constructor(code, args = [], message) {
+ super();
+ this.type = "Annotation";
+ this.code = code;
+ this.arguments = args;
+ this.message = message;
+ }
+}
+
+const ast = ({
+ BaseNode: BaseNode,
+ Resource: Resource,
+ Entry: Entry,
+ Message: Message,
+ Term: Term,
+ Pattern: Pattern,
+ PatternElement: PatternElement,
+ TextElement: TextElement,
+ Placeable: Placeable,
+ Expression: Expression,
+ Literal: Literal,
+ StringLiteral: StringLiteral,
+ NumberLiteral: NumberLiteral,
+ MessageReference: MessageReference,
+ TermReference: TermReference,
+ VariableReference: VariableReference,
+ FunctionReference: FunctionReference,
+ SelectExpression: SelectExpression,
+ CallArguments: CallArguments,
+ Attribute: Attribute,
+ Variant: Variant,
+ NamedArgument: NamedArgument,
+ Identifier: Identifier,
+ BaseComment: BaseComment,
+ Comment: Comment,
+ GroupComment: GroupComment,
+ ResourceComment: ResourceComment,
+ Junk: Junk,
+ Span: Span,
+ Annotation: Annotation
+});
+
+class ParseError extends Error {
+ constructor(code, ...args) {
+ super();
+ this.code = code;
+ this.args = args;
+ this.message = getErrorMessage(code, args);
+ }
+}
+
+/* eslint-disable complexity */
+function getErrorMessage(code, args) {
+ switch (code) {
+ case "E0001":
+ return "Generic error";
+ case "E0002":
+ return "Expected an entry start";
+ case "E0003": {
+ const [token] = args;
+ return `Expected token: "${token}"`;
+ }
+ case "E0004": {
+ const [range] = args;
+ return `Expected a character from range: "${range}"`;
+ }
+ case "E0005": {
+ const [id] = args;
+ return `Expected message "${id}" to have a value or attributes`;
+ }
+ case "E0006": {
+ const [id] = args;
+ return `Expected term "-${id}" to have a value`;
+ }
+ case "E0007":
+ return "Keyword cannot end with a whitespace";
+ case "E0008":
+ return "The callee has to be an upper-case identifier or a term";
+ case "E0009":
+ return "The argument name has to be a simple identifier";
+ case "E0010":
+ return "Expected one of the variants to be marked as default (*)";
+ case "E0011":
+ return 'Expected at least one variant after "->"';
+ case "E0012":
+ return "Expected value";
+ case "E0013":
+ return "Expected variant key";
+ case "E0014":
+ return "Expected literal";
+ case "E0015":
+ return "Only one variant can be marked as default (*)";
+ case "E0016":
+ return "Message references cannot be used as selectors";
+ case "E0017":
+ return "Terms cannot be used as selectors";
+ case "E0018":
+ return "Attributes of messages cannot be used as selectors";
+ case "E0019":
+ return "Attributes of terms cannot be used as placeables";
+ case "E0020":
+ return "Unterminated string expression";
+ case "E0021":
+ return "Positional arguments must not follow named arguments";
+ case "E0022":
+ return "Named arguments must be unique";
+ case "E0024":
+ return "Cannot access variants of a message.";
+ case "E0025": {
+ const [char] = args;
+ return `Unknown escape sequence: \\${char}.`;
+ }
+ case "E0026": {
+ const [sequence] = args;
+ return `Invalid Unicode escape sequence: ${sequence}.`;
+ }
+ case "E0027":
+ return "Unbalanced closing brace in TextElement.";
+ case "E0028":
+ return "Expected an inline expression";
+ default:
+ return code;
+ }
+}
+
+function includes(arr, elem) {
+ return arr.indexOf(elem) > -1;
+}
+
+/* eslint no-magic-numbers: "off" */
+
+class ParserStream {
+ constructor(string) {
+ this.string = string;
+ this.index = 0;
+ this.peekOffset = 0;
+ }
+
+ charAt(offset) {
+ // When the cursor is at CRLF, return LF but don't move the cursor.
+ // The cursor still points to the EOL position, which in this case is the
+ // beginning of the compound CRLF sequence. This ensures slices of
+ // [inclusive, exclusive) continue to work properly.
+ if (this.string[offset] === "\r"
+ && this.string[offset + 1] === "\n") {
+ return "\n";
+ }
+
+ return this.string[offset];
+ }
+
+ get currentChar() {
+ return this.charAt(this.index);
+ }
+
+ get currentPeek() {
+ return this.charAt(this.index + this.peekOffset);
+ }
+
+ next() {
+ this.peekOffset = 0;
+ // Skip over the CRLF as if it was a single character.
+ if (this.string[this.index] === "\r"
+ && this.string[this.index + 1] === "\n") {
+ this.index++;
+ }
+ this.index++;
+ return this.string[this.index];
+ }
+
+ peek() {
+ // Skip over the CRLF as if it was a single character.
+ if (this.string[this.index + this.peekOffset] === "\r"
+ && this.string[this.index + this.peekOffset + 1] === "\n") {
+ this.peekOffset++;
+ }
+ this.peekOffset++;
+ return this.string[this.index + this.peekOffset];
+ }
+
+ resetPeek(offset = 0) {
+ this.peekOffset = offset;
+ }
+
+ skipToPeek() {
+ this.index += this.peekOffset;
+ this.peekOffset = 0;
+ }
+}
+
+const EOL = "\n";
+const EOF = undefined;
+const SPECIAL_LINE_START_CHARS = ["}", ".", "[", "*"];
+
+class FluentParserStream extends ParserStream {
+ peekBlankInline() {
+ const start = this.index + this.peekOffset;
+ while (this.currentPeek === " ") {
+ this.peek();
+ }
+ return this.string.slice(start, this.index + this.peekOffset);
+ }
+
+ skipBlankInline() {
+ const blank = this.peekBlankInline();
+ this.skipToPeek();
+ return blank;
+ }
+
+ peekBlankBlock() {
+ let blank = "";
+ while (true) {
+ const lineStart = this.peekOffset;
+ this.peekBlankInline();
+ if (this.currentPeek === EOL) {
+ blank += EOL;
+ this.peek();
+ continue;
+ }
+ if (this.currentPeek === EOF) {
+ // Treat the blank line at EOF as a blank block.
+ return blank;
+ }
+ // Any other char; reset to column 1 on this line.
+ this.resetPeek(lineStart);
+ return blank;
+ }
+ }
+
+ skipBlankBlock() {
+ const blank = this.peekBlankBlock();
+ this.skipToPeek();
+ return blank;
+ }
+
+ peekBlank() {
+ while (this.currentPeek === " " || this.currentPeek === EOL) {
+ this.peek();
+ }
+ }
+
+ skipBlank() {
+ this.peekBlank();
+ this.skipToPeek();
+ }
+
+ expectChar(ch) {
+ if (this.currentChar === ch) {
+ this.next();
+ return true;
+ }
+
+ throw new ParseError("E0003", ch);
+ }
+
+ expectLineEnd() {
+ if (this.currentChar === EOF) {
+ // EOF is a valid line end in Fluent.
+ return true;
+ }
+
+ if (this.currentChar === EOL) {
+ this.next();
+ return true;
+ }
+
+ // Unicode Character 'SYMBOL FOR NEWLINE' (U+2424)
+ throw new ParseError("E0003", "\u2424");
+ }
+
+ takeChar(f) {
+ const ch = this.currentChar;
+ if (ch === EOF) {
+ return EOF;
+ }
+ if (f(ch)) {
+ this.next();
+ return ch;
+ }
+ return null;
+ }
+
+ isCharIdStart(ch) {
+ if (ch === EOF) {
+ return false;
+ }
+
+ const cc = ch.charCodeAt(0);
+ return (cc >= 97 && cc <= 122) || // a-z
+ (cc >= 65 && cc <= 90); // A-Z
+ }
+
+ isIdentifierStart() {
+ return this.isCharIdStart(this.currentPeek);
+ }
+
+ isNumberStart() {
+ const ch = this.currentChar === "-"
+ ? this.peek()
+ : this.currentChar;
+
+ if (ch === EOF) {
+ this.resetPeek();
+ return false;
+ }
+
+ const cc = ch.charCodeAt(0);
+ const isDigit = cc >= 48 && cc <= 57; // 0-9
+ this.resetPeek();
+ return isDigit;
+ }
+
+ isCharPatternContinuation(ch) {
+ if (ch === EOF) {
+ return false;
+ }
+
+ return !includes(SPECIAL_LINE_START_CHARS, ch);
+ }
+
+ isValueStart() {
+ // Inline Patterns may start with any char.
+ const ch = this.currentPeek;
+ return ch !== EOL && ch !== EOF;
+ }
+
+ isValueContinuation() {
+ const column1 = this.peekOffset;
+ this.peekBlankInline();
+
+ if (this.currentPeek === "{") {
+ this.resetPeek(column1);
+ return true;
+ }
+
+ if (this.peekOffset - column1 === 0) {
+ return false;
+ }
+
+ if (this.isCharPatternContinuation(this.currentPeek)) {
+ this.resetPeek(column1);
+ return true;
+ }
+
+ return false;
+ }
+
+ // -1 - any
+ // 0 - comment
+ // 1 - group comment
+ // 2 - resource comment
+ isNextLineComment(level = -1) {
+ if (this.currentChar !== EOL) {
+ return false;
+ }
+
+ let i = 0;
+
+ while (i <= level || (level === -1 && i < 3)) {
+ if (this.peek() !== "#") {
+ if (i <= level && level !== -1) {
+ this.resetPeek();
+ return false;
+ }
+ break;
+ }
+ i++;
+ }
+
+ // The first char after #, ## or ###.
+ const ch = this.peek();
+ if (ch === " " || ch === EOL) {
+ this.resetPeek();
+ return true;
+ }
+
+ this.resetPeek();
+ return false;
+ }
+
+ isVariantStart() {
+ const currentPeekOffset = this.peekOffset;
+ if (this.currentPeek === "*") {
+ this.peek();
+ }
+ if (this.currentPeek === "[") {
+ this.resetPeek(currentPeekOffset);
+ return true;
+ }
+ this.resetPeek(currentPeekOffset);
+ return false;
+ }
+
+ isAttributeStart() {
+ return this.currentPeek === ".";
+ }
+
+ skipToNextEntryStart(junkStart) {
+ let lastNewline = this.string.lastIndexOf(EOL, this.index);
+ if (junkStart < lastNewline) {
+ // Last seen newline is _after_ the junk start. It's safe to rewind
+ // without the risk of resuming at the same broken entry.
+ this.index = lastNewline;
+ }
+ while (this.currentChar) {
+ // We're only interested in beginnings of line.
+ if (this.currentChar !== EOL) {
+ this.next();
+ continue;
+ }
+
+ // Break if the first char in this line looks like an entry start.
+ const first = this.next();
+ if (this.isCharIdStart(first) || first === "-" || first === "#") {
+ break;
+ }
+ }
+ }
+
+ takeIDStart() {
+ if (this.isCharIdStart(this.currentChar)) {
+ const ret = this.currentChar;
+ this.next();
+ return ret;
+ }
+
+ throw new ParseError("E0004", "a-zA-Z");
+ }
+
+ takeIDChar() {
+ const closure = ch => {
+ const cc = ch.charCodeAt(0);
+ return ((cc >= 97 && cc <= 122) || // a-z
+ (cc >= 65 && cc <= 90) || // A-Z
+ (cc >= 48 && cc <= 57) || // 0-9
+ cc === 95 || cc === 45); // _-
+ };
+
+ return this.takeChar(closure);
+ }
+
+ takeDigit() {
+ const closure = ch => {
+ const cc = ch.charCodeAt(0);
+ return (cc >= 48 && cc <= 57); // 0-9
+ };
+
+ return this.takeChar(closure);
+ }
+
+ takeHexDigit() {
+ const closure = ch => {
+ const cc = ch.charCodeAt(0);
+ return (cc >= 48 && cc <= 57) // 0-9
+ || (cc >= 65 && cc <= 70) // A-F
+ || (cc >= 97 && cc <= 102); // a-f
+ };
+
+ return this.takeChar(closure);
+ }
+}
+
+/* eslint no-magic-numbers: [0] */
+
+
+const trailingWSRe = /[ \t\n\r]+$/;
+
+
+function withSpan(fn) {
+ return function(ps, ...args) {
+ if (!this.withSpans) {
+ return fn.call(this, ps, ...args);
+ }
+
+ const start = ps.index;
+ const node = fn.call(this, ps, ...args);
+
+ // Don't re-add the span if the node already has it. This may happen when
+ // one decorated function calls another decorated function.
+ if (node.span) {
+ return node;
+ }
+
+ const end = ps.index;
+ node.addSpan(start, end);
+ return node;
+ };
+}
+
+
+class FluentParser {
+ constructor({
+ withSpans = true,
+ } = {}) {
+ this.withSpans = withSpans;
+
+ // Poor man's decorators.
+ const methodNames = [
+ "getComment", "getMessage", "getTerm", "getAttribute", "getIdentifier",
+ "getVariant", "getNumber", "getPattern", "getTextElement",
+ "getPlaceable", "getExpression", "getInlineExpression",
+ "getCallArgument", "getCallArguments", "getString", "getLiteral",
+ ];
+ for (const name of methodNames) {
+ this[name] = withSpan(this[name]);
+ }
+ }
+
+ parse(source) {
+ const ps = new FluentParserStream(source);
+ ps.skipBlankBlock();
+
+ const entries = [];
+ let lastComment = null;
+
+ while (ps.currentChar) {
+ const entry = this.getEntryOrJunk(ps);
+ const blankLines = ps.skipBlankBlock();
+
+ // Regular Comments require special logic. Comments may be attached to
+ // Messages or Terms if they are followed immediately by them. However
+ // they should parse as standalone when they're followed by Junk.
+ // Consequently, we only attach Comments once we know that the Message
+ // or the Term parsed successfully.
+ if (entry.type === "Comment"
+ && blankLines.length === 0
+ && ps.currentChar) {
+ // Stash the comment and decide what to do with it in the next pass.
+ lastComment = entry;
+ continue;
+ }
+
+ if (lastComment) {
+ if (entry.type === "Message" || entry.type === "Term") {
+ entry.comment = lastComment;
+ if (this.withSpans) {
+ entry.span.start = entry.comment.span.start;
+ }
+ } else {
+ entries.push(lastComment);
+ }
+ // In either case, the stashed comment has been dealt with; clear it.
+ lastComment = null;
+ }
+
+ // No special logic for other types of entries.
+ entries.push(entry);
+ }
+
+ const res = new Resource(entries);
+
+ if (this.withSpans) {
+ res.addSpan(0, ps.index);
+ }
+
+ return res;
+ }
+
+ /*
+ * Parse the first Message or Term in `source`.
+ *
+ * Skip all encountered comments and start parsing at the first Message or
+ * Term start. Return Junk if the parsing is not successful.
+ *
+ * Preceding comments are ignored unless they contain syntax errors
+ * themselves, in which case Junk for the invalid comment is returned.
+ */
+ parseEntry(source) {
+ const ps = new FluentParserStream(source);
+ ps.skipBlankBlock();
+
+ while (ps.currentChar === "#") {
+ const skipped = this.getEntryOrJunk(ps);
+ if (skipped.type === "Junk") {
+ // Don't skip Junk comments.
+ return skipped;
+ }
+ ps.skipBlankBlock();
+ }
+
+ return this.getEntryOrJunk(ps);
+ }
+
+ getEntryOrJunk(ps) {
+ const entryStartPos = ps.index;
+
+ try {
+ const entry = this.getEntry(ps);
+ ps.expectLineEnd();
+ return entry;
+ } catch (err) {
+ if (!(err instanceof ParseError)) {
+ throw err;
+ }
+
+ let errorIndex = ps.index;
+ ps.skipToNextEntryStart(entryStartPos);
+ const nextEntryStart = ps.index;
+ if (nextEntryStart < errorIndex) {
+ // The position of the error must be inside of the Junk's span.
+ errorIndex = nextEntryStart;
+ }
+
+ // Create a Junk instance
+ const slice = ps.string.substring(entryStartPos, nextEntryStart);
+ const junk = new Junk(slice);
+ if (this.withSpans) {
+ junk.addSpan(entryStartPos, nextEntryStart);
+ }
+ const annot = new Annotation(err.code, err.args, err.message);
+ annot.addSpan(errorIndex, errorIndex);
+ junk.addAnnotation(annot);
+ return junk;
+ }
+ }
+
+ getEntry(ps) {
+ if (ps.currentChar === "#") {
+ return this.getComment(ps);
+ }
+
+ if (ps.currentChar === "-") {
+ return this.getTerm(ps);
+ }
+
+ if (ps.isIdentifierStart()) {
+ return this.getMessage(ps);
+ }
+
+ throw new ParseError("E0002");
+ }
+
+ getComment(ps) {
+ // 0 - comment
+ // 1 - group comment
+ // 2 - resource comment
+ let level = -1;
+ let content = "";
+
+ while (true) {
+ let i = -1;
+ while (ps.currentChar === "#" && (i < (level === -1 ? 2 : level))) {
+ ps.next();
+ i++;
+ }
+
+ if (level === -1) {
+ level = i;
+ }
+
+ if (ps.currentChar !== EOL) {
+ ps.expectChar(" ");
+ let ch;
+ while ((ch = ps.takeChar(x => x !== EOL))) {
+ content += ch;
+ }
+ }
+
+ if (ps.isNextLineComment(level)) {
+ content += ps.currentChar;
+ ps.next();
+ } else {
+ break;
+ }
+ }
+
+ let Comment$$1;
+ switch (level) {
+ case 0:
+ Comment$$1 = Comment;
+ break;
+ case 1:
+ Comment$$1 = GroupComment;
+ break;
+ case 2:
+ Comment$$1 = ResourceComment;
+ break;
+ }
+ return new Comment$$1(content);
+ }
+
+ getMessage(ps) {
+ const id = this.getIdentifier(ps);
+
+ ps.skipBlankInline();
+ ps.expectChar("=");
+
+ const value = this.maybeGetPattern(ps);
+ const attrs = this.getAttributes(ps);
+
+ if (value === null && attrs.length === 0) {
+ throw new ParseError("E0005", id.name);
+ }
+
+ return new Message(id, value, attrs);
+ }
+
+ getTerm(ps) {
+ ps.expectChar("-");
+ const id = this.getIdentifier(ps);
+
+ ps.skipBlankInline();
+ ps.expectChar("=");
+
+ const value = this.maybeGetPattern(ps);
+ if (value === null) {
+ throw new ParseError("E0006", id.name);
+ }
+
+ const attrs = this.getAttributes(ps);
+ return new Term(id, value, attrs);
+ }
+
+ getAttribute(ps) {
+ ps.expectChar(".");
+
+ const key = this.getIdentifier(ps);
+
+ ps.skipBlankInline();
+ ps.expectChar("=");
+
+ const value = this.maybeGetPattern(ps);
+ if (value === null) {
+ throw new ParseError("E0012");
+ }
+
+ return new Attribute(key, value);
+ }
+
+ getAttributes(ps) {
+ const attrs = [];
+ ps.peekBlank();
+ while (ps.isAttributeStart()) {
+ ps.skipToPeek();
+ const attr = this.getAttribute(ps);
+ attrs.push(attr);
+ ps.peekBlank();
+ }
+ return attrs;
+ }
+
+ getIdentifier(ps) {
+ let name = ps.takeIDStart();
+
+ let ch;
+ while ((ch = ps.takeIDChar())) {
+ name += ch;
+ }
+
+ return new Identifier(name);
+ }
+
+ getVariantKey(ps) {
+ const ch = ps.currentChar;
+
+ if (ch === EOF) {
+ throw new ParseError("E0013");
+ }
+
+ const cc = ch.charCodeAt(0);
+
+ if ((cc >= 48 && cc <= 57) || cc === 45) { // 0-9, -
+ return this.getNumber(ps);
+ }
+
+ return this.getIdentifier(ps);
+ }
+
+ getVariant(ps, {hasDefault}) {
+ let defaultIndex = false;
+
+ if (ps.currentChar === "*") {
+ if (hasDefault) {
+ throw new ParseError("E0015");
+ }
+ ps.next();
+ defaultIndex = true;
+ }
+
+ ps.expectChar("[");
+
+ ps.skipBlank();
+
+ const key = this.getVariantKey(ps);
+
+ ps.skipBlank();
+ ps.expectChar("]");
+
+ const value = this.maybeGetPattern(ps);
+ if (value === null) {
+ throw new ParseError("E0012");
+ }
+
+ return new Variant(key, value, defaultIndex);
+ }
+
+ getVariants(ps) {
+ const variants = [];
+ let hasDefault = false;
+
+ ps.skipBlank();
+ while (ps.isVariantStart()) {
+ const variant = this.getVariant(ps, {hasDefault});
+
+ if (variant.default) {
+ hasDefault = true;
+ }
+
+ variants.push(variant);
+ ps.expectLineEnd();
+ ps.skipBlank();
+ }
+
+ if (variants.length === 0) {
+ throw new ParseError("E0011");
+ }
+
+ if (!hasDefault) {
+ throw new ParseError("E0010");
+ }
+
+ return variants;
+ }
+
+ getDigits(ps) {
+ let num = "";
+
+ let ch;
+ while ((ch = ps.takeDigit())) {
+ num += ch;
+ }
+
+ if (num.length === 0) {
+ throw new ParseError("E0004", "0-9");
+ }
+
+ return num;
+ }
+
+ getNumber(ps) {
+ let value = "";
+
+ if (ps.currentChar === "-") {
+ ps.next();
+ value += `-${this.getDigits(ps)}`;
+ } else {
+ value += this.getDigits(ps);
+ }
+
+ if (ps.currentChar === ".") {
+ ps.next();
+ value += `.${this.getDigits(ps)}`;
+ }
+
+ return new NumberLiteral(value);
+ }
+
+ // maybeGetPattern distinguishes between patterns which start on the same line
+ // as the identifier (a.k.a. inline signleline patterns and inline multiline
+ // patterns) and patterns which start on a new line (a.k.a. block multiline
+ // patterns). The distinction is important for the dedentation logic: the
+ // indent of the first line of a block pattern must be taken into account when
+ // calculating the maximum common indent.
+ maybeGetPattern(ps) {
+ ps.peekBlankInline();
+ if (ps.isValueStart()) {
+ ps.skipToPeek();
+ return this.getPattern(ps, {isBlock: false});
+ }
+
+ ps.peekBlankBlock();
+ if (ps.isValueContinuation()) {
+ ps.skipToPeek();
+ return this.getPattern(ps, {isBlock: true});
+ }
+
+ return null;
+ }
+
+ getPattern(ps, {isBlock}) {
+ const elements = [];
+ if (isBlock) {
+ // A block pattern is a pattern which starts on a new line. Store and
+ // measure the indent of this first line for the dedentation logic.
+ const blankStart = ps.index;
+ const firstIndent = ps.skipBlankInline();
+ elements.push(this.getIndent(ps, firstIndent, blankStart));
+ var commonIndentLength = firstIndent.length;
+ } else {
+ commonIndentLength = Infinity;
+ }
+
+ let ch;
+ elements: while ((ch = ps.currentChar)) {
+ switch (ch) {
+ case EOL: {
+ const blankStart = ps.index;
+ const blankLines = ps.peekBlankBlock();
+ if (ps.isValueContinuation()) {
+ ps.skipToPeek();
+ const indent = ps.skipBlankInline();
+ commonIndentLength = Math.min(commonIndentLength, indent.length);
+ elements.push(this.getIndent(ps, blankLines + indent, blankStart));
+ continue elements;
+ }
+
+ // The end condition for getPattern's while loop is a newline
+ // which is not followed by a valid pattern continuation.
+ ps.resetPeek();
+ break elements;
+ }
+ case "{":
+ elements.push(this.getPlaceable(ps));
+ continue elements;
+ case "}":
+ throw new ParseError("E0027");
+ default:
+ const element = this.getTextElement(ps);
+ elements.push(element);
+ }
+ }
+
+ const dedented = this.dedent(elements, commonIndentLength);
+ return new Pattern(dedented);
+ }
+
+ // Create a token representing an indent. It's not part of the AST and it will
+ // be trimmed and merged into adjacent TextElements, or turned into a new
+ // TextElement, if it's surrounded by two Placeables.
+ getIndent(ps, value, start) {
+ return {
+ type: "Indent",
+ span: {start, end: ps.index},
+ value,
+ };
+ }
+
+ // Dedent a list of elements by removing the maximum common indent from the
+ // beginning of text lines. The common indent is calculated in getPattern.
+ dedent(elements, commonIndent) {
+ const trimmed = [];
+
+ for (let element of elements) {
+ if (element.type === "Placeable") {
+ trimmed.push(element);
+ continue;
+ }
+
+ if (element.type === "Indent") {
+ // Strip common indent.
+ element.value = element.value.slice(
+ 0, element.value.length - commonIndent);
+ if (element.value.length === 0) {
+ continue;
+ }
+ }
+
+ let prev = trimmed[trimmed.length - 1];
+ if (prev && prev.type === "TextElement") {
+ // Join adjacent TextElements by replacing them with their sum.
+ const sum = new TextElement(prev.value + element.value);
+ if (this.withSpans) {
+ sum.addSpan(prev.span.start, element.span.end);
+ }
+ trimmed[trimmed.length - 1] = sum;
+ continue;
+ }
+
+ if (element.type === "Indent") {
+ // If the indent hasn't been merged into a preceding TextElement,
+ // convert it into a new TextElement.
+ const textElement = new TextElement(element.value);
+ if (this.withSpans) {
+ textElement.addSpan(element.span.start, element.span.end);
+ }
+ element = textElement;
+ }
+
+ trimmed.push(element);
+ }
+
+ // Trim trailing whitespace from the Pattern.
+ const lastElement = trimmed[trimmed.length - 1];
+ if (lastElement.type === "TextElement") {
+ lastElement.value = lastElement.value.replace(trailingWSRe, "");
+ if (lastElement.value.length === 0) {
+ trimmed.pop();
+ }
+ }
+
+ return trimmed;
+ }
+
+ getTextElement(ps) {
+ let buffer = "";
+
+ let ch;
+ while ((ch = ps.currentChar)) {
+ if (ch === "{" || ch === "}") {
+ return new TextElement(buffer);
+ }
+
+ if (ch === EOL) {
+ return new TextElement(buffer);
+ }
+
+ buffer += ch;
+ ps.next();
+ }
+
+ return new TextElement(buffer);
+ }
+
+ getEscapeSequence(ps) {
+ const next = ps.currentChar;
+
+ switch (next) {
+ case "\\":
+ case "\"":
+ ps.next();
+ return `\\${next}`;
+ case "u":
+ return this.getUnicodeEscapeSequence(ps, next, 4);
+ case "U":
+ return this.getUnicodeEscapeSequence(ps, next, 6);
+ default:
+ throw new ParseError("E0025", next);
+ }
+ }
+
+ getUnicodeEscapeSequence(ps, u, digits) {
+ ps.expectChar(u);
+
+ let sequence = "";
+ for (let i = 0; i < digits; i++) {
+ const ch = ps.takeHexDigit();
+
+ if (!ch) {
+ throw new ParseError(
+ "E0026", `\\${u}${sequence}${ps.currentChar}`);
+ }
+
+ sequence += ch;
+ }
+
+ return `\\${u}${sequence}`;
+ }
+
+ getPlaceable(ps) {
+ ps.expectChar("{");
+ ps.skipBlank();
+ const expression = this.getExpression(ps);
+ ps.expectChar("}");
+ return new Placeable(expression);
+ }
+
+ getExpression(ps) {
+ const selector = this.getInlineExpression(ps);
+ ps.skipBlank();
+
+ if (ps.currentChar === "-") {
+ if (ps.peek() !== ">") {
+ ps.resetPeek();
+ return selector;
+ }
+
+ if (selector.type === "MessageReference") {
+ if (selector.attribute === null) {
+ throw new ParseError("E0016");
+ } else {
+ throw new ParseError("E0018");
+ }
+ }
+
+ if (selector.type === "TermReference" && selector.attribute === null) {
+ throw new ParseError("E0017");
+ }
+
+ ps.next();
+ ps.next();
+
+ ps.skipBlankInline();
+ ps.expectLineEnd();
+
+ const variants = this.getVariants(ps);
+ return new SelectExpression(selector, variants);
+ }
+
+ if (selector.type === "TermReference" && selector.attribute !== null) {
+ throw new ParseError("E0019");
+ }
+
+ return selector;
+ }
+
+ getInlineExpression(ps) {
+ if (ps.currentChar === "{") {
+ return this.getPlaceable(ps);
+ }
+
+ if (ps.isNumberStart()) {
+ return this.getNumber(ps);
+ }
+
+ if (ps.currentChar === '"') {
+ return this.getString(ps);
+ }
+
+ if (ps.currentChar === "$") {
+ ps.next();
+ const id = this.getIdentifier(ps);
+ return new VariableReference(id);
+ }
+
+ if (ps.currentChar === "-") {
+ ps.next();
+ const id = this.getIdentifier(ps);
+
+ let attr;
+ if (ps.currentChar === ".") {
+ ps.next();
+ attr = this.getIdentifier(ps);
+ }
+
+ let args;
+ if (ps.currentChar === "(") {
+ args = this.getCallArguments(ps);
+ }
+
+ return new TermReference(id, attr, args);
+ }
+
+ if (ps.isIdentifierStart()) {
+ const id = this.getIdentifier(ps);
+
+ if (ps.currentChar === "(") {
+ // It's a Function. Ensure it's all upper-case.
+ if (!/^[A-Z][A-Z0-9_-]*$/.test(id.name)) {
+ throw new ParseError("E0008");
+ }
+
+ let args = this.getCallArguments(ps);
+ return new FunctionReference(id, args);
+ }
+
+ let attr;
+ if (ps.currentChar === ".") {
+ ps.next();
+ attr = this.getIdentifier(ps);
+ }
+
+ return new MessageReference(id, attr);
+ }
+
+
+ throw new ParseError("E0028");
+ }
+
+ getCallArgument(ps) {
+ const exp = this.getInlineExpression(ps);
+
+ ps.skipBlank();
+
+ if (ps.currentChar !== ":") {
+ return exp;
+ }
+
+ if (exp.type === "MessageReference" && exp.attribute === null) {
+ ps.next();
+ ps.skipBlank();
+
+ const value = this.getLiteral(ps);
+ return new NamedArgument(exp.id, value);
+ }
+
+ throw new ParseError("E0009");
+ }
+
+ getCallArguments(ps) {
+ const positional = [];
+ const named = [];
+ const argumentNames = new Set();
+
+ ps.expectChar("(");
+ ps.skipBlank();
+
+ while (true) {
+ if (ps.currentChar === ")") {
+ break;
+ }
+
+ const arg = this.getCallArgument(ps);
+ if (arg.type === "NamedArgument") {
+ if (argumentNames.has(arg.name.name)) {
+ throw new ParseError("E0022");
+ }
+ named.push(arg);
+ argumentNames.add(arg.name.name);
+ } else if (argumentNames.size > 0) {
+ throw new ParseError("E0021");
+ } else {
+ positional.push(arg);
+ }
+
+ ps.skipBlank();
+
+ if (ps.currentChar === ",") {
+ ps.next();
+ ps.skipBlank();
+ continue;
+ }
+
+ break;
+ }
+
+ ps.expectChar(")");
+ return new CallArguments(positional, named);
+ }
+
+ getString(ps) {
+ ps.expectChar("\"");
+ let value = "";
+
+ let ch;
+ while ((ch = ps.takeChar(x => x !== '"' && x !== EOL))) {
+ if (ch === "\\") {
+ value += this.getEscapeSequence(ps);
+ } else {
+ value += ch;
+ }
+ }
+
+ if (ps.currentChar === EOL) {
+ throw new ParseError("E0020");
+ }
+
+ ps.expectChar("\"");
+
+ return new StringLiteral(value);
+ }
+
+ getLiteral(ps) {
+ if (ps.isNumberStart()) {
+ return this.getNumber(ps);
+ }
+
+ if (ps.currentChar === '"') {
+ return this.getString(ps);
+ }
+
+ throw new ParseError("E0014");
+ }
+}
+
+function indent(content) {
+ return content.split("\n").join("\n ");
+}
+
+function includesNewLine(elem) {
+ return elem.type === "TextElement" && includes(elem.value, "\n");
+}
+
+function isSelectExpr(elem) {
+ return elem.type === "Placeable"
+ && elem.expression.type === "SelectExpression";
+}
+
+const HAS_ENTRIES = 1;
+
+class FluentSerializer {
+ constructor({ withJunk = false } = {}) {
+ this.withJunk = withJunk;
+ }
+
+ serialize(resource) {
+ if (resource.type !== "Resource") {
+ throw new Error(`Unknown resource type: ${resource.type}`);
+ }
+
+ let state = 0;
+ const parts = [];
+
+ for (const entry of resource.body) {
+ if (entry.type !== "Junk" || this.withJunk) {
+ parts.push(this.serializeEntry(entry, state));
+ if (!(state & HAS_ENTRIES)) {
+ state |= HAS_ENTRIES;
+ }
+ }
+ }
+
+ return parts.join("");
+ }
+
+ serializeEntry(entry, state = 0) {
+ switch (entry.type) {
+ case "Message":
+ return serializeMessage(entry);
+ case "Term":
+ return serializeTerm(entry);
+ case "Comment":
+ if (state & HAS_ENTRIES) {
+ return `\n${serializeComment(entry, "#")}\n`;
+ }
+ return `${serializeComment(entry, "#")}\n`;
+ case "GroupComment":
+ if (state & HAS_ENTRIES) {
+ return `\n${serializeComment(entry, "##")}\n`;
+ }
+ return `${serializeComment(entry, "##")}\n`;
+ case "ResourceComment":
+ if (state & HAS_ENTRIES) {
+ return `\n${serializeComment(entry, "###")}\n`;
+ }
+ return `${serializeComment(entry, "###")}\n`;
+ case "Junk":
+ return serializeJunk(entry);
+ default :
+ throw new Error(`Unknown entry type: ${entry.type}`);
+ }
+ }
+}
+
+
+function serializeComment(comment, prefix = "#") {
+ const prefixed = comment.content.split("\n").map(
+ line => line.length ? `${prefix} ${line}` : prefix
+ ).join("\n");
+ // Add the trailing newline.
+ return `${prefixed}\n`;
+}
+
+
+function serializeJunk(junk) {
+ return junk.content;
+}
+
+
+function serializeMessage(message) {
+ const parts = [];
+
+ if (message.comment) {
+ parts.push(serializeComment(message.comment));
+ }
+
+ parts.push(`${message.id.name} =`);
+
+ if (message.value) {
+ parts.push(serializePattern(message.value));
+ }
+
+ for (const attribute of message.attributes) {
+ parts.push(serializeAttribute(attribute));
+ }
+
+ parts.push("\n");
+ return parts.join("");
+}
+
+
+function serializeTerm(term) {
+ const parts = [];
+
+ if (term.comment) {
+ parts.push(serializeComment(term.comment));
+ }
+
+ parts.push(`-${term.id.name} =`);
+ parts.push(serializePattern(term.value));
+
+ for (const attribute of term.attributes) {
+ parts.push(serializeAttribute(attribute));
+ }
+
+ parts.push("\n");
+ return parts.join("");
+}
+
+
+function serializeAttribute(attribute) {
+ const value = indent(serializePattern(attribute.value));
+ return `\n .${attribute.id.name} =${value}`;
+}
+
+
+function serializePattern(pattern) {
+ const content = pattern.elements.map(serializeElement).join("");
+ const startOnNewLine =
+ pattern.elements.some(isSelectExpr) ||
+ pattern.elements.some(includesNewLine);
+
+ if (startOnNewLine) {
+ return `\n ${indent(content)}`;
+ }
+
+ return ` ${content}`;
+}
+
+
+function serializeElement(element) {
+ switch (element.type) {
+ case "TextElement":
+ return element.value;
+ case "Placeable":
+ return serializePlaceable(element);
+ default:
+ throw new Error(`Unknown element type: ${element.type}`);
+ }
+}
+
+
+function serializePlaceable(placeable) {
+ const expr = placeable.expression;
+ switch (expr.type) {
+ case "Placeable":
+ return `{${serializePlaceable(expr)}}`;
+ case "SelectExpression":
+ // Special-case select expression to control the whitespace around the
+ // opening and the closing brace.
+ return `{ ${serializeExpression(expr)}}`;
+ default:
+ return `{ ${serializeExpression(expr)} }`;
+ }
+}
+
+
+function serializeExpression(expr) {
+ switch (expr.type) {
+ case "StringLiteral":
+ return `"${expr.value}"`;
+ case "NumberLiteral":
+ return expr.value;
+ case "VariableReference":
+ return `$${expr.id.name}`;
+ case "TermReference": {
+ let out = `-${expr.id.name}`;
+ if (expr.attribute) {
+ out += `.${expr.attribute.name}`;
+ }
+ if (expr.arguments) {
+ out += serializeCallArguments(expr.arguments);
+ }
+ return out;
+ }
+ case "MessageReference": {
+ let out = expr.id.name;
+ if (expr.attribute) {
+ out += `.${expr.attribute.name}`;
+ }
+ return out;
+ }
+ case "FunctionReference":
+ return `${expr.id.name}${serializeCallArguments(expr.arguments)}`;
+ case "SelectExpression": {
+ let out = `${serializeExpression(expr.selector)} ->`;
+ for (let variant of expr.variants) {
+ out += serializeVariant(variant);
+ }
+ return `${out}\n`;
+ }
+ case "Placeable":
+ return serializePlaceable(expr);
+ default:
+ throw new Error(`Unknown expression type: ${expr.type}`);
+ }
+}
+
+
+function serializeVariant(variant) {
+ const key = serializeVariantKey(variant.key);
+ const value = indent(serializePattern(variant.value));
+
+ if (variant.default) {
+ return `\n *[${key}]${value}`;
+ }
+
+ return `\n [${key}]${value}`;
+}
+
+
+function serializeCallArguments(expr) {
+ const positional = expr.positional.map(serializeExpression).join(", ");
+ const named = expr.named.map(serializeNamedArgument).join(", ");
+ if (expr.positional.length > 0 && expr.named.length > 0) {
+ return `(${positional}, ${named})`;
+ }
+ return `(${positional || named})`;
+}
+
+
+function serializeNamedArgument(arg) {
+ const value = serializeExpression(arg.value);
+ return `${arg.name.name}: ${value}`;
+}
+
+
+function serializeVariantKey(key) {
+ switch (key.type) {
+ case "Identifier":
+ return key.name;
+ case "NumberLiteral":
+ return key.value;
+ default:
+ throw new Error(`Unknown variant key type: ${key.type}`);
+ }
+}
+
+/*
+ * Abstract Visitor pattern
+ */
+class Visitor {
+ visit(node) {
+ if (Array.isArray(node)) {
+ node.forEach(child => this.visit(child));
+ return;
+ }
+ if (!(node instanceof BaseNode)) {
+ return;
+ }
+ const visit = this[`visit${node.type}`] || this.genericVisit;
+ visit.call(this, node);
+ }
+
+ genericVisit(node) {
+ for (const propname of Object.keys(node)) {
+ this.visit(node[propname]);
+ }
+ }
+}
+
+/*
+ * Abstract Transformer pattern
+ */
+class Transformer extends Visitor {
+ visit(node) {
+ if (!(node instanceof BaseNode)) {
+ return node;
+ }
+ const visit = this[`visit${node.type}`] || this.genericVisit;
+ return visit.call(this, node);
+ }
+
+ genericVisit(node) {
+ for (const propname of Object.keys(node)) {
+ const propvalue = node[propname];
+ if (Array.isArray(propvalue)) {
+ const newvals = propvalue
+ .map(child => this.visit(child))
+ .filter(newchild => newchild !== undefined);
+ node[propname] = newvals;
+ }
+ if (propvalue instanceof BaseNode) {
+ const new_val = this.visit(propvalue);
+ if (new_val === undefined) {
+ delete node[propname];
+ } else {
+ node[propname] = new_val;
+ }
+ }
+ }
+ return node;
+ }
+}
+
+const visitor = ({
+ Visitor: Visitor,
+ Transformer: Transformer
+});
+
+/* eslint object-shorthand: "off",
+ comma-dangle: "off",
+ no-labels: "off" */
+
+this.EXPORTED_SYMBOLS = [
+ ...Object.keys({
+ FluentParser,
+ FluentSerializer,
+ }),
+ ...Object.keys(ast),
+ ...Object.keys(visitor),
+];
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-02 10:59:34 +0000