ventojs 0.12.1 → 0.12.2

package/esm/deps/deno.land/x/astring@v1.8.6/src/astring.js

@@ -1,1159 +0,0 @@
-// Astring is a tiny and fast JavaScript code generator from an ESTree-compliant AST.
-//
-// Astring was written by David Bonnet and released under an MIT license.
-//
-// The Git repository for Astring is available at:
-// https://github.com/davidbonnet/astring.git
-//
-// Please use the GitHub bug tracker to report issues:
-// https://github.com/davidbonnet/astring/issues
-const { stringify } = JSON;
-/* c8 ignore if */
-if (!String.prototype.repeat) {
-    /* c8 ignore next */
-    throw new Error('String.prototype.repeat is undefined, see https://github.com/davidbonnet/astring#installation');
-}
-/* c8 ignore if */
-if (!String.prototype.endsWith) {
-    /* c8 ignore next */
-    throw new Error('String.prototype.endsWith is undefined, see https://github.com/davidbonnet/astring#installation');
-}
-const OPERATOR_PRECEDENCE = {
-    '||': 2,
-    '??': 3,
-    '&&': 4,
-    '|': 5,
-    '^': 6,
-    '&': 7,
-    '==': 8,
-    '!=': 8,
-    '===': 8,
-    '!==': 8,
-    '<': 9,
-    '>': 9,
-    '<=': 9,
-    '>=': 9,
-    in: 9,
-    instanceof: 9,
-    '<<': 10,
-    '>>': 10,
-    '>>>': 10,
-    '+': 11,
-    '-': 11,
-    '*': 12,
-    '%': 12,
-    '/': 12,
-    '**': 13,
-};
-// Enables parenthesis regardless of precedence
-export const NEEDS_PARENTHESES = 17;
-export const EXPRESSIONS_PRECEDENCE = {
-    // Definitions
-    ArrayExpression: 20,
-    TaggedTemplateExpression: 20,
-    ThisExpression: 20,
-    Identifier: 20,
-    PrivateIdentifier: 20,
-    Literal: 18,
-    TemplateLiteral: 20,
-    Super: 20,
-    SequenceExpression: 20,
-    // Operations
-    MemberExpression: 19,
-    ChainExpression: 19,
-    CallExpression: 19,
-    NewExpression: 19,
-    // Other definitions
-    ArrowFunctionExpression: NEEDS_PARENTHESES,
-    ClassExpression: NEEDS_PARENTHESES,
-    FunctionExpression: NEEDS_PARENTHESES,
-    ObjectExpression: NEEDS_PARENTHESES,
-    // Other operations
-    UpdateExpression: 16,
-    UnaryExpression: 15,
-    AwaitExpression: 15,
-    BinaryExpression: 14,
-    LogicalExpression: 13,
-    ConditionalExpression: 4,
-    AssignmentExpression: 3,
-    YieldExpression: 2,
-    RestElement: 1,
-};
-function formatSequence(state, nodes) {
-    /*
-    Writes into `state` a sequence of `nodes`.
-    */
-    const { generator } = state;
-    state.write('(');
-    if (nodes != null && nodes.length > 0) {
-        generator[nodes[0].type](nodes[0], state);
-        const { length } = nodes;
-        for (let i = 1; i < length; i++) {
-            const param = nodes[i];
-            state.write(', ');
-            generator[param.type](param, state);
-        }
-    }
-    state.write(')');
-}
-function expressionNeedsParenthesis(state, node, parentNode, isRightHand) {
-    const nodePrecedence = state.expressionsPrecedence[node.type];
-    if (nodePrecedence === NEEDS_PARENTHESES) {
-        return true;
-    }
-    const parentNodePrecedence = state.expressionsPrecedence[parentNode.type];
-    if (nodePrecedence !== parentNodePrecedence) {
-        // Different node types
-        return ((!isRightHand &&
-            nodePrecedence === 15 &&
-            parentNodePrecedence === 14 &&
-            parentNode.operator === '**') ||
-            nodePrecedence < parentNodePrecedence);
-    }
-    if (nodePrecedence !== 13 && nodePrecedence !== 14) {
-        // Not a `LogicalExpression` or `BinaryExpression`
-        return false;
-    }
-    if (node.operator === '**' && parentNode.operator === '**') {
-        // Exponentiation operator has right-to-left associativity
-        return !isRightHand;
-    }
-    if (nodePrecedence === 13 &&
-        parentNodePrecedence === 13 &&
-        (node.operator === '??' || parentNode.operator === '??')) {
-        // Nullish coalescing and boolean operators cannot be combined
-        return true;
-    }
-    if (isRightHand) {
-        // Parenthesis are used if both operators have the same precedence
-        return (OPERATOR_PRECEDENCE[node.operator] <=
-            OPERATOR_PRECEDENCE[parentNode.operator]);
-    }
-    return (OPERATOR_PRECEDENCE[node.operator] <
-        OPERATOR_PRECEDENCE[parentNode.operator]);
-}
-function formatExpression(state, node, parentNode, isRightHand) {
-    /*
-    Writes into `state` the provided `node`, adding parenthesis around if the provided `parentNode` needs it. If `node` is a right-hand argument, the provided `isRightHand` parameter should be `true`.
-    */
-    const { generator } = state;
-    if (expressionNeedsParenthesis(state, node, parentNode, isRightHand)) {
-        state.write('(');
-        generator[node.type](node, state);
-        state.write(')');
-    }
-    else {
-        generator[node.type](node, state);
-    }
-}
-function reindent(state, text, indent, lineEnd) {
-    /*
-    Writes into `state` the `text` string reindented with the provided `indent`.
-    */
-    const lines = text.split('\n');
-    const end = lines.length - 1;
-    state.write(lines[0].trim());
-    if (end > 0) {
-        state.write(lineEnd);
-        for (let i = 1; i < end; i++) {
-            state.write(indent + lines[i].trim() + lineEnd);
-        }
-        state.write(indent + lines[end].trim());
-    }
-}
-function formatComments(state, comments, indent, lineEnd) {
-    /*
-    Writes into `state` the provided list of `comments`, with the given `indent` and `lineEnd` strings.
-    Line comments will end with `"\n"` regardless of the value of `lineEnd`.
-    Expects to start on a new unindented line.
-    */
-    const { length } = comments;
-    for (let i = 0; i < length; i++) {
-        const comment = comments[i];
-        state.write(indent);
-        if (comment.type[0] === 'L') {
-            // Line comment
-            state.write('// ' + comment.value.trim() + '\n', comment);
-        }
-        else {
-            // Block comment
-            state.write('/*');
-            reindent(state, comment.value, indent, lineEnd);
-            state.write('*/' + lineEnd);
-        }
-    }
-}
-function hasCallExpression(node) {
-    /*
-    Returns `true` if the provided `node` contains a call expression and `false` otherwise.
-    */
-    let currentNode = node;
-    while (currentNode != null) {
-        const { type } = currentNode;
-        if (type[0] === 'C' && type[1] === 'a') {
-            // Is CallExpression
-            return true;
-        }
-        else if (type[0] === 'M' && type[1] === 'e' && type[2] === 'm') {
-            // Is MemberExpression
-            currentNode = currentNode.object;
-        }
-        else {
-            return false;
-        }
-    }
-}
-function formatVariableDeclaration(state, node) {
-    /*
-    Writes into `state` a variable declaration.
-    */
-    const { generator } = state;
-    const { declarations } = node;
-    state.write(node.kind + ' ');
-    const { length } = declarations;
-    if (length > 0) {
-        generator.VariableDeclarator(declarations[0], state);
-        for (let i = 1; i < length; i++) {
-            state.write(', ');
-            generator.VariableDeclarator(declarations[i], state);
-        }
-    }
-}
-let ForInStatement, FunctionDeclaration, RestElement, BinaryExpression, ArrayExpression, BlockStatement;
-export const GENERATOR = {
-    /*
-    Default generator.
-    */
-    Program(node, state) {
-        const indent = state.indent.repeat(state.indentLevel);
-        const { lineEnd, writeComments } = state;
-        if (writeComments && node.comments != null) {
-            formatComments(state, node.comments, indent, lineEnd);
-        }
-        const statements = node.body;
-        const { length } = statements;
-        for (let i = 0; i < length; i++) {
-            const statement = statements[i];
-            if (writeComments && statement.comments != null) {
-                formatComments(state, statement.comments, indent, lineEnd);
-            }
-            state.write(indent);
-            this[statement.type](statement, state);
-            state.write(lineEnd);
-        }
-        if (writeComments && node.trailingComments != null) {
-            formatComments(state, node.trailingComments, indent, lineEnd);
-        }
-    },
-    BlockStatement: (BlockStatement = function (node, state) {
-        const indent = state.indent.repeat(state.indentLevel++);
-        const { lineEnd, writeComments } = state;
-        const statementIndent = indent + state.indent;
-        state.write('{');
-        const statements = node.body;
-        if (statements != null && statements.length > 0) {
-            state.write(lineEnd);
-            if (writeComments && node.comments != null) {
-                formatComments(state, node.comments, statementIndent, lineEnd);
-            }
-            const { length } = statements;
-            for (let i = 0; i < length; i++) {
-                const statement = statements[i];
-                if (writeComments && statement.comments != null) {
-                    formatComments(state, statement.comments, statementIndent, lineEnd);
-                }
-                state.write(statementIndent);
-                this[statement.type](statement, state);
-                state.write(lineEnd);
-            }
-            state.write(indent);
-        }
-        else {
-            if (writeComments && node.comments != null) {
-                state.write(lineEnd);
-                formatComments(state, node.comments, statementIndent, lineEnd);
-                state.write(indent);
-            }
-        }
-        if (writeComments && node.trailingComments != null) {
-            formatComments(state, node.trailingComments, statementIndent, lineEnd);
-        }
-        state.write('}');
-        state.indentLevel--;
-    }),
-    ClassBody: BlockStatement,
-    StaticBlock(node, state) {
-        state.write('static ');
-        this.BlockStatement(node, state);
-    },
-    EmptyStatement(node, state) {
-        state.write(';');
-    },
-    ExpressionStatement(node, state) {
-        const precedence = state.expressionsPrecedence[node.expression.type];
-        if (precedence === NEEDS_PARENTHESES ||
-            (precedence === 3 && node.expression.left.type[0] === 'O')) {
-            // Should always have parentheses or is an AssignmentExpression to an ObjectPattern
-            state.write('(');
-            this[node.expression.type](node.expression, state);
-            state.write(')');
-        }
-        else {
-            this[node.expression.type](node.expression, state);
-        }
-        state.write(';');
-    },
-    IfStatement(node, state) {
-        state.write('if (');
-        this[node.test.type](node.test, state);
-        state.write(') ');
-        this[node.consequent.type](node.consequent, state);
-        if (node.alternate != null) {
-            state.write(' else ');
-            this[node.alternate.type](node.alternate, state);
-        }
-    },
-    LabeledStatement(node, state) {
-        this[node.label.type](node.label, state);
-        state.write(': ');
-        this[node.body.type](node.body, state);
-    },
-    BreakStatement(node, state) {
-        state.write('break');
-        if (node.label != null) {
-            state.write(' ');
-            this[node.label.type](node.label, state);
-        }
-        state.write(';');
-    },
-    ContinueStatement(node, state) {
-        state.write('continue');
-        if (node.label != null) {
-            state.write(' ');
-            this[node.label.type](node.label, state);
-        }
-        state.write(';');
-    },
-    WithStatement(node, state) {
-        state.write('with (');
-        this[node.object.type](node.object, state);
-        state.write(') ');
-        this[node.body.type](node.body, state);
-    },
-    SwitchStatement(node, state) {
-        const indent = state.indent.repeat(state.indentLevel++);
-        const { lineEnd, writeComments } = state;
-        state.indentLevel++;
-        const caseIndent = indent + state.indent;
-        const statementIndent = caseIndent + state.indent;
-        state.write('switch (');
-        this[node.discriminant.type](node.discriminant, state);
-        state.write(') {' + lineEnd);
-        const { cases: occurences } = node;
-        const { length: occurencesCount } = occurences;
-        for (let i = 0; i < occurencesCount; i++) {
-            const occurence = occurences[i];
-            if (writeComments && occurence.comments != null) {
-                formatComments(state, occurence.comments, caseIndent, lineEnd);
-            }
-            if (occurence.test) {
-                state.write(caseIndent + 'case ');
-                this[occurence.test.type](occurence.test, state);
-                state.write(':' + lineEnd);
-            }
-            else {
-                state.write(caseIndent + 'default:' + lineEnd);
-            }
-            const { consequent } = occurence;
-            const { length: consequentCount } = consequent;
-            for (let i = 0; i < consequentCount; i++) {
-                const statement = consequent[i];
-                if (writeComments && statement.comments != null) {
-                    formatComments(state, statement.comments, statementIndent, lineEnd);
-                }
-                state.write(statementIndent);
-                this[statement.type](statement, state);
-                state.write(lineEnd);
-            }
-        }
-        state.indentLevel -= 2;
-        state.write(indent + '}');
-    },
-    ReturnStatement(node, state) {
-        state.write('return');
-        if (node.argument) {
-            state.write(' ');
-            this[node.argument.type](node.argument, state);
-        }
-        state.write(';');
-    },
-    ThrowStatement(node, state) {
-        state.write('throw ');
-        this[node.argument.type](node.argument, state);
-        state.write(';');
-    },
-    TryStatement(node, state) {
-        state.write('try ');
-        this[node.block.type](node.block, state);
-        if (node.handler) {
-            const { handler } = node;
-            if (handler.param == null) {
-                state.write(' catch ');
-            }
-            else {
-                state.write(' catch (');
-                this[handler.param.type](handler.param, state);
-                state.write(') ');
-            }
-            this[handler.body.type](handler.body, state);
-        }
-        if (node.finalizer) {
-            state.write(' finally ');
-            this[node.finalizer.type](node.finalizer, state);
-        }
-    },
-    WhileStatement(node, state) {
-        state.write('while (');
-        this[node.test.type](node.test, state);
-        state.write(') ');
-        this[node.body.type](node.body, state);
-    },
-    DoWhileStatement(node, state) {
-        state.write('do ');
-        this[node.body.type](node.body, state);
-        state.write(' while (');
-        this[node.test.type](node.test, state);
-        state.write(');');
-    },
-    ForStatement(node, state) {
-        state.write('for (');
-        if (node.init != null) {
-            const { init } = node;
-            if (init.type[0] === 'V') {
-                formatVariableDeclaration(state, init);
-            }
-            else {
-                this[init.type](init, state);
-            }
-        }
-        state.write('; ');
-        if (node.test) {
-            this[node.test.type](node.test, state);
-        }
-        state.write('; ');
-        if (node.update) {
-            this[node.update.type](node.update, state);
-        }
-        state.write(') ');
-        this[node.body.type](node.body, state);
-    },
-    ForInStatement: (ForInStatement = function (node, state) {
-        state.write(`for ${node.await ? 'await ' : ''}(`);
-        const { left } = node;
-        if (left.type[0] === 'V') {
-            formatVariableDeclaration(state, left);
-        }
-        else {
-            this[left.type](left, state);
-        }
-        // Identifying whether node.type is `ForInStatement` or `ForOfStatement`
-        state.write(node.type[3] === 'I' ? ' in ' : ' of ');
-        this[node.right.type](node.right, state);
-        state.write(') ');
-        this[node.body.type](node.body, state);
-    }),
-    ForOfStatement: ForInStatement,
-    DebuggerStatement(node, state) {
-        state.write('debugger;', node);
-    },
-    FunctionDeclaration: (FunctionDeclaration = function (node, state) {
-        state.write((node.async ? 'async ' : '') +
-            (node.generator ? 'function* ' : 'function ') +
-            (node.id ? node.id.name : ''), node);
-        formatSequence(state, node.params);
-        state.write(' ');
-        this[node.body.type](node.body, state);
-    }),
-    FunctionExpression: FunctionDeclaration,
-    VariableDeclaration(node, state) {
-        formatVariableDeclaration(state, node);
-        state.write(';');
-    },
-    VariableDeclarator(node, state) {
-        this[node.id.type](node.id, state);
-        if (node.init != null) {
-            state.write(' = ');
-            this[node.init.type](node.init, state);
-        }
-    },
-    ClassDeclaration(node, state) {
-        state.write('class ' + (node.id ? `${node.id.name} ` : ''), node);
-        if (node.superClass) {
-            state.write('extends ');
-            const { superClass } = node;
-            const { type } = superClass;
-            const precedence = state.expressionsPrecedence[type];
-            if ((type[0] !== 'C' || type[1] !== 'l' || type[5] !== 'E') &&
-                (precedence === NEEDS_PARENTHESES ||
-                    precedence < state.expressionsPrecedence.ClassExpression)) {
-                // Not a ClassExpression that needs parentheses
-                state.write('(');
-                this[node.superClass.type](superClass, state);
-                state.write(')');
-            }
-            else {
-                this[superClass.type](superClass, state);
-            }
-            state.write(' ');
-        }
-        this.ClassBody(node.body, state);
-    },
-    ImportDeclaration(node, state) {
-        state.write('import ');
-        const { specifiers } = node;
-        const { length } = specifiers;
-        // TODO: Once babili is fixed, put this after condition
-        // https://github.com/babel/babili/issues/430
-        let i = 0;
-        if (length > 0) {
-            for (; i < length;) {
-                if (i > 0) {
-                    state.write(', ');
-                }
-                const specifier = specifiers[i];
-                const type = specifier.type[6];
-                if (type === 'D') {
-                    // ImportDefaultSpecifier
-                    state.write(specifier.local.name, specifier);
-                    i++;
-                }
-                else if (type === 'N') {
-                    // ImportNamespaceSpecifier
-                    state.write('* as ' + specifier.local.name, specifier);
-                    i++;
-                }
-                else {
-                    // ImportSpecifier
-                    break;
-                }
-            }
-            if (i < length) {
-                state.write('{');
-                for (;;) {
-                    const specifier = specifiers[i];
-                    const { name } = specifier.imported;
-                    state.write(name, specifier);
-                    if (name !== specifier.local.name) {
-                        state.write(' as ' + specifier.local.name);
-                    }
-                    if (++i < length) {
-                        state.write(', ');
-                    }
-                    else {
-                        break;
-                    }
-                }
-                state.write('}');
-            }
-            state.write(' from ');
-        }
-        this.Literal(node.source, state);
-        state.write(';');
-    },
-    ImportExpression(node, state) {
-        state.write('import(');
-        this[node.source.type](node.source, state);
-        state.write(')');
-    },
-    ExportDefaultDeclaration(node, state) {
-        state.write('export default ');
-        this[node.declaration.type](node.declaration, state);
-        if (state.expressionsPrecedence[node.declaration.type] != null &&
-            node.declaration.type[0] !== 'F') {
-            // All expression nodes except `FunctionExpression`
-            state.write(';');
-        }
-    },
-    ExportNamedDeclaration(node, state) {
-        state.write('export ');
-        if (node.declaration) {
-            this[node.declaration.type](node.declaration, state);
-        }
-        else {
-            state.write('{');
-            const { specifiers } = node, { length } = specifiers;
-            if (length > 0) {
-                for (let i = 0;;) {
-                    const specifier = specifiers[i];
-                    const { name } = specifier.local;
-                    state.write(name, specifier);
-                    if (name !== specifier.exported.name) {
-                        state.write(' as ' + specifier.exported.name);
-                    }
-                    if (++i < length) {
-                        state.write(', ');
-                    }
-                    else {
-                        break;
-                    }
-                }
-            }
-            state.write('}');
-            if (node.source) {
-                state.write(' from ');
-                this.Literal(node.source, state);
-            }
-            state.write(';');
-        }
-    },
-    ExportAllDeclaration(node, state) {
-        if (node.exported != null) {
-            state.write('export * as ' + node.exported.name + ' from ');
-        }
-        else {
-            state.write('export * from ');
-        }
-        this.Literal(node.source, state);
-        state.write(';');
-    },
-    MethodDefinition(node, state) {
-        if (node.static) {
-            state.write('static ');
-        }
-        const kind = node.kind[0];
-        if (kind === 'g' || kind === 's') {
-            // Getter or setter
-            state.write(node.kind + ' ');
-        }
-        if (node.value.async) {
-            state.write('async ');
-        }
-        if (node.value.generator) {
-            state.write('*');
-        }
-        if (node.computed) {
-            state.write('[');
-            this[node.key.type](node.key, state);
-            state.write(']');
-        }
-        else {
-            this[node.key.type](node.key, state);
-        }
-        formatSequence(state, node.value.params);
-        state.write(' ');
-        this[node.value.body.type](node.value.body, state);
-    },
-    ClassExpression(node, state) {
-        this.ClassDeclaration(node, state);
-    },
-    ArrowFunctionExpression(node, state) {
-        state.write(node.async ? 'async ' : '', node);
-        const { params } = node;
-        if (params != null) {
-            // Omit parenthesis if only one named parameter
-            if (params.length === 1 && params[0].type[0] === 'I') {
-                // If params[0].type[0] starts with 'I', it can't be `ImportDeclaration` nor `IfStatement` and thus is `Identifier`
-                state.write(params[0].name, params[0]);
-            }
-            else {
-                formatSequence(state, node.params);
-            }
-        }
-        state.write(' => ');
-        if (node.body.type[0] === 'O') {
-            // Body is an object expression
-            state.write('(');
-            this.ObjectExpression(node.body, state);
-            state.write(')');
-        }
-        else {
-            this[node.body.type](node.body, state);
-        }
-    },
-    ThisExpression(node, state) {
-        state.write('this', node);
-    },
-    Super(node, state) {
-        state.write('super', node);
-    },
-    RestElement: (RestElement = function (node, state) {
-        state.write('...');
-        this[node.argument.type](node.argument, state);
-    }),
-    SpreadElement: RestElement,
-    YieldExpression(node, state) {
-        state.write(node.delegate ? 'yield*' : 'yield');
-        if (node.argument) {
-            state.write(' ');
-            this[node.argument.type](node.argument, state);
-        }
-    },
-    AwaitExpression(node, state) {
-        state.write('await ', node);
-        formatExpression(state, node.argument, node);
-    },
-    TemplateLiteral(node, state) {
-        const { quasis, expressions } = node;
-        state.write('`');
-        const { length } = expressions;
-        for (let i = 0; i < length; i++) {
-            const expression = expressions[i];
-            const quasi = quasis[i];
-            state.write(quasi.value.raw, quasi);
-            state.write('${');
-            this[expression.type](expression, state);
-            state.write('}');
-        }
-        const quasi = quasis[quasis.length - 1];
-        state.write(quasi.value.raw, quasi);
-        state.write('`');
-    },
-    TemplateElement(node, state) {
-        state.write(node.value.raw, node);
-    },
-    TaggedTemplateExpression(node, state) {
-        formatExpression(state, node.tag, node);
-        this[node.quasi.type](node.quasi, state);
-    },
-    ArrayExpression: (ArrayExpression = function (node, state) {
-        state.write('[');
-        if (node.elements.length > 0) {
-            const { elements } = node, { length } = elements;
-            for (let i = 0;;) {
-                const element = elements[i];
-                if (element != null) {
-                    this[element.type](element, state);
-                }
-                if (++i < length) {
-                    state.write(', ');
-                }
-                else {
-                    if (element == null) {
-                        state.write(', ');
-                    }
-                    break;
-                }
-            }
-        }
-        state.write(']');
-    }),
-    ArrayPattern: ArrayExpression,
-    ObjectExpression(node, state) {
-        const indent = state.indent.repeat(state.indentLevel++);
-        const { lineEnd, writeComments } = state;
-        const propertyIndent = indent + state.indent;
-        state.write('{');
-        if (node.properties.length > 0) {
-            state.write(lineEnd);
-            if (writeComments && node.comments != null) {
-                formatComments(state, node.comments, propertyIndent, lineEnd);
-            }
-            const comma = ',' + lineEnd;
-            const { properties } = node, { length } = properties;
-            for (let i = 0;;) {
-                const property = properties[i];
-                if (writeComments && property.comments != null) {
-                    formatComments(state, property.comments, propertyIndent, lineEnd);
-                }
-                state.write(propertyIndent);
-                this[property.type](property, state);
-                if (++i < length) {
-                    state.write(comma);
-                }
-                else {
-                    break;
-                }
-            }
-            state.write(lineEnd);
-            if (writeComments && node.trailingComments != null) {
-                formatComments(state, node.trailingComments, propertyIndent, lineEnd);
-            }
-            state.write(indent + '}');
-        }
-        else if (writeComments) {
-            if (node.comments != null) {
-                state.write(lineEnd);
-                formatComments(state, node.comments, propertyIndent, lineEnd);
-                if (node.trailingComments != null) {
-                    formatComments(state, node.trailingComments, propertyIndent, lineEnd);
-                }
-                state.write(indent + '}');
-            }
-            else if (node.trailingComments != null) {
-                state.write(lineEnd);
-                formatComments(state, node.trailingComments, propertyIndent, lineEnd);
-                state.write(indent + '}');
-            }
-            else {
-                state.write('}');
-            }
-        }
-        else {
-            state.write('}');
-        }
-        state.indentLevel--;
-    },
-    Property(node, state) {
-        if (node.method || node.kind[0] !== 'i') {
-            // Either a method or of kind `set` or `get` (not `init`)
-            this.MethodDefinition(node, state);
-        }
-        else {
-            if (!node.shorthand) {
-                if (node.computed) {
-                    state.write('[');
-                    this[node.key.type](node.key, state);
-                    state.write(']');
-                }
-                else {
-                    this[node.key.type](node.key, state);
-                }
-                state.write(': ');
-            }
-            this[node.value.type](node.value, state);
-        }
-    },
-    PropertyDefinition(node, state) {
-        if (node.static) {
-            state.write('static ');
-        }
-        if (node.computed) {
-            state.write('[');
-        }
-        this[node.key.type](node.key, state);
-        if (node.computed) {
-            state.write(']');
-        }
-        if (node.value == null) {
-            if (node.key.type[0] !== 'F') {
-                state.write(';');
-            }
-            return;
-        }
-        state.write(' = ');
-        this[node.value.type](node.value, state);
-        state.write(';');
-    },
-    ObjectPattern(node, state) {
-        state.write('{');
-        if (node.properties.length > 0) {
-            const { properties } = node, { length } = properties;
-            for (let i = 0;;) {
-                this[properties[i].type](properties[i], state);
-                if (++i < length) {
-                    state.write(', ');
-                }
-                else {
-                    break;
-                }
-            }
-        }
-        state.write('}');
-    },
-    SequenceExpression(node, state) {
-        formatSequence(state, node.expressions);
-    },
-    UnaryExpression(node, state) {
-        if (node.prefix) {
-            const { operator, argument, argument: { type }, } = node;
-            state.write(operator);
-            const needsParentheses = expressionNeedsParenthesis(state, argument, node);
-            if (!needsParentheses &&
-                (operator.length > 1 ||
-                    (type[0] === 'U' &&
-                        (type[1] === 'n' || type[1] === 'p') &&
-                        argument.prefix &&
-                        argument.operator[0] === operator &&
-                        (operator === '+' || operator === '-')))) {
-                // Large operator or argument is UnaryExpression or UpdateExpression node
-                state.write(' ');
-            }
-            if (needsParentheses) {
-                state.write(operator.length > 1 ? ' (' : '(');
-                this[type](argument, state);
-                state.write(')');
-            }
-            else {
-                this[type](argument, state);
-            }
-        }
-        else {
-            // FIXME: This case never occurs
-            this[node.argument.type](node.argument, state);
-            state.write(node.operator);
-        }
-    },
-    UpdateExpression(node, state) {
-        // Always applied to identifiers or members, no parenthesis check needed
-        if (node.prefix) {
-            state.write(node.operator);
-            this[node.argument.type](node.argument, state);
-        }
-        else {
-            this[node.argument.type](node.argument, state);
-            state.write(node.operator);
-        }
-    },
-    AssignmentExpression(node, state) {
-        this[node.left.type](node.left, state);
-        state.write(' ' + node.operator + ' ');
-        this[node.right.type](node.right, state);
-    },
-    AssignmentPattern(node, state) {
-        this[node.left.type](node.left, state);
-        state.write(' = ');
-        this[node.right.type](node.right, state);
-    },
-    BinaryExpression: (BinaryExpression = function (node, state) {
-        const isIn = node.operator === 'in';
-        if (isIn) {
-            // Avoids confusion in `for` loops initializers
-            state.write('(');
-        }
-        formatExpression(state, node.left, node, false);
-        state.write(' ' + node.operator + ' ');
-        formatExpression(state, node.right, node, true);
-        if (isIn) {
-            state.write(')');
-        }
-    }),
-    LogicalExpression: BinaryExpression,
-    ConditionalExpression(node, state) {
-        const { test } = node;
-        const precedence = state.expressionsPrecedence[test.type];
-        if (precedence === NEEDS_PARENTHESES ||
-            precedence <= state.expressionsPrecedence.ConditionalExpression) {
-            state.write('(');
-            this[test.type](test, state);
-            state.write(')');
-        }
-        else {
-            this[test.type](test, state);
-        }
-        state.write(' ? ');
-        this[node.consequent.type](node.consequent, state);
-        state.write(' : ');
-        this[node.alternate.type](node.alternate, state);
-    },
-    NewExpression(node, state) {
-        state.write('new ');
-        const precedence = state.expressionsPrecedence[node.callee.type];
-        if (precedence === NEEDS_PARENTHESES ||
-            precedence < state.expressionsPrecedence.CallExpression ||
-            hasCallExpression(node.callee)) {
-            state.write('(');
-            this[node.callee.type](node.callee, state);
-            state.write(')');
-        }
-        else {
-            this[node.callee.type](node.callee, state);
-        }
-        formatSequence(state, node['arguments']);
-    },
-    CallExpression(node, state) {
-        const precedence = state.expressionsPrecedence[node.callee.type];
-        if (precedence === NEEDS_PARENTHESES ||
-            precedence < state.expressionsPrecedence.CallExpression) {
-            state.write('(');
-            this[node.callee.type](node.callee, state);
-            state.write(')');
-        }
-        else {
-            this[node.callee.type](node.callee, state);
-        }
-        if (node.optional) {
-            state.write('?.');
-        }
-        formatSequence(state, node['arguments']);
-    },
-    ChainExpression(node, state) {
-        this[node.expression.type](node.expression, state);
-    },
-    MemberExpression(node, state) {
-        const precedence = state.expressionsPrecedence[node.object.type];
-        if (precedence === NEEDS_PARENTHESES ||
-            precedence < state.expressionsPrecedence.MemberExpression) {
-            state.write('(');
-            this[node.object.type](node.object, state);
-            state.write(')');
-        }
-        else {
-            this[node.object.type](node.object, state);
-        }
-        if (node.computed) {
-            if (node.optional) {
-                state.write('?.');
-            }
-            state.write('[');
-            this[node.property.type](node.property, state);
-            state.write(']');
-        }
-        else {
-            if (node.optional) {
-                state.write('?.');
-            }
-            else {
-                state.write('.');
-            }
-            this[node.property.type](node.property, state);
-        }
-    },
-    MetaProperty(node, state) {
-        state.write(node.meta.name + '.' + node.property.name, node);
-    },
-    Identifier(node, state) {
-        state.write(node.name, node);
-    },
-    PrivateIdentifier(node, state) {
-        state.write(`#${node.name}`, node);
-    },
-    Literal(node, state) {
-        if (node.raw != null) {
-            // Non-standard property
-            state.write(node.raw, node);
-        }
-        else if (node.regex != null) {
-            this.RegExpLiteral(node, state);
-        }
-        else if (node.bigint != null) {
-            state.write(node.bigint + 'n', node);
-        }
-        else {
-            state.write(stringify(node.value), node);
-        }
-    },
-    RegExpLiteral(node, state) {
-        const { regex } = node;
-        state.write(`/${regex.pattern}/${regex.flags}`, node);
-    },
-};
-const EMPTY_OBJECT = {};
-/*
-DEPRECATED: Alternate export of `GENERATOR`.
-*/
-export const baseGenerator = GENERATOR;
-class State {
-    constructor(options) {
-        const setup = options == null ? EMPTY_OBJECT : options;
-        this.output = '';
-        // Functional options
-        if (setup.output != null) {
-            this.output = setup.output;
-            this.write = this.writeToStream;
-        }
-        else {
-            this.output = '';
-        }
-        this.generator = setup.generator != null ? setup.generator : GENERATOR;
-        this.expressionsPrecedence =
-            setup.expressionsPrecedence != null
-                ? setup.expressionsPrecedence
-                : EXPRESSIONS_PRECEDENCE;
-        // Formating setup
-        this.indent = setup.indent != null ? setup.indent : '  ';
-        this.lineEnd = setup.lineEnd != null ? setup.lineEnd : '\n';
-        this.indentLevel =
-            setup.startingIndentLevel != null ? setup.startingIndentLevel : 0;
-        this.writeComments = setup.comments ? setup.comments : false;
-        // Source map
-        if (setup.sourceMap != null) {
-            this.write =
-                setup.output == null ? this.writeAndMap : this.writeToStreamAndMap;
-            this.sourceMap = setup.sourceMap;
-            this.line = 1;
-            this.column = 0;
-            this.lineEndSize = this.lineEnd.split('\n').length - 1;
-            this.mapping = {
-                original: null,
-                // Uses the entire state to avoid generating ephemeral objects
-                generated: this,
-                name: undefined,
-                source: setup.sourceMap.file || setup.sourceMap._file,
-            };
-        }
-    }
-    write(code) {
-        this.output += code;
-    }
-    writeToStream(code) {
-        this.output.write(code);
-    }
-    writeAndMap(code, node) {
-        this.output += code;
-        this.map(code, node);
-    }
-    writeToStreamAndMap(code, node) {
-        this.output.write(code);
-        this.map(code, node);
-    }
-    map(code, node) {
-        if (node != null) {
-            const { type } = node;
-            if (type[0] === 'L' && type[2] === 'n') {
-                // LineComment
-                this.column = 0;
-                this.line++;
-                return;
-            }
-            if (node.loc != null) {
-                const { mapping } = this;
-                mapping.original = node.loc.start;
-                mapping.name = node.name;
-                this.sourceMap.addMapping(mapping);
-            }
-            if ((type[0] === 'T' && type[8] === 'E') ||
-                (type[0] === 'L' && type[1] === 'i' && typeof node.value === 'string')) {
-                // TemplateElement or Literal string node
-                const { length } = code;
-                let { column, line } = this;
-                for (let i = 0; i < length; i++) {
-                    if (code[i] === '\n') {
-                        column = 0;
-                        line++;
-                    }
-                    else {
-                        column++;
-                    }
-                }
-                this.column = column;
-                this.line = line;
-                return;
-            }
-        }
-        const { length } = code;
-        const { lineEnd } = this;
-        if (length > 0) {
-            if (this.lineEndSize > 0 &&
-                (lineEnd.length === 1
-                    ? code[length - 1] === lineEnd
-                    : code.endsWith(lineEnd))) {
-                this.line += this.lineEndSize;
-                this.column = 0;
-            }
-            else {
-                this.column += length;
-            }
-        }
-    }
-    toString() {
-        return this.output;
-    }
-}
-export function generate(node, options) {
-    /*
-    Returns a string representing the rendered code of the provided AST `node`.
-    The `options` are:
-  
-    - `indent`: string to use for indentation (defaults to `␣␣`)
-    - `lineEnd`: string to use for line endings (defaults to `\n`)
-    - `startingIndentLevel`: indent level to start from (defaults to `0`)
-    - `comments`: generate comments if `true` (defaults to `false`)
-    - `output`: output stream to write the rendered code to (defaults to `null`)
-    - `generator`: custom code generator (defaults to `GENERATOR`)
-    - `expressionsPrecedence`: custom map of node types and their precedence level (defaults to `EXPRESSIONS_PRECEDENCE`)
-    */
-    const state = new State(options);
-    // Travel through the AST node and generate the code
-    state.generator[node.type](node, state);
-    return state.output;
-}