const std = @import("std");
const logger = @import("logger.zig");
const js_lexer = @import("js_lexer.zig");
const importRecord = @import("import_record.zig");
const js_ast = @import("js_ast.zig");
const options = @import("options.zig");
const alloc = @import("alloc.zig");

const fs = @import("fs.zig");
usingnamespace @import("global.zig");
usingnamespace @import("ast/base.zig");
usingnamespace js_ast.G;

const expect = std.testing.expect;
const ImportKind = importRecord.ImportKind;
const BindingNodeIndex = js_ast.BindingNodeIndex;

const StmtNodeIndex = js_ast.StmtNodeIndex;
const ExprNodeIndex = js_ast.ExprNodeIndex;
const ExprNodeList = js_ast.ExprNodeList;
const StmtNodeList = js_ast.StmtNodeList;
const BindingNodeList = js_ast.BindingNodeList;
const assert = std.debug.assert;

const LocRef = js_ast.LocRef;
const S = js_ast.S;
const B = js_ast.B;
const G = js_ast.G;
const T = js_lexer.T;
const E = js_ast.E;
const Stmt = js_ast.Stmt;
const Expr = js_ast.Expr;
const Binding = js_ast.Binding;
const Symbol = js_ast.Symbol;
const Level = js_ast.Op.Level;
const Op = js_ast.Op;
const Scope = js_ast.Scope;
const locModuleScope = logger.Loc.Empty;
const Lexer = js_lexer.Lexer;

fn JSONLikeParser(opts: js_lexer.JSONOptions) type {
    return struct {
        lexer: Lexer,
        source: *const logger.Source,
        log: *logger.Log,
        allocator: *std.mem.Allocator,

        pub fn init(allocator: *std.mem.Allocator, source: *const logger.Source, log: *logger.Log) !Parser {
            if (opts.allow_comments) {
                return Parser{
                    .lexer = try Lexer.initTSConfig(log, source, allocator),
                    .allocator = allocator,
                    .log = log,
                    .source = source,
                };
            } else {
                return Parser{
                    .lexer = try Lexer.initJSON(log, source, allocator),
                    .allocator = allocator,
                    .log = log,
                    .source = source,
                };
            }
        }

        const Parser = @This();

        pub fn e(p: *Parser, t: anytype, loc: logger.Loc) Expr {
            const Type = @TypeOf(t);
            if (@typeInfo(Type) == .Pointer) {
                return Expr.init(std.meta.Child(Type), t, loc);
            } else {
                return Expr.alloc(p.allocator, Type, t, loc);
            }
        }
        pub fn parseExpr(p: *Parser, comptime maybe_auto_quote: bool) anyerror!Expr {
            const loc = p.lexer.loc();

            switch (p.lexer.token) {
                .t_false => {
                    try p.lexer.next();
                    return p.e(E.Boolean{
                        .value = false,
                    }, loc);
                },
                .t_true => {
                    try p.lexer.next();
                    return p.e(E.Boolean{
                        .value = true,
                    }, loc);
                },
                .t_null => {
                    try p.lexer.next();
                    return p.e(E.Null{}, loc);
                },
                .t_string_literal => {
                    var str: E.String = p.lexer.toEString();

                    try p.lexer.next();
                    return p.e(str, loc);
                },
                .t_numeric_literal => {
                    const value = p.lexer.number;
                    try p.lexer.next();
                    return p.e(E.Number{ .value = value }, loc);
                },
                .t_minus => {
                    try p.lexer.next();
                    const value = p.lexer.number;
                    try p.lexer.expect(.t_numeric_literal);
                    return p.e(E.Number{ .value = -value }, loc);
                },
                .t_open_bracket => {
                    try p.lexer.next();
                    var is_single_line = !p.lexer.has_newline_before;
                    var exprs = std.ArrayList(Expr).init(p.allocator);

                    while (p.lexer.token != .t_close_bracket) {
                        if (exprs.items.len > 0) {
                            if (p.lexer.has_newline_before) {
                                is_single_line = false;
                            }

                            if (!try p.parseMaybeTrailingComma(.t_close_bracket)) {
                                break;
                            }

                            if (p.lexer.has_newline_before) {
                                is_single_line = false;
                            }
                        }

                        exprs.append(try p.parseExpr(false)) catch unreachable;
                    }

                    if (p.lexer.has_newline_before) {
                        is_single_line = false;
                    }
                    try p.lexer.expect(.t_close_bracket);
                    return p.e(E.Array{ .items = exprs.toOwnedSlice() }, loc);
                },
                .t_open_brace => {
                    try p.lexer.next();
                    var is_single_line = !p.lexer.has_newline_before;
                    var properties = std.ArrayList(G.Property).init(p.allocator);
                    var duplicates = std.AutoHashMap(u64, void).init(p.allocator);
                    defer duplicates.deinit();

                    while (p.lexer.token != .t_close_brace) {
                        if (properties.items.len > 0) {
                            if (p.lexer.has_newline_before) {
                                is_single_line = false;
                            }
                            if (!try p.parseMaybeTrailingComma(.t_close_brace)) {
                                break;
                            }
                            if (p.lexer.has_newline_before) {
                                is_single_line = false;
                            }
                        }

                        var str = p.lexer.toEString();
                        const hash_key = str.hash();
                        const duplicate_get_or_put = duplicates.getOrPut(hash_key) catch unreachable;
                        duplicate_get_or_put.key_ptr.* = hash_key;

                        var key_range = p.lexer.range();
                        // Warn about duplicate keys
                        if (duplicate_get_or_put.found_existing) {
                            p.log.addRangeWarningFmt(p.source, key_range, p.allocator, "Duplicate key \"{s}\" in object literal", .{p.lexer.string_literal_slice}) catch unreachable;
                        }

                        var key = p.e(str, key_range.loc);
                        try p.lexer.expect(.t_string_literal);

                        try p.lexer.expect(.t_colon);
                        var value = try p.parseExpr(false);
                        properties.append(G.Property{ .key = key, .value = value }) catch unreachable;
                    }

                    if (p.lexer.has_newline_before) {
                        is_single_line = false;
                    }
                    try p.lexer.expect(.t_close_brace);
                    return p.e(E.Object{
                        .properties = properties.toOwnedSlice(),
                        .is_single_line = is_single_line,
                    }, loc);
                },
                else => {
                    if (comptime maybe_auto_quote) {
                        p.lexer = try Lexer.initJSON(p.log, p.source, p.allocator);
                        try p.lexer.parseStringLiteral(0);
                        return p.parseExpr(false);
                    }

                    try p.lexer.unexpected();
                    if (comptime isDebug) {
                        @breakpoint();
                    }
                    return error.ParserError;
                },
            }
        }

        pub fn parseMaybeTrailingComma(p: *Parser, closer: T) !bool {
            const comma_range = p.lexer.range();
            try p.lexer.expect(.t_comma);

            if (p.lexer.token == closer) {
                if (!opts.allow_trailing_commas) {
                    p.log.addRangeError(p.source, comma_range, "JSON does not support trailing commas") catch unreachable;
                }
                return false;
            }

            return true;
        }
    };
}

const JSONParser = JSONLikeParser(js_lexer.JSONOptions{});
const DotEnvJSONParser = JSONLikeParser(js_lexer.JSONOptions{
    .starts_with_string = true,
    .allow_trailing_commas = true,
});
const TSConfigParser = JSONLikeParser(js_lexer.JSONOptions{ .allow_comments = true, .allow_trailing_commas = true });
var empty_string = E.String{ .utf8 = "" };
var empty_object = E.Object{};
var empty_array = E.Array{ .items = &[_]ExprNodeIndex{} };
var empty_string_data = Expr.Data{ .e_string = &empty_string };
var empty_object_data = Expr.Data{ .e_object = &empty_object };
var empty_array_data = Expr.Data{ .e_array = &empty_array };

pub fn ParseJSON(source: *const logger.Source, log: *logger.Log, allocator: *std.mem.Allocator) !Expr {
    var parser = try JSONParser.init(allocator, source, log);
    switch (source.contents.len) {
        // This is to be consisntent with how disabled JS files are handled
        0 => {
            return Expr{ .loc = logger.Loc{ .start = 0 }, .data = empty_object_data };
        },
        // This is a fast pass I guess
        2 => {
            if (strings.eqlComptime(source.contents[0..1], "\"\"") or strings.eqlComptime(source.contents[0..1], "''")) {
                return Expr{ .loc = logger.Loc{ .start = 0 }, .data = empty_string_data };
            } else if (strings.eqlComptime(source.contents[0..1], "{}")) {
                return Expr{ .loc = logger.Loc{ .start = 0 }, .data = empty_object_data };
            } else if (strings.eqlComptime(source.contents[0..1], "[]")) {
                return Expr{ .loc = logger.Loc{ .start = 0 }, .data = empty_array_data };
            }
        },
        else => {},
    }

    return try parser.parseExpr(false);
}

pub const JSONParseResult = struct {
    expr: Expr,
    tag: Tag,

    pub const Tag = enum {
        expr,
        ascii,
        empty,
    };
};

pub fn ParseJSONForBundling(source: *const logger.Source, log: *logger.Log, allocator: *std.mem.Allocator) !JSONParseResult {
    var parser = try JSONParser.init(allocator, source, log);
    switch (source.contents.len) {
        // This is to be consisntent with how disabled JS files are handled
        0 => {
            return JSONParseResult{ .expr = Expr{ .loc = logger.Loc{ .start = 0 }, .data = empty_object_data }, .tag = .empty };
        },
        // This is a fast pass I guess
        2 => {
            if (strings.eqlComptime(source.contents[0..1], "\"\"") or strings.eqlComptime(source.contents[0..1], "''")) {
                return JSONParseResult{ .expr = Expr{ .loc = logger.Loc{ .start = 0 }, .data = empty_string_data }, .tag = .expr };
            } else if (strings.eqlComptime(source.contents[0..1], "{}")) {
                return JSONParseResult{ .expr = Expr{ .loc = logger.Loc{ .start = 0 }, .data = empty_object_data }, .tag = .expr };
            } else if (strings.eqlComptime(source.contents[0..1], "[]")) {
                return JSONParseResult{ .expr = Expr{ .loc = logger.Loc{ .start = 0 }, .data = empty_array_data }, .tag = .expr };
            }
        },
        else => {},
    }

    const result = try parser.parseExpr(false);
    return JSONParseResult{
        .tag = if (parser.lexer.is_ascii_only) JSONParseResult.Tag.ascii else JSONParseResult.Tag.expr,
        .expr = result,
    };
}

// threadlocal var env_json_auto_quote_buffer: MutableString = undefined;
// threadlocal var env_json_auto_quote_buffer_loaded: bool = false;
pub fn ParseEnvJSON(source: *const logger.Source, log: *logger.Log, allocator: *std.mem.Allocator) !Expr {
    var parser = try DotEnvJSONParser.init(allocator, source, log);
    switch (source.contents.len) {
        // This is to be consisntent with how disabled JS files are handled
        0 => {
            return Expr{ .loc = logger.Loc{ .start = 0 }, .data = empty_object_data };
        },
        // This is a fast pass I guess
        2 => {
            if (strings.eqlComptime(source.contents[0..1], "\"\"") or strings.eqlComptime(source.contents[0..1], "''")) {
                return Expr{ .loc = logger.Loc{ .start = 0 }, .data = empty_string_data };
            } else if (strings.eqlComptime(source.contents[0..1], "{}")) {
                return Expr{ .loc = logger.Loc{ .start = 0 }, .data = empty_object_data };
            } else if (strings.eqlComptime(source.contents[0..1], "[]")) {
                return Expr{ .loc = logger.Loc{ .start = 0 }, .data = empty_array_data };
            }
        },
        else => {},
    }

    switch (source.contents[0]) {
        '{', '[', '0'...'9', '"', '\'' => {
            return try parser.parseExpr(false);
        },
        else => {
            switch (parser.lexer.token) {
                .t_true => {
                    return Expr{ .loc = logger.Loc{ .start = 0 }, .data = .{ .e_boolean = E.Boolean{ .value = true } } };
                },
                .t_false => {
                    return Expr{ .loc = logger.Loc{ .start = 0 }, .data = .{ .e_boolean = E.Boolean{ .value = false } } };
                },
                .t_null => {
                    return Expr{ .loc = logger.Loc{ .start = 0 }, .data = .{ .e_null = E.Null{} } };
                },
                .t_identifier => {
                    if (strings.eqlComptime(parser.lexer.identifier, "undefined")) {
                        return Expr{ .loc = logger.Loc{ .start = 0 }, .data = .{ .e_undefined = E.Undefined{} } };
                    }

                    return try parser.parseExpr(true);
                },
                else => {
                    return try parser.parseExpr(true);
                },
            }
        },
    }
}

pub fn ParseTSConfig(source: *const logger.Source, log: *logger.Log, allocator: *std.mem.Allocator) !Expr {
    switch (source.contents.len) {
        // This is to be consisntent with how disabled JS files are handled
        0 => {
            return Expr{ .loc = logger.Loc{ .start = 0 }, .data = empty_object_data };
        },
        // This is a fast pass I guess
        2 => {
            if (strings.eqlComptime(source.contents[0..1], "\"\"") or strings.eqlComptime(source.contents[0..1], "''")) {
                return Expr{ .loc = logger.Loc{ .start = 0 }, .data = empty_string_data };
            } else if (strings.eqlComptime(source.contents[0..1], "{}")) {
                return Expr{ .loc = logger.Loc{ .start = 0 }, .data = empty_object_data };
            } else if (strings.eqlComptime(source.contents[0..1], "[]")) {
                return Expr{ .loc = logger.Loc{ .start = 0 }, .data = empty_array_data };
            }
        },
        else => {},
    }

    var parser = try TSConfigParser.init(allocator, source, log);

    return parser.parseExpr(false);
}

const duplicateKeyJson = "{ \"name\": \"valid\", \"name\": \"invalid\" }";

const js_printer = @import("js_printer.zig");
const renamer = @import("renamer.zig");
const SymbolList = [][]Symbol;

fn expectPrintedJSON(_contents: string, expected: string) !void {
    var contents = alloc.dynamic.alloc(u8, _contents.len + 1) catch unreachable;
    std.mem.copy(u8, contents, _contents);
    contents[contents.len - 1] = ';';
    var log = logger.Log.init(alloc.dynamic);
    defer log.msgs.deinit();

    var source = logger.Source.initPathString(
        "source.json",
        contents,
    );
    const expr = try ParseJSON(&source, &log, alloc.dynamic);
    var stmt = Stmt.alloc(alloc.dynamic, S.SExpr{ .value = expr }, logger.Loc{ .start = 0 });

    var part = js_ast.Part{
        .stmts = &([_]Stmt{stmt}),
    };
    const tree = js_ast.Ast.initTest(&([_]js_ast.Part{part}));
    var symbols: SymbolList = &([_][]Symbol{tree.symbols});
    var symbol_map = js_ast.Symbol.Map.initList(symbols);
    if (log.msgs.items.len > 0) {
        Global.panic("--FAIL--\nExpr {s}\nLog: {s}\n--FAIL--", .{ expr, log.msgs.items[0].data.text });
    }
    var linker = @import("linker.zig").Linker{};

    const result = js_printer.printAst(alloc.dynamic, tree, symbol_map, &source, true, js_printer.Options{ .to_module_ref = Ref{ .inner_index = 0 } }, &linker) catch unreachable;

    var js = result.js;

    if (js.len > 1) {
        while (js[js.len - 1] == '\n') {
            js = js[0 .. js.len - 1];
        }

        if (js[js.len - 1] == ';') {
            js = js[0 .. js.len - 1];
        }
    }

    std.testing.expectEqualStrings(expected, js);
}

test "ParseJSON" {
    try alloc.setup(default_allocator);
    try expectPrintedJSON("true", "true");
    try expectPrintedJSON("false", "false");
    try expectPrintedJSON("1", "1");
    try expectPrintedJSON("10", "10");
    try expectPrintedJSON("100", "100");
    try expectPrintedJSON("100.1", "100.1");
    try expectPrintedJSON("19.1", "19.1");
    try expectPrintedJSON("19.12", "19.12");
    try expectPrintedJSON("3.4159820837456", "3.4159820837456");
    try expectPrintedJSON("-10000.25", "-10000.25");
    try expectPrintedJSON("\"hi\"", "\"hi\"");
    try expectPrintedJSON("{\"hi\": 1, \"hey\": \"200\", \"boom\": {\"yo\": true}}", "({\"hi\": 1, \"hey\": \"200\", \"boom\": {\"yo\": true}})");
    try expectPrintedJSON("{\"hi\": \"hey\"}", "({hi: \"hey\"})");
    try expectPrintedJSON("{\"hi\": [\"hey\", \"yo\"]}", "({hi:[\"hey\",\"yo\"]})");
    // TODO: emoji?
}

test "ParseJSON DuplicateKey warning" {
    alloc.setup(std.heap.page_allocator) catch unreachable;
    var log = logger.Log.init(alloc.dynamic);

    var source = logger.Source.initPathString(
        "package.json",
        duplicateKeyJson,
    );
    const expr = try ParseJSON(&source, &log, alloc.dynamic);

    const tag = @as(Expr.Tag, expr.data);
    expect(tag == .e_object);
    const object = expr.data.e_object;
    std.testing.expectEqual(@as(usize, 2), object.properties.len);
    const name1 = object.properties[0];
    expect(name1.key != null);
    expect(name1.value != null);
    expect(Expr.Tag.e_string == @as(Expr.Tag, name1.value.?.data));
    expect(Expr.Tag.e_string == @as(Expr.Tag, name1.key.?.data));
    expect(strings.eqlUtf16("name", name1.key.?.data.e_string.value));
    expect(strings.eqlUtf16("valid", name1.value.?.data.e_string.value));

    const name2 = object.properties[1];
    expect(name2.key != null);
    expect(name2.value != null);
    expect(Expr.Tag.e_string == @as(Expr.Tag, name2.value.?.data));
    expect(Expr.Tag.e_string == @as(Expr.Tag, name2.key.?.data));
    expect(strings.eqlUtf16("name", name2.key.?.data.e_string.value));
    std.testing.expectEqualStrings("invalid", try name2.value.?.data.e_string.string(alloc.dynamic));

    std.testing.expectEqual(@as(usize, 1), log.msgs.items.len);
}
g'>streaming</option>
<option value='telemetry-audit-1'>telemetry-audit-1</option>
<option value='test/new-integrations-demo'>test/new-integrations-demo</option>
<option value='test/new-ssr-demo'>test/new-ssr-demo</option>
<option value='top-level-exports-integrations'>top-level-exports-integrations</option>
<option value='ts-in-hoisted-script'>ts-in-hoisted-script</option>
<option value='ts-no-err'>ts-no-err</option>
<option value='upd-vite-vendored'>upd-vite-vendored</option>
<option value='upgrade-deps'>upgrade-deps</option>
<option value='v1-beta'>v1-beta</option>
<option value='vercel-test'>vercel-test</option>
<option value='vite-fork'>vite-fork</option>
<option value='vscode-astro-global'>vscode-astro-global</option>
<option value='vt-follow-redirects'>vt-follow-redirects</option>
<option value='warn-exp-flag'>warn-exp-flag</option>
<option value='win'>win</option>
<option value='windows-tests-beta'>windows-tests-beta</option>
<option value='wip-assets'>wip-assets</option>
<option value='wip-component-api-2'>wip-component-api-2</option>
<option value='wip-docs-components'>wip-docs-components</option>
<option value='wip-docs-reference-gen'>wip-docs-reference-gen</option>
<option value='wip-fetch-cache'>wip-fetch-cache</option>
<option value='wip-fun-flags'>wip-fun-flags</option>
<option value='wip-icons'>wip-icons</option>
<option value='wip-logging'>wip-logging</option>
<option value='wip-logging-saved'>wip-logging-saved</option>
<option value='wip-mdc'>wip-mdc</option>
<option value='wip-mdx-to-astro-js'>wip-mdx-to-astro-js</option>
<option value='wip-preview-command-integrations'>wip-preview-command-integrations</option>
<option value='wip-setup-content'>wip-setup-content</option>
<option value='wip-smoke'>wip-smoke</option>
<option value='wip-speed-up-markdown'>wip-speed-up-markdown</option>
<option value='wip-stage'>wip-stage</option>
<option value='wip/react-19-test'>wip/react-19-test</option>
</select> <input type='submit' value='switch'/></form></td></tr>
<tr><td class='sub'>Unnamed repository; edit this file 'description' to name the repository.</td><td class='sub right'></td></tr></table>
<table class='tabs'><tr><td>
<a href='/ansg191/astro/?h=@astrojs/renderer-vue@0.1.9'>summary</a><a href='/ansg191/astro/refs/?h=@astrojs/renderer-vue@0.1.9'>refs</a><a class='active' href='/ansg191/astro/log/examples/framework-react/src?h=@astrojs/renderer-vue@0.1.9&amp;follow=1'>log</a><a href='/ansg191/astro/tree/examples/framework-react/src?h=@astrojs/renderer-vue@0.1.9'>tree</a><a href='/ansg191/astro/commit/examples/framework-react/src?h=@astrojs/renderer-vue@0.1.9&amp;follow=1'>commit</a><a href='/ansg191/astro/diff/examples/framework-react/src?h=@astrojs/renderer-vue@0.1.9&amp;follow=1'>diff</a></td><td class='form'><form class='right' method='get' action='/ansg191/astro/log/examples/framework-react/src'>
<input type='hidden' name='h' value='@astrojs/renderer-vue@0.1.9'/><select name='qt'>
<option value='grep'>log msg</option>
<option value='author'>author</option>
<option value='committer'>committer</option>
<option value='range'>range</option>
</select>
<input class='txt' type='search' size='10' name='q' value=''/>
<input type='submit' value='search'/>
</form>
</td></tr></table>
<div class='path'>path: <a href='/ansg191/astro/log/?h=@astrojs/renderer-vue@0.1.9&amp;follow=1'>root</a>/<a href='/ansg191/astro/log/examples?h=@astrojs/renderer-vue@0.1.9&amp;follow=1'>examples</a>/<a href='/ansg191/astro/log/examples/framework-react?h=@astrojs/renderer-vue@0.1.9&amp;follow=1'>framework-react</a>/<a href='/ansg191/astro/log/examples/framework-react/src?h=@astrojs/renderer-vue@0.1.9&amp;follow=1'>src</a> (<a href='/ansg191/astro/log/examples/framework-react/src?h=@astrojs/renderer-vue@0.1.9'>unfollow</a>)</div><div class='content'><table class='list nowrap'><tr class='nohover'><th class='left'>Age</th><th class='left'>Commit message (<a href='/ansg191/astro/log/examples/framework-react/src?h=@astrojs/renderer-vue@0.1.9&amp;showmsg=1&amp;follow=1'>Expand</a>)</th><th class='left'>Author</th><th class='left'>Files</th><th class='left'>Lines</th></tr>
<tr><td><span title='2021-10-14 15:08:07 -0400'>2021-10-14</span></td><td><a href='/ansg191/astro/commit/scripts/stats/stats.csv?h=@astrojs/renderer-vue@0.1.9&amp;id=31d068801622e8a01fbedf7a59b0be8efe47bc3a&amp;follow=1'>Expose Vue component names for devtools (#1512)</a></td><td><img src='//www.gravatar.com/avatar/4791c3ded91a738f6d4bb33471d269f4?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> Levi
</td><td>3</td><td><span class='deletions'>-3</span>/<span class='insertions'>+10</span></td></tr>
<tr><td><span title='2021-10-14 14:40:33 -0400'>2021-10-14</span></td><td><a href='/ansg191/astro/commit/examples/blog-multiple-authors/src/pages/index.astro?h=@astrojs/renderer-vue@0.1.9&amp;id=32dbf68247720c7a9c81a55d29cf763d1e14a801&amp;follow=1'>Fix type error in blog-multiple-authors example (#1553)</a></td><td><img src='//www.gravatar.com/avatar/f913899c6f1d94d41fc5577ae2f985a3?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> Yoshiaki Togami
</td><td>4</td><td><span class='deletions'>-4</span>/<span class='insertions'>+9</span></td></tr>
<tr><td><span title='2021-10-14 12:25:46 -0600'>2021-10-14</span></td><td><a href='/ansg191/astro/commit/www/src/components/Sponsors.astro?h=@astrojs/renderer-vue@0.1.9&amp;id=7e4f91db609f43b54070518ab099f643f331f445&amp;follow=1'>Add Vercel sponsorship logo (#1555)</a></td><td><img src='//www.gravatar.com/avatar/57d4699c286f6169906cfe54ad9ac96c?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> Drew Powers
</td><td>8</td><td><span class='deletions'>-48</span>/<span class='insertions'>+60</span></td></tr>
<tr><td><span title='2021-10-14 14:09:02 -0400'>2021-10-14</span></td><td><a href='/ansg191/astro/commit/docs/src/pages/installation.md?h=@astrojs/renderer-vue@0.1.9&amp;id=59f9201774322cc1351c2c81946d0121a218084b&amp;follow=1'>Include pnpm example on "Installation" page (#1554)</a></td><td><img src='//www.gravatar.com/avatar/3fb6186f441716d4360e39f942652998?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> Henrique Borges
</td><td>1</td><td><span class='deletions'>-0</span>/<span class='insertions'>+5</span></td></tr>
<tr><td><span title='2021-10-14 08:33:58 -0400'>2021-10-14</span></td><td><a href='/ansg191/astro/commit/examples/docs/src/components/HeadSEO.astro?h=@astrojs/renderer-vue@0.1.9&amp;id=4dbad5d5ff164167ae5b61ab6c2e46605fc25b14&amp;follow=1'>Added descriptions to docs pages (#1550)</a></td><td><img src='//www.gravatar.com/avatar/97864ad109e3ba909af302bbc983a5a1?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> AsyncBanana
</td><td>22</td><td><span class='deletions'>-8</span>/<span class='insertions'>+28</span></td></tr>
<tr><td><span title='2021-10-14 08:07:47 -0400'>2021-10-14</span></td><td><a href='/ansg191/astro/commit/.github/workflows/stat.yml?h=@astrojs/renderer-vue@0.1.9&amp;id=a0becd24b4f44a8ee92533c3baf943e760ee7584&amp;follow=1'>Only run `.github/workflows/stats.yml` locally, not on forks (#1549)</a></td><td><img src='//www.gravatar.com/avatar/e7083c09b30334ac5bb50a7b67697d02?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> Caleb Jasik
</td><td>1</td><td><span class='deletions'>-0</span>/<span class='insertions'>+1</span></td></tr>
<tr><td><span title='2021-10-14 12:05:38 +0000'>2021-10-14</span></td><td><a href='/ansg191/astro/commit/scripts/stats/stats.csv?h=@astrojs/renderer-vue@0.1.9&amp;id=fb966b0820ff4ad3635243c971f77d3d5c8825b9&amp;follow=1'>[ci] collect stats</a></td><td><img src='//www.gravatar.com/avatar/d992ca8d4b18ac36e0a6e5f2fdeb063f?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> FredKSchott
</td><td>1</td><td><span class='deletions'>-0</span>/<span class='insertions'>+1</span></td></tr>
<tr><td><span title='2021-10-13 16:22:00 -0400'>2021-10-13</span></td><td><a href='/ansg191/astro/commit/docs/src/pages/themes.astro?h=@astrojs/renderer-vue@0.1.9&amp;id=8c308a14907c0e995274a6cd634ca36cbf26e610&amp;follow=1'>Add Community Themes and separate Featured Theme (#1543)</a></td><td><img src='//www.gravatar.com/avatar/a96e3be396ec41ec6a70e1f3f4703c64?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> Mark Teekman
</td><td>2</td><td><span class='deletions'>-8</span>/<span class='insertions'>+30</span></td></tr>
<tr><td><span title='2021-10-13 16:21:35 -0400'>2021-10-13</span></td><td><a href='/ansg191/astro/commit/www/src/components/BlogPostPreview.astro?h=@astrojs/renderer-vue@0.1.9&amp;id=3aafb58d60afe03f2c4fef036452451fb3f399da&amp;follow=1'>Change publish date el to be more accessible (#1522)</a></td><td><img src='//www.gravatar.com/avatar/97864ad109e3ba909af302bbc983a5a1?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> AsyncBanana
</td><td>2</td><td><span class='deletions'>-2</span>/<span class='insertions'>+2</span></td></tr>
<tr><td><span title='2021-10-13 17:09:37 +0000'>2021-10-13</span></td><td><a href='/ansg191/astro/commit/docs/src/pages/es/core-concepts/project-structure.md?h=@astrojs/renderer-vue@0.1.9&amp;id=660481444b7f6ca540771d1aa70a27346db8554f&amp;follow=1'>[ci] yarn format</a></td><td><img src='//www.gravatar.com/avatar/fedbf2bad69e90b269e5caba47a0e897?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> matthewp
</td><td>1</td><td><span class='deletions'>-1</span>/<span class='insertions'>+1</span></td></tr>
<tr><td><span title='2021-10-13 13:08:19 -0400'>2021-10-13</span></td><td><a href='/ansg191/astro/commit/docs/src/pages/pt-br/getting-started.md?h=@astrojs/renderer-vue@0.1.9&amp;id=9d53dfbfb2b6df081adef904f5cdbcc121282445&amp;follow=1'>docs: unify concepts in Spanish version (#1545)</a></td><td><img src='//www.gravatar.com/avatar/12c81222a24160844b7f80152508513d?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> Jorge del Casar
</td><td>6</td><td><span class='deletions'>-11</span>/<span class='insertions'>+11</span></td></tr>
<tr><td><span title='2021-10-13 16:23:19 +0000'>2021-10-13</span></td><td><a href='/ansg191/astro/commit/docs/src/pages/de/quick-start.md?h=@astrojs/renderer-vue@0.1.9&amp;id=348ba366f7399ecb5d06d2e447034472173cd4be&amp;follow=1'>[ci] yarn format</a></td><td><img src='//www.gravatar.com/avatar/fedbf2bad69e90b269e5caba47a0e897?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> matthewp
</td><td>1</td><td><span class='deletions'>-1</span>/<span class='insertions'>+1</span></td></tr>