file_text stringlengths 1 2.1M ⌀ | language stringclasses 416
values | file_name stringlengths 1 185 ⌀ |
|---|---|---|
const std = @import("std");
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bun.default_allo... | Zig | http_bench.zig |
// This file benchmarks different approaches for determinig whether or not a unicode codepoint is possibly a JS identifier
// these values are copy-pasted from "typescript/lib/typescriptServices.js"
const std = @import("std");
pub const SerializedBitset = extern struct {};
pub const Bitset = struct {
const Cache =... | Zig | identifier.zig |
const std = @import("std");
const bun = @import("root").bun;
pub const CachedBitset = extern struct {
range: [2]i32,
len: u32,
pub fn fromFile(comptime filename: anytype) CachedBitset {
return comptime @as(CachedBitset, @bitCast(bun.asByteSlice(@embedFile(filename)).ptr[0..@sizeOf(CachedBitset)].*... | Zig | identifier_cache.zig |
const std = @import("std");
// "unicodeESNextIdentifierStart"
pub const start_codepoints = [_]i32{ 65, 90, 97, 122, 170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 895, 895, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, ... | Zig | identifier_data.zig |
pub fn IdentityContext(comptime Key: type) type {
return struct {
pub fn hash(_: @This(), key: Key) u64 {
return key;
}
pub fn eql(_: @This(), a: Key, b: Key) bool {
return a == b;
}
};
}
/// When storing hashes as keys in a hash table, we don't want to ... | Zig | identity_context.zig |
const fs = @import("root").bun.fs;
const bun = @import("root").bun;
const logger = @import("root").bun.logger;
const std = @import("std");
const Ref = @import("ast/base.zig").Ref;
const Index = @import("ast/base.zig").Index;
const Api = @import("./api/schema.zig").Api;
pub const ImportKind = enum(u8) {
// An entr... | Zig | import_record.zig |
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bun.default_allocator;
const C = bun.C;
cons... | Zig | init_command.zig |
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bun.default_allocator;
const C = bun.C;
cons... | Zig | install.zig |
const Command = @import("../cli.zig").Command;
const bun = @import("root").bun;
const PackageManager = @import("../install/install.zig").PackageManager;
pub const InstallCommand = struct {
pub fn exec(ctx: Command.Context) !void {
try PackageManager.install(ctx);
}
};
| Zig | install_command.zig |
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bun.default_allocator;
const C = bun.C;
cons... | Zig | install_completions_command.zig |
const std = @import("std");
const strings = @import("../string_immutable.zig");
const Crypto = @import("../sha.zig").Hashers;
const bun = @import("root").bun;
pub const Integrity = extern struct {
const empty_digest_buf: [Integrity.digest_buf_len]u8 = [_]u8{0} ** Integrity.digest_buf_len;
tag: Tag = Tag.unkno... | Zig | integrity.zig |
//! The interpreter for the shell language
//!
//! Normally, the implementation would be a very simple tree-walk of the AST,
//! but it needs to be non-blocking, and Zig does not have coroutines yet, so
//! this implementation is half tree-walk half one big state machine. The state
//! machine part manually keeps track... | Zig | interpreter.zig |
const bun = @import("root").bun;
const std = @import("std");
const sys = bun.sys;
const linux = std.os.linux;
const Environment = bun.Environment;
const heap = @import("./heap.zig");
const JSC = bun.JSC;
const log = bun.Output.scoped(.loop, false);
const TimerHeap = heap.Intrusive(Timer, void, Timer.less);
const os ... | Zig | io.zig |
const std = @import("std");
const os = struct {
pub usingnamespace std.os;
pub const EINTR = 4;
pub const EAGAIN = 35;
pub const EBADF = 9;
pub const ECONNRESET = 54;
pub const EFAULT = 14;
pub const EINVAL = 22;
pub const EIO = 5;
pub const EISDIR = 21;
pub const ENOBUFS = 55;
... | Zig | io_darwin.zig |
const std = @import("std");
const assert = std.debug.assert;
const Platform = @import("root").bun.analytics.GenerateHeader.GeneratePlatform;
const os = struct {
pub usingnamespace std.os;
pub const EPERM = 1;
pub const ENOENT = 2;
pub const ESRCH = 3;
pub const EINTR = 4;
pub const EIO = 5;
... | Zig | io_linux.zig |
const std = @import("std");
const IO = struct {
buffer: i32 = 0,
};
pub fn init(_: anytype, _: anytype) anyerror!void {}
pub var global: IO = undefined;
pub var global_loaded: bool = false;
fn buffer_limit(_: usize) usize {}
| Zig | io_stub.zig |
pub fn init() *@This() {
@panic("ahahhhahahhahahha AsyncIO/io_windows.zig was deleted");
}
| Zig | io_windows.zig |
const uws = @import("../deps/uws.zig");
const bun = @import("root").bun;
const Environment = bun.Environment;
const Global = bun.Global;
const strings = bun.strings;
const string = bun.string;
const Output = @import("root").bun.Output;
const MutableString = @import("root").bun.MutableString;
const std = @import("std");... | Zig | ipc.zig |
const std = @import("std");
const is_bindgen: bool = std.meta.globalOption("bindgen", bool) orelse false;
const StaticExport = @import("./bindings/static_export.zig");
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
c... | Zig | javascript.zig |
/// *************************************
/// **** DO NOT USE THIS ON NEW CODE ****
/// *************************************
/// To generate a new class exposed to JavaScript, look at *.classes.ts
/// Otherwise, use `JSC.JSValue`.
/// ************************************
const bun = @import("root").bun;
const std = @i... | Zig | javascript_core_c_api.zig |
const std = @import("std");
const bun = @import("root").bun;
const js_parser = bun.js_parser;
const js_ast = bun.JSAst;
const Api = @import("../../api/schema.zig").Api;
const MimeType = bun.http.MimeType;
const ZigURL = @import("../../url.zig").URL;
const HTTPClient = @import("root").bun.http;
const Environment = bun.E... | Zig | jest.zig |
const std = @import("std");
const logger = @import("root").bun.logger;
const JSXRuntime = @import("options.zig").JSX.Runtime;
const Runtime = @import("runtime.zig").Runtime;
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environm... | Zig | js_ast.zig |
const std = @import("std");
const logger = @import("root").bun.logger;
const tables = @import("js_lexer_tables.zig");
const build_options = @import("build_options");
const js_ast = bun.JSAst;
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environ... | Zig | js_lexer.zig |
const std = @import("std");
const expectString = std.testing.expectEqualStrings;
const expect = std.testing.expect;
const logger = @import("root").bun.logger;
const unicode = std.unicode;
const default_allocator = @import("root").bun.default_allocator;
const string = @import("string_types.zig").string;
const CodePoint ... | Zig | js_lexer_tables.zig |
/// ** IMPORTANT **
/// ** When making changes to the JavaScript Parser that impact runtime behavior or fix bugs **
/// ** you must also increment the `expected_version` in RuntimeTranspilerCache.zig **
/// ** IMPORTANT **
pub const std = @import("std");
pub const logger = @import("root").bun.logger;
pub const js_lexer... | Zig | js_parser.zig |
const std = @import("std");
const logger = @import("root").bun.logger;
const js_lexer = bun.js_lexer;
const importRecord = @import("import_record.zig");
const js_ast = bun.JSAst;
const options = @import("options.zig");
const rename = @import("renamer.zig");
const runtime = @import("runtime.zig");
const Lock = @import("... | Zig | js_printer.zig |
// Top-level so it can access all files
pub usingnamespace @import("./bun.js/base.zig");
pub usingnamespace @import("./bun.js/bindings/bindings.zig");
pub usingnamespace @import("./bun.js/bindings/exports.zig");
pub usingnamespace @import("./bun.js/event_loop.zig");
pub usingnamespace @import("./bun.js/javascript.zig")... | Zig | jsc.zig |
// For WASM builds
pub const is_bindgen = true;
pub const C = struct {};
pub const WebCore = struct {};
pub const Jest = struct {};
pub const API = struct {
pub const Transpiler = struct {};
};
pub const Node = struct {};
pub const VirtualMachine = struct {};
| Zig | jsc_stub.zig |
const std = @import("std");
const logger = @import("root").bun.logger;
const js_lexer = bun.js_lexer;
const importRecord = @import("import_record.zig");
const js_ast = bun.JSAst;
const options = @import("options.zig");
const BabyList = @import("./baby_list.zig").BabyList;
const fs = @import("fs.zig");
const bun = @impo... | Zig | json_parser.zig |
const bun = @import("root").bun;
pub const wchar_t = u16;
pub const la_int64_t = i64;
pub const la_ssize_t = isize;
pub const struct_archive = opaque {};
pub const struct_archive_entry = opaque {};
pub const archive = struct_archive;
pub const archive_entry = struct_archive_entry;
const mode_t = bun.Mode;
const FILE = ... | Zig | libarchive-bindings.zig |
// @link "../deps/libarchive.a"
const lib = @import("./libarchive-bindings.zig");
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const FileDescri... | Zig | libarchive.zig |
const bun = @import("root").bun;
const WORD = c_ushort;
const LARGE_INTEGER = i64;
const std = @import("std");
const windows = bun.windows;
const HANDLE = windows.HANDLE;
const DWORD = windows.DWORD;
const OVERLAPPED = std.os.windows.OVERLAPPED;
const ULONG_PTR = std.os.windows.ULONG_PTR;
const HMODULE = HANDLE;
const... | Zig | libuv.zig |
const bun = @import("root").bun;
const Lockfile = @import("./lockfile.zig");
const std = @import("std");
const Async = bun.Async;
const PosixSpawn = bun.posix.spawn;
const PackageManager = @import("./install.zig").PackageManager;
const Environment = bun.Environment;
const Output = bun.Output;
const Global = bun.Global;... | Zig | lifecycle_script_runner.zig |
// clone of zig stdlib
// except, this one vectorizes
// FIFO of fixed size items
// Usually used for e.g. byte buffers
const std = @import("std");
const math = std.math;
const mem = std.mem;
const Allocator = mem.Allocator;
const debug = std.debug;
const assert = debug.assert;
const testing = std.testing;
const bun ... | Zig | linear_fifo.zig |
const Command = @import("../cli.zig").Command;
const PackageManager = @import("../install/install.zig").PackageManager;
pub const LinkCommand = struct {
pub fn exec(ctx: Command.Context) !void {
try PackageManager.link(ctx);
}
};
| Zig | link_command.zig |
// Most of this file should eventually be replaced with `bundle_v2.zig` or
// `bundle_v2` should be split into several files.
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableS... | Zig | linker.zig |
const std = @import("std");
const bun = @import("root").bun;
pub const SystemErrno = enum(u8) {
SUCCESS = 0,
EPERM = 1,
ENOENT = 2,
ESRCH = 3,
EINTR = 4,
EIO = 5,
ENXIO = 6,
E2BIG = 7,
ENOEXEC = 8,
EBADF = 9,
ECHILD = 10,
EAGAIN = 11,
ENOMEM = 12,
EACCES = 13,
... | Zig | linux_c.zig |
const bun = @import("root").bun;
const std = @import("std");
/// When cloning large amounts of data potentially multiple times, we can
/// leverage copy-on-write memory to avoid actually copying the data. To do that
/// on Linux, we need to use a memfd, which is a Linux-specific feature.
///
/// The steps are roughly:... | Zig | linux_memfd_allocator.zig |
const std = @import("std");
const bun = @import("root").bun;
// yarn v2.3 commands
const yarn_v2 = [_][]const u8{
"add",
"bin",
"cache",
"config",
"dedupe",
"dlx",
"exec",
"explain",
"info",
"init",
"install",
"link",
"node",
"npm",
"pack",
"patch",
"... | Zig | list-of-yarn-commands.zig |
const std = @import("std");
const Atomic = std.atomic.Value;
const Futex = @import("./futex.zig");
// Credit: this is copypasta from @kprotty. Thank you @kprotty!
pub const Mutex = struct {
state: Atomic(u32) = Atomic(u32).init(UNLOCKED),
const UNLOCKED = 0;
const LOCKED = 0b01;
const CONTENDED = 0b11... | Zig | lock.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const... | Zig | lockfile.zig |
const std = @import("std");
const Api = @import("./api/schema.zig").Api;
const js = @import("root").bun.JSC;
const ImportKind = @import("./import_record.zig").ImportKind;
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment... | Zig | logger.zig |
pub const Error = error{Fail};
const std = @import("std");
const bun = @import("root").bun;
pub const MemorySettings = extern struct {
preallocated_parsing_buffer_size: usize,
max_allowed_memory_usage: usize,
};
inline fn auto_disable() void {
if (comptime @import("root").bun.FeatureFlags.disable_lolhtml)
... | Zig | lol-html.zig |
const bun = @import("root").bun;
const lshpack_header = extern struct {
name: [*]const u8 = undefined,
name_len: usize = 0,
value: [*]const u8 = undefined,
value_len: usize = 0,
};
/// wrapper implemented at src/bun.js/bindings/c-bindings.cpp
pub const HPACK = extern struct {
self: *anyopaque,
... | Zig | lshpack.zig |
// most of this file is copy pasted from other files in misctools
const std = @import("std");
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const... | Zig | machbench.zig |
const std = @import("std");
extern fn print(*const u8) void;
comptime {
std.debug.assert(@alignOf(u16) >= 2);
std.debug.assert(@alignOf(u32) >= 4);
std.debug.assert(@alignOf(u64) >= 8);
std.debug.assert(@alignOf(i16) >= 2);
std.debug.assert(@alignOf(i32) >= 4);
std.debug.assert(@alignOf(i64) >... | Zig | main.zig |
const std = @import("std");
pub fn main() !void {
// Prints to stderr (it's a shortcut based on `std.io.getStdErr()`)
std.debug.print("All your {s} are belong to us.\n", .{"codebase"});
// stdout is for the actual output of your application, for example if you
// are implementing gzip, then only the c... | Zig | main_1.zig |
const std = @import("std");
const Allocator = @import("std").mem.Allocator;
const print = @import("std").debug.print;
const RndGen = std.rand.DefaultPrng;
const utils = @import("utils.zig");
const queryParser = @import("query_parser.zig");
const Client = @import("driver/client.zig").Client;
const Tree = @import("engi... | Zig | main_2.zig |
const Api = @import("./api/schema.zig").Api;
const Options = @import("./options.zig");
var options: Options.BundleOptions = undefined;
export fn init() void {
if (!alloc.needs_setup) {
return;
}
}
export fn setOptions(options_ptr: [*c]u8, options_len: c_int) void {}
| Zig | main_api.zig |
const std = @import("std");
comptime {
const test_files = [_]type{
@import("tests/utils_test.zig"),
@import("query_parser.zig"),
@import("engine/tree.zig"),
@import("engine/Node.zig"),
@import("engine/TypeNode.zig"),
@import("engine/tests/exact_search_tests.zig"),
... | Zig | main_test.zig |
const bun = @import("root").bun;
const JSParser = bun.js_parser;
const JSPrinter = bun.js_printer;
const JSAst = bun.JSAst;
const Api = @import("./api/schema.zig").Api;
const Logger = @import("root").bun.logger;
const global = @import("root").bun;
const default_allocator = global.default_allocator;
const std = @import(... | Zig | main_wasm.zig |
const bun = @import("root").bun;
const std = @import("std");
/// Single allocation only.
///
pub const MaxHeapAllocator = struct {
array_list: std.ArrayList(u8),
fn alloc(ptr: *anyopaque, len: usize, _: u8, _: usize) ?[*]u8 {
var this = bun.cast(*MaxHeapAllocator, ptr);
this.array_list.items.l... | Zig | max_heap_allocator.zig |
const mem = @import("std").mem;
const builtin = @import("std").builtin;
const std = @import("std");
const mimalloc = @import("./allocators/mimalloc.zig");
const FeatureFlags = @import("./feature_flags.zig");
const Environment = @import("./env.zig");
fn mimalloc_free(
_: *anyopaque,
buf: []u8,
buf_align: u... | Zig | memory_allocator.zig |
const std = @import("std");
pub usingnamespace std.meta;
pub fn ReturnOf(comptime function: anytype) type {
return ReturnOfType(@TypeOf(function));
}
pub fn ReturnOfType(comptime Type: type) type {
const typeinfo: std.builtin.Type.Fn = @typeInfo(Type).Fn;
return typeinfo.return_type orelse void;
}
// pa... | Zig | meta.zig |
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bun.default_allocator;
const C = bun.C;
cons... | Zig | method.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
cons... | Zig | migration.zig |
pub extern fn mi_malloc(size: usize) ?*anyopaque;
pub extern fn mi_calloc(count: usize, size: usize) ?*anyopaque;
pub extern fn mi_realloc(p: ?*anyopaque, newsize: usize) ?*anyopaque;
pub extern fn mi_expand(p: ?*anyopaque, newsize: usize) ?*anyopaque;
pub extern fn mi_free(p: ?*anyopaque) void;
pub extern fn mi_strdup... | Zig | mimalloc.zig |
const mem = @import("std").mem;
const builtin = @import("std").builtin;
const std = @import("std");
const mimalloc = @import("./allocators/mimalloc.zig");
const Environment = @import("./env.zig");
const FeatureFlags = @import("./feature_flags.zig");
const Allocator = mem.Allocator;
const assert = std.debug.assert;
con... | Zig | mimalloc_arena.zig |
const std = @import("std");
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bun.default_allo... | Zig | mime_type.zig |
const std = @import("std");
const is_bindgen: bool = std.meta.globalOption("bindgen", bool) orelse false;
const StaticExport = @import("./bindings/static_export.zig");
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
c... | Zig | module_loader.zig |
const std = @import("std");
const builtin = @import("builtin");
const assert = std.debug.assert;
const meta = std.meta;
const mem = std.mem;
const Allocator = mem.Allocator;
const testing = std.testing;
/// A MultiArrayList stores a list of a struct or tagged union type.
/// Instead of storing a single list of items, ... | Zig | multi_array_list.zig |
const std = @import("std");
const JSC = @import("root").bun.JSC;
const strings = @import("root").bun.strings;
const bun = @import("root").bun;
const Lock = @import("../lock.zig").Lock;
const JSValue = JSC.JSValue;
const ZigString = JSC.ZigString;
const TODO_EXCEPTION: JSC.C.ExceptionRef = null;
const Channel = @import... | Zig | napi.zig |
const std = @import("std");
const string = @import("./string_types.zig").string;
const PackageJSON = @import("./resolver/package_json.zig").PackageJSON;
const logger = @import("root").bun.logger;
const Fs = @import("./fs.zig");
const bun = @import("root").bun;
const ComptimeStringMap = @import("./comptime_string_map.zi... | Zig | node_fallbacks.zig |
// This file contains the underlying implementation for sync & async functions
// for interacting with the filesystem from JavaScript.
// The top-level functions assume the arguments are already validated
const std = @import("std");
const bun = @import("root").bun;
const strings = bun.strings;
const windows = bun.windo... | Zig | node_fs.zig |
const bun = @import("root").bun;
const JSC = @import("root").bun.JSC;
const std = @import("std");
const Flavor = JSC.Node.Flavor;
const ArgumentsSlice = JSC.Node.ArgumentsSlice;
const system = std.os.system;
const Maybe = JSC.Maybe;
const Encoding = JSC.Node.Encoding;
const FeatureFlags = @import("root").bun.FeatureFla... | Zig | node_fs_binding.zig |
const bun = @import("root").bun;
const Environment = bun.Environment;
const std = @import("std");
fn get(comptime name: []const u8) comptime_int {
return if (@hasDecl(std.os.O, name))
return @field(std.os.O, name)
else
@compileError("Unknown Constant: " ++ name);
}
pub const Constants = struct... | Zig | node_fs_constant.zig |
const std = @import("std");
const JSC = @import("root").bun.JSC;
const bun = @import("root").bun;
const Fs = @import("../../fs.zig");
const Path = @import("../../resolver/resolve_path.zig");
const Encoder = JSC.WebCore.Encoder;
const Mutex = @import("../../lock.zig").Lock;
const uws = @import("../../deps/uws.zig");
co... | Zig | node_fs_stat_watcher.zig |
const std = @import("std");
const JSC = @import("root").bun.JSC;
const bun = @import("root").bun;
const Fs = @import("../../fs.zig");
const Path = @import("../../resolver/resolve_path.zig");
const Encoder = JSC.WebCore.Encoder;
const Mutex = @import("../../lock.zig").Lock;
const VirtualMachine = JSC.VirtualMachine;
co... | Zig | node_fs_watcher.zig |
const std = @import("std");
const Allocator = @import("std").mem.Allocator;
const utils = @import("../utils.zig");
const buildTree = @import("utils.zig").buildTree;
const queryParser = @import("../../query_parser.zig");
const RawDecl = @import("utils.zig").RawDecl;
const Following = @import("../following.zig").Follow... | Zig | node_labels_tests.zig |
const std = @import("std");
const builtin = @import("builtin");
const bun = @import("root").bun;
const C = bun.C;
const string = bun.string;
const strings = bun.strings;
const JSC = @import("root").bun.JSC;
const Environment = bun.Environment;
const Global = bun.Global;
const is_bindgen: bool = std.meta.globalOption("b... | Zig | node_os.zig |
/// https://nodejs.org/api/errors.html#nodejs-error-codes
pub const Code = enum {
/// Used when an operation has been aborted (typically using an AbortController).
/// APIs not using AbortSignals typically do not raise an error with this code.
/// This code does not use the regular ERR_* convention Node.js ... | Zig | nodejs_error_code.zig |
const URL = @import("../url.zig").URL;
const bun = @import("root").bun;
const std = @import("std");
const MutableString = @import("../string_mutable.zig").MutableString;
const Semver = @import("./semver.zig");
const ExternalString = Semver.ExternalString;
const String = Semver.String;
const string = @import("../string_... | Zig | npm.zig |
const std = @import("std");
/// A nullable allocator the same size as `std.mem.Allocator`.
pub const NullableAllocator = struct {
ptr: *anyopaque = undefined,
// Utilize the null pointer optimization on the vtable instead of
// the regular ptr because some allocator implementations might tag their
// `... | Zig | nullable_allocator.zig |
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bun.default_allocator;
const C = bun.C;
cons... | Zig | open.zig |
/// This file is mostly the API schema but with all the options normalized.
/// Normalization is necessary because most fields in the API schema are optional
const std = @import("std");
const logger = @import("root").bun.logger;
const Fs = @import("fs.zig");
const resolver = @import("./resolver/resolver.zig");
const a... | Zig | options.zig |
const Output = @This();
const bun = @import("root").bun;
const std = @import("std");
const Environment = @import("./env.zig");
const string = @import("root").bun.string;
const root = @import("root");
const strings = @import("root").bun.strings;
const StringTypes = @import("root").bun.StringTypes;
const Global = @import... | Zig | output.zig |
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const StoredFileDescriptorType = bun.StoredFileDescriptorType;
const stringZ = bun.stringZ;
const d... | Zig | package_json.zig |
const std = @import("std");
const bun = @import("root").bun;
const Global = bun.Global;
const Output = bun.Output;
const string = bun.string;
const strings = bun.strings;
const Command = @import("../cli.zig").Command;
const Fs = @import("../fs.zig");
const Dependency = @import("../install/dependency.zig");
const Instal... | Zig | package_manager_command.zig |
const std = @import("std");
/// In some parts of lockfile serialization, Bun will use `std.mem.sliceAsBytes` to convert a struct into raw
/// bytes to write. This makes lockfile serialization/deserialization much simpler/faster, at the cost of not
/// having any pointers within these structs.
///
/// One major caveat ... | Zig | padding_checker.zig |
const std = @import("std");
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bun.default_allo... | Zig | panic_handler.zig |
const std = @import("std");
const bun = @import("root").bun;
const string = bun.string;
const strings = bun.strings;
const String = bun.String;
const JSC = bun.JSC;
const JSValue = JSC.JSValue;
const JSGlobalObject = JSC.JSGlobalObject;
const ZigString = JSC.ZigString;
const validators = @import("./validators.zig");
c... | Zig | parse_args.zig |
const std = @import("std");
const testing = std.testing;
const String = if (@import("builtin").is_test) TestString else @import("root").bun.String;
const JSValue = if (@import("builtin").is_test) usize else @import("root").bun.JSC.JSValue;
pub const OptionValueType = enum { boolean, string };
/// Metadata of an optio... | Zig | parse_args_utils.zig |
const std = @import("std");
const UnboundedQueue = @import("../unbounded_queue.zig").UnboundedQueue;
const Path = @import("../../resolver/resolve_path.zig");
const Fs = @import("../../fs.zig");
const Mutex = @import("../../lock.zig").Lock;
const FSEvents = @import("./fs_events.zig");
const bun = @import("root").bun;
... | Zig | path_watcher.zig |
const std = @import("std");
const c = @import("picohttpparser.zig");
const ExactSizeMatcher = @import("root").bun.ExactSizeMatcher;
const Match = ExactSizeMatcher(2);
const Output = @import("root").bun.Output;
const Environment = @import("root").bun.Environment;
const StringBuilder = @import("root").bun.StringBuilder;
... | Zig | picohttp.zig |
pub usingnamespace @import("std").zig.c_builtins;
pub const struct_phr_header = extern struct {
name: [*c]const u8,
name_len: usize,
value: [*c]const u8,
value_len: usize,
};
pub extern fn phr_parse_request(buf: [*c]const u8, len: usize, method: [*c][*c]const u8, method_len: [*c]usize, path: [*c][*c]co... | Zig | picohttpparser.zig |
const std = @import("std");
fn SinglyLinkedList(comptime T: type, comptime Parent: type) type {
return struct {
const Self = @This();
/// Node inside the linked list wrapping the actual data.
pub const Node = struct {
next: ?*Node = null,
allocator: std.mem.Allocato... | Zig | pool.zig |
const bun = @import("root").bun;
const Output = bun.Output;
const JSC = bun.JSC;
const uws = bun.uws;
const Environment = bun.Environment;
const std = @import("std");
pub const Loop = uws.Loop;
/// Track if an object whose file descriptor is being watched should keep the event loop alive.
/// This is not reference co... | Zig | posix_event_loop.zig |
const std = @import("std");
const bun = @import("root").bun;
const Output = bun.Output;
const JSC = bun.JSC;
const JSGlobalObject = JSC.JSGlobalObject;
const JSValue = JSC.JSValue;
const is_bindgen: bool = std.meta.globalOption("bindgen", bool) orelse false;
const default_allocator = bun.default_allocator;
const CAPI =... | Zig | pretty_format.zig |
pub const lodash = [_][]const u8{
"/project/node_modules/lodash/_apply.js",
"/project/node_modules/lodash/_arrayAggregator.js",
"/project/node_modules/lodash/_arrayEach.js",
"/project/node_modules/lodash/_arrayEachRight.js",
"/project/node_modules/lodash/_arrayEvery.js",
"/project/node_modules/l... | Zig | project.zig |
const std = @import("std");
const Allocator = @import("std").mem.Allocator;
const RndGen = std.rand.DefaultPrng;
const TypeNode = @import("engine/TypeNode.zig");
const utils = @import("utils.zig");
const main = @import("main.zig");
const LOG = @import("config").logp;
pub fn parseQuery(allocator: Allocator, str: []co... | Zig | query_parser.zig |
const EditorContext = @import("../open.zig").EditorContext;
const Blob = JSC.WebCore.Blob;
const default_allocator = @import("root").bun.default_allocator;
const Output = @import("root").bun.Output;
const RareData = @This();
const Syscall = bun.sys;
const JSC = @import("root").bun.JSC;
const std = @import("std");
const... | Zig | rare_data.zig |
const std = @import("std");
const path_handler = @import("../src/resolver/resolve_path.zig");
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
cons... | Zig | readlink-getfd.zig |
const std = @import("std");
const path_handler = @import("../src/resolver/resolve_path.zig");
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
cons... | Zig | readlink-realpath.zig |
const std = @import("std");
pub fn RefCount(comptime TypeName: type, comptime deinit_on_zero: bool) type {
return struct {
const AllocatorType = if (deinit_on_zero) std.mem.Allocator else void;
value: Type,
count: i32 = 1,
allocator: AllocatorType = undefined,
pub inline f... | Zig | ref_count.zig |
const Command = @import("../cli.zig").Command;
const PackageManager = @import("../install/install.zig").PackageManager;
pub const RemoveCommand = struct {
pub fn exec(ctx: Command.Context) !void {
try PackageManager.remove(ctx);
}
};
| Zig | remove_command.zig |
const js_ast = bun.JSAst;
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bun.default_alloca... | Zig | renamer.zig |
const std = @import("std");
const logger = @import("root").bun.logger;
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;... | Zig | report.zig |
const bun = @import("root").bun;
const Global = bun.Global;
const logger = bun.logger;
const Dependency = @import("./dependency.zig");
const DotEnv = @import("../env_loader.zig");
const Environment = @import("../env.zig");
const FileSystem = @import("../fs.zig").FileSystem;
const Install = @import("./install.zig");
con... | Zig | repository.zig |
const std = @import("std");
const Api = @import("../../api/schema.zig").Api;
const bun = @import("root").bun;
const MimeType = bun.http.MimeType;
const ZigURL = @import("../../url.zig").URL;
const HTTPClient = @import("root").bun.http;
const JSC = @import("root").bun.JSC;
const js = JSC.C;
const Method = @import("../.... | Zig | request.zig |
const PackageManager = @import("./install.zig").PackageManager;
const Semver = @import("./semver.zig");
const ExternalString = Semver.ExternalString;
const String = Semver.String;
const std = @import("std");
const Repository = @import("./repository.zig").Repository;
const string = @import("../string_types.zig").string;... | Zig | resolution.zig |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.