file_text stringlengths 1 2.1M ⌀ | language stringclasses 416
values | file_name stringlengths 1 185 ⌀ |
|---|---|---|
const boring = @import("./deps/boringssl.translated.zig");
pub usingnamespace boring;
const std = @import("std");
const bun = @import("root").bun;
const c_ares = @import("./deps/c_ares.zig");
const strings = bun.strings;
const builtin = @import("builtin");
const X509 = @import("./bun.js/api/bun/x509.zig");
var loaded ... | Zig | boringssl.zig |
const bun = @import("root").bun;
const ArrayList = std.ArrayList;
const std = @import("std");
const builtin = @import("builtin");
const Arena = std.heap.ArenaAllocator;
const Allocator = std.mem.Allocator;
const SmolStr = @import("../string_types.zig").SmolStr;
const TaggedPointerUnion = @import("../tagged_pointer.zig"... | Zig | braces.zig |
const bun = @import("root").bun;
const std = @import("std");
const c = @import("./deps/brotli_decoder.zig");
const BrotliDecoder = c.BrotliDecoder;
const mimalloc = bun.Mimalloc;
const BrotliAllocator = struct {
pub fn alloc(_: ?*anyopaque, len: usize) callconv(.C) *anyopaque {
if (comptime bun.is_heap_br... | Zig | brotli.zig |
const bun = @import("root").bun;
const std = @import("std");
pub const brotli_alloc_func = ?*const fn (?*anyopaque, usize) callconv(.C) ?*anyopaque;
pub const brotli_free_func = ?*const fn (?*anyopaque, *anyopaque) callconv(.C) void;
pub const struct_BrotliSharedDictionaryStruct = opaque {};
pub const BrotliSharedDict... | Zig | brotli_decoder.zig |
const bun = @import("root").bun;
const JSC = bun.JSC;
const Encoder = JSC.WebCore.Encoder;
pub const BufferVectorized = struct {
pub fn fill(
str: *JSC.ZigString,
buf_ptr: [*]u8,
fill_length: usize,
encoding: JSC.Node.Encoding,
) callconv(.C) bool {
if (str.len == 0) ret... | Zig | buffer.zig |
const std = @import("std");
const pathRel = std.fs.path.relative;
const builtin = @import("builtin");
const Wyhash = @import("./src/wyhash.zig").Wyhash;
const zig_version = builtin.zig_version;
/// Do not rename this constant. It is scanned by some scripts to determine which zig version to install.
const recommended_... | Zig | build.zig |
.{
.name = "aoc-2023-zig",
// This is a [Semantic Version](https://semver.org/).
// In a future version of Zig it will be used for package deduplication.
.version = "0.0.0",
// This field is optional.
// This is currently advisory only; Zig does not yet do anything
// with this value.
/... | Zig | build.zig.zon |
const std = @import("std");
// Although this function looks imperative, note that its job is to
// declaratively construct a build graph that will be executed by an external
// runner.
pub fn build(b: *std.Build) void {
// Standard target options allows the person running `zig build` to choose
// what target t... | Zig | build_1.zig |
const std = @import("std");
// Although this function looks imperative, note that its job is to
// declaratively construct a build graph that will be executed by an external
// runner.
pub fn build(b: *std.Build) !void {
// Standard target options allows the person running `zig build` to choose
// what target ... | Zig | build_2.zig |
// Compatible with Zig Version 0.11.0
const std = @import("std");
const ArrayList = std.ArrayList;
const Compile = std.Build.Step.Compile;
const ConfigHeader = std.Build.Step.ConfigHeader;
const Mode = std.builtin.Mode;
const CrossTarget = std.zig.CrossTarget;
const Maker = struct {
builder: *std.build.Builder,
... | Zig | build_3.zig |
// Compatible with Zig Version 0.11.0
const std = @import("std");
const ArrayList = std.ArrayList;
const Compile = std.Build.Step.Compile;
const ConfigHeader = std.Build.Step.ConfigHeader;
const Mode = std.builtin.Mode;
const CrossTarget = std.zig.CrossTarget;
const Maker = struct {
builder: *std.build.Builder,
... | Zig | build_4.zig |
const std = @import("std");
const Command = @import("../cli.zig").Command;
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.stri... | Zig | build_command.zig |
const JSC = @import("root").bun.JSC;
pub const SIMDUTFResult = extern struct {
status: Status,
count: usize = 0,
pub const Status = enum(i32) {
success = 0,
/// Any byte must have fewer than 5 header bits.
header_bits = 1,
/// The leading byte must be followed by N-1 conti... | Zig | bun-simdutf.zig |
/// The functions in this file are used throughout Bun's codebase
//
// Do not import this file directly!
// To import it:
// @import("root").bun
//
// Otherwise, you risk a circular dependency or Zig including multiple copies of this file which leads to strange bugs.
const std = @import("std");
pub const Enviro... | Zig | bun.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 | bun_js.zig |
//! This program is a shim for node_modules/.bin scripts.
//!
//! This is needed because:
//! - Symlinks are not guaranteed to work on Windows
//! - Windows does not process Shebangs
//!
//! This also solves the 'Terminate batch job (Y/N)' problem you see when using NPM/Yarn,
//! which is a HUGE dx win for developers.
... | Zig | bun_shim_impl.zig |
// This is Bun's JavaScript/TypeScript bundler
//
// A lot of the implementation is based on the Go implementation of esbuild. Thank you Evan Wallace.
//
// # Memory management
//
// Zig is not a managed language, so we have to be careful about memory management.
// Manually freeing memory is error-prone and tedious, b... | Zig | bundle_v2.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 StoredFileDescr... | Zig | bundler.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 | bunfig.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 | bunx_command.zig |
const std = @import("std");
const bun = @import("root").bun;
const Environment = @import("./env.zig");
const PlatformSpecific = switch (Environment.os) {
.mac => @import("./darwin_c.zig"),
.linux => @import("./linux_c.zig"),
.windows => @import("./windows_c.zig"),
else => struct {},
};
pub usingnamespa... | Zig | c.zig |
const c = @import("std").c;
const std = @import("std");
const bun = @import("root").bun;
const JSC = bun.JSC;
const strings = bun.strings;
const iovec = @import("std").os.iovec;
const struct_in_addr = std.os.sockaddr.in;
const struct_sockaddr = std.os.sockaddr;
pub const socklen_t = c.socklen_t;
const ares_socklen_t = ... | Zig | c_ares.zig |
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const StoredFileDescriptorType = bun.StoredFileDescriptorType;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const F... | Zig | cache.zig |
const std = @import("std");
const Allocator = @import("std").mem.Allocator;
const Node = @import("Node.zig");
const TypeNode = @import("TypeNode.zig");
const constants = @import("constants.zig");
const main = @import("../main.zig");
const Tree = @import("./tree.zig").Tree;
pub const Cache = struct {
const Child =... | Zig | cache_1.zig |
//! TODO: Delete this entire file once https://github.com/ziglang/zig/issues/18694 is resolved.
const bun = @import("root").bun;
const std = @import("std");
const os = std.os;
const windows = os.windows;
const mem = std.mem;
const unicode = std.unicode;
const fs = std.fs;
const math = std.math;
const File = fs.File;
... | Zig | child_process_windows.zig |
const std = @import("std");
const debug = std.debug;
const heap = std.heap;
const io = std.io;
const mem = std.mem;
const testing = std.testing;
const Output = @import("../../output.zig");
pub const args = @import("clap/args.zig");
test "clap" {
testing.refAllDecls(@This());
}
pub const ComptimeClap = @import("... | Zig | clap.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 FeatureFlags = ... | Zig | cli.zig |
const std = @import("std");
const net = std.net;
const Allocator = std.mem.Allocator;
const server = @import("server.zig");
const common = @import("common.zig");
const Server = @import("server.zig").Server;
const TypeNode = @import("../engine/TypeNode.zig");
const Message = common.Message;
const Status = common.Statu... | Zig | client.zig |
const JSC = @import("root").bun.JSC;
const std = @import("std");
pub const CallbackGetterFn = fn (JSC.JSValue) callconv(.C) JSC.JSValue;
pub const CallbackSetterFn = fn (JSC.JSValue, JSC.JSValue) callconv(.C) void;
pub fn CallbackWrapper(comptime Getter: *const CallbackGetterFn, comptime Setter: *const CallbackSetter... | Zig | codegen.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 | colon_list_type.zig |
const std = @import("std");
pub const Counter = extern struct {
timestamp: usize,
percent: f64,
rotate: u32,
color_values: [8 * 3]u32,
};
const RUN_COUNT = 1024;
var counters: [RUN_COUNT]Counter = undefined;
pub const Blob = extern struct {
run_count: u32,
interval: u64,
};
pub var all_time... | Zig | color-looper.emotion.zig |
const std = @import("std");
pub const Counter = extern struct {
timestamp: usize,
percent: f64,
rotate: u32,
color_values: [8 * 3]u32,
};
const RUN_COUNT = 1024;
var counters: [RUN_COUNT]Counter = undefined;
pub const Blob = extern struct {
run_count: u32,
interval: u64,
};
pub var all_time... | Zig | color-looper.zig |
const std = @import("std");
const net = std.net;
const Allocator = std.mem.Allocator;
const Server = @import("server.zig").Server;
const ServerError = Server.Error;
pub const Hello = struct {
language: []const u8,
};
pub const Response = struct {
message: []const u8,
};
pub const RawDeclaration = struct {
... | Zig | common.zig |
/// Demo app testing the macOS libcompression bindings.
const std = @import("std");
const CompressionFramework = struct {
var handle: ?*anyopaque = null;
pub fn load() !void {
handle = std.os.darwin.dlopen("libcompression.dylib", 1);
if (handle == null)
return error.@"failed to load... | Zig | compression.zig |
const clap = @import("../clap.zig");
const bun = @import("root").bun;
const std = @import("std");
const debug = std.debug;
const heap = std.heap;
const mem = std.mem;
const testing = std.testing;
/// Deprecated: Use `parseEx` instead
pub fn ComptimeClap(
comptime Id: type,
comptime params: []const clap.Param(... | Zig | comptime.zig |
const JSC = @import("root").bun.JSC;
const std = @import("std");
const mem = std.mem;
const strings = @import("./string_immutable.zig");
/// Comptime string map optimized for small sets of disparate string keys.
/// Works by separating the keys by length at comptime and only checking strings of
/// equal length at run... | Zig | comptime_string_map.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 | config.zig |
const std = @import("std");
const bun = @import("root").bun;
const string = bun.string;
const Environment = bun.Environment;
const JSC = @import("root").bun.JSC;
const ConstantType = enum { ERRNO, ERRNO_WIN, SIG, DLOPEN, OTHER };
fn getErrnoConstant(comptime name: []const u8) ?comptime_int {
return if (@hasField(... | Zig | constants.zig |
const TypeNode = @import("TypeNode.zig");
pub var PREROOT: TypeNode = undefined;
| Zig | constants_1.zig |
const std = @import("std");
const os = std.os;
const math = std.math;
const bun = @import("root").bun;
const strings = bun.strings;
const Environment = bun.Environment;
pub const CopyFileRangeError = error{
FileTooBig,
InputOutput,
/// `in` is not open for reading; or `out` is not open for writing;
/... | Zig | copy_file.zig |
const std = @import("std");
fn setup_sigactions(act: ?*const os.Sigaction) !void {
try os.sigaction(os.SIG.ABRT, act, null);
try os.sigaction(os.SIG.BUS, act, null);
try os.sigaction(os.SIG.FPE, act, null);
try os.sigaction(os.SIG.ILL, act, null);
try os.sigaction(os.SIG.SEGV, act, null);
try o... | Zig | crash_reporter.zig |
const std = @import("std");
pub fn start(_: anytype) bool {
std.debug.attachSegfaultHandler();
return true;
}
pub fn generate() void {}
pub fn crashReportPath(_: *[1024]u8) []const u8 {
return "";
}
| Zig | crash_reporter_linux.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 | create_command.zig |
const Fs = @import("fs.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 CodePoint = bun.CodePoint;
const St... | Zig | css_scanner.zig |
const std = @import("std");
const bun = @import("root").bun;
const builtin = @import("builtin");
const os = std.os;
const mem = std.mem;
const Stat = std.fs.File.Stat;
const Kind = std.fs.File.Kind;
const StatError = std.fs.File.StatError;
const off_t = std.c.off_t;
const errno = os.errno;
const zeroes = mem.zeroes;
p... | Zig | darwin_c.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;
con... | Zig | data_url.zig |
// -------------------------------------------------------------------------- //
// Copyright (c) 2019-2022, Jairus Martin. //
// Distributed under the terms of the MIT License. //
// The full license is in the file LICENSE, distributed with this software. ... | Zig | datetime.zig |
const std = @import("std");
const t = std.testing;
fn isDigit(x: u8) bool {
return '0' <= x and x <= '9';
}
fn part1(data: []const u8) !i32 {
var iter = std.mem.tokenize(u8, data, "\n");
var res: i32 = 0;
while (iter.next()) |line| {
var first: i32 = -1;
var last: i32 = -1;
for ... | Zig | day01.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 | defines-table.zig |
const std = @import("std");
const js_ast = bun.JSAst;
const logger = @import("root").bun.logger;
const js_lexer = bun.js_lexer;
const json_parser = bun.JSON;
const fs = @import("fs.zig");
const bun = @import("root").bun;
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment ... | Zig | defines.zig |
//! Modified version of `std.fs.deleteTree`:
//! - nonsense instances of `unreachable` removed
//! - uses Bun's DirIterator
//! - can pass a Context which allows you to inspect which files/directories have been deleted (needed for shell's implementation of rm with verbose flag)
const std = @import("std");
const os = st... | Zig | delete_tree.zig |
const bun = @import("root").bun;
const logger = bun.logger;
const Environment = @import("../env.zig");
const Install = @import("./install.zig");
const PackageManager = Install.PackageManager;
const ExternalStringList = Install.ExternalStringList;
const Features = Install.Features;
const PackageNameHash = Install.Packag... | Zig | dependency.zig |
const std = @import("std");
const bun = @import("root").bun;
const MutableString = bun.MutableString;
const Output = bun.Output;
const default_allocator = bun.default_allocator;
const string = bun.string;
const JSC = bun.JSC;
const JSValue = JSC.JSValue;
const JSGlobalObject = JSC.JSGlobalObject;
const ConsoleObject = ... | Zig | diff_format.zig |
const bun = @import("root").bun;
const std = @import("std");
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 | dir_info.zig |
// This is copied from std.fs.Dir.Iterator
// The differences are:
// - it returns errors in the expected format
// - doesn't mark BADF as unreachable
// - It uses PathString instead of []const u8
// - Windows can be configured to return []const u16
const builtin = @import("builtin");
const std = @import("std");
const... | Zig | dir_iterator.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 | discord_command.zig |
const Bun = @This();
const default_allocator = @import("root").bun.default_allocator;
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")... | Zig | dns_resolver.zig |
const std = @import("std");
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 JSC = @import("root").bun.JSC;
const js = JSC.C;
const Method = @import("../../http/method.zig").Method;
con... | Zig | encoding.zig |
const std = @import("std");
const Allocator = std.mem.Allocator;
const queryParser = @import("../query_parser.zig");
const TypeC = queryParser.TypeC;
pub const Declaration = struct {
name: []const u8,
ty: *TypeC,
id: usize = 0,
pub fn init(allocator: Allocator, name: []const u8, ty: *TypeC) !*Declar... | Zig | entities.zig |
const logger = @import("root").bun.logger;
const std = @import("std");
const bun = @import("root").bun;
const string = bun.string;
const Fs = @import("../fs.zig");
const js_ast = bun.JSAst;
const Bundler = bun.Bundler;
const strings = bun.strings;
pub const FallbackEntryPoint = struct {
code_buffer: [8192]u8 = und... | Zig | entry_points.zig |
// This is a copy-paste of the same file from Zig's standard library.
// This exists mostly as a workaround for https://github.com/ziglang/zig/issues/16980
const std = @import("std");
const assert = std.debug.assert;
const testing = std.testing;
const EnumField = std.builtin.Type.EnumField;
/// Returns a struct with ... | Zig | enums.zig |
const std = @import("std");
const builtin = @import("builtin");
pub const BuildTarget = enum { native, wasm, wasi };
pub const build_target: BuildTarget = brk: {
if (@import("builtin").target.isWasm()) {
break :brk BuildTarget.wasm;
} else {
break :brk BuildTarget.native;
}
};
pub const is... | Zig | env.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 | env_loader.zig |
const std = @import("std");
const server = @import("../driver/server.zig");
pub const EngineError = error{
NotYetSupported,
ShouldBeUnreachable,
} || std.mem.Allocator.Error || std.posix.ReadError || std.posix.WriteError || server.Server.Error;
| Zig | error.zig |
const std = @import("std");
const JSC = @import("root").bun.JSC;
const JSGlobalObject = JSC.JSGlobalObject;
const VirtualMachine = JSC.VirtualMachine;
const Lock = @import("../lock.zig").Lock;
const bun = @import("root").bun;
const Environment = bun.Environment;
const Fetch = JSC.WebCore.Fetch;
const WebCore = JSC.WebC... | Zig | event_loop.zig |
const std = @import("std");
const Allocator = @import("std").mem.Allocator;
const buildTree = @import("utils.zig").buildTree;
const queryParser = @import("../../query_parser.zig");
const RawDecl = @import("utils.zig").RawDecl;
// NOTE: All the tests the file are about exact search(no variance or inheritance)
test "... | Zig | exact_search_tests.zig |
const std = @import("std");
const bun = @import("root").bun;
pub fn ExactSizeMatcher(comptime max_bytes: usize) type {
switch (max_bytes) {
1, 2, 4, 8, 12, 16 => {},
else => {
@compileError("max_bytes must be 1, 2, 4, 8, or 12.");
},
}
const T = std.meta.Int(
.u... | Zig | exact_size_matcher.zig |
const std = @import("std");
const bun = @import("root").bun;
const default_allocator = bun.default_allocator;
const string = bun.string;
const MutableString = bun.MutableString;
const strings = bun.strings;
const Output = bun.Output;
const jest = bun.JSC.Jest;
const Jest = jest.Jest;
const TestRunner = jest.TestRunner;... | Zig | expect.zig |
const JSC = @import("root").bun.JSC;
const Fs = @import("../../fs.zig");
const CAPI = JSC.C;
const JS = @import("../javascript.zig");
const JSBase = @import("../base.zig");
const ZigURL = @import("../../url.zig").URL;
const Api = @import("../../api/schema.zig").Api;
const bun = @import("root").bun;
const std = @import(... | Zig | exports.zig |
const bun = @import("root").bun;
const default_allocator = bun.default_allocator;
const Global = bun.Global;
const json_parser = bun.JSON;
const logger = bun.logger;
const Output = bun.Output;
const FileSystem = @import("../fs.zig").FileSystem;
const Install = @import("./install.zig");
const DependencyID = Install.Depe... | Zig | extract_tarball.zig |
const std = @import("std");
const os = std.os;
const linux = os.linux;
const bun = @import("root").bun;
const env = bun.Environment;
const JSC = bun.JSC;
const JSValue = JSC.JSValue;
const libuv = bun.windows.libuv;
const allow_assert = env.allow_assert;
const log = bun.Output.scoped(.fs, false);
fn handleToNumber(h... | Zig | fd.zig |
const env = @import("env.zig");
pub const strong_etags_for_built_files = true;
pub const keep_alive = false;
// Debug helpers
pub const print_ast = false;
pub const disable_printing_null = false;
// This was a ~5% performance improvement
pub const store_file_descriptors = !env.isBrowser;
pub const css_in_js_import_b... | Zig | feature_flags.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 | features.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 | fetch.zig |
const Bun = @This();
const root = @import("root");
const default_allocator = bun.default_allocator;
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 = @... | Zig | ffi.zig |
const std = @import("std");
const assert = std.debug.assert;
/// An intrusive first in/first out linked list.
/// The element type T must have a field called "next" of type ?*T
pub fn FIFO(comptime T: type) type {
return struct {
const Self = @This();
in: ?*T = null,
out: ?*T = null,
... | Zig | fifo.zig |
const std = @import("std");
const Api = @import("../../api/schema.zig").Api;
const JavaScript = @import("../javascript.zig");
const QueryStringMap = @import("../../url.zig").QueryStringMap;
const CombinedScanner = @import("../../url.zig").CombinedScanner;
const bun = @import("root").bun;
const string = bun.string;
cons... | Zig | filesystem_router.zig |
const std = @import("std");
pub const fixtures = std.ComptimeStringMap([]u8, .{
.{ "package.json", @embedFile("./fixtures/package.json") },
.{ "tsconfig.json", @embedFile("./fixtures/tsconfig.json") },
.{ "simple-component.js", @embedFile("./fixtures/simple-component.js") },
.{ "simple-component.tsx", ... | Zig | fixtures.zig |
const std = @import("std");
const bun = @import("root").bun;
const Output = bun.Output;
const strings = bun.strings;
const string = bun.string;
const js_lexer = bun.js_lexer;
const ComptimeStringMap = bun.ComptimeStringMap;
const fmt = std.fmt;
const Environment = bun.Environment;
pub usingnamespace std.fmt;
const Sh... | Zig | fmt.zig |
const std = @import("std");
const PackageID = @import("../install.zig").PackageID;
const Lockfile = @import("../install.zig").Lockfile;
const PackageManager = @import("../install.zig").PackageManager;
const Npm = @import("../npm.zig");
const logger = @import("root").bun.logger;
const FileSystem = @import("../../fs.zig"... | Zig | folder_resolver.zig |
const std = @import("std");
const Allocator = @import("std").mem.Allocator;
const EngineError = @import("error.zig").EngineError;
const Node = @import("Node.zig");
const TypeNode = @import("TypeNode.zig");
pub const Following = struct {
pub const Kind = enum {
arrow, // simple function arrow
gener... | Zig | following.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 StoredFileDescriptorType = bun.StoredFileDescriptorType;
const Fi... | Zig | fs.zig |
const std = @import("std");
const bun = @import("root").bun;
const Environment = bun.Environment;
const Mutex = @import("../../lock.zig").Lock;
const sync = @import("../../sync.zig");
const Semaphore = sync.Semaphore;
const UnboundedQueue = @import("../unbounded_queue.zig").UnboundedQueue;
const TaggedPointerUnion = @i... | Zig | fs_events.zig |
//! Futex is a mechanism used to block (`wait`) and unblock (`wake`) threads using a 32bit memory address as hints.
//! Blocking a thread is acknowledged only if the 32bit memory address is equal to a given value.
//! This check helps avoid block/unblock deadlocks which occur if a `wake()` happens before a `wait()`.
//... | Zig | futex.zig |
const JSC = @import("root").bun.JSC;
pub const Classes = struct {
pub const Blob = JSC.WebCore.Blob;
pub const HTMLRewriter = JSC.Cloudflare.HTMLRewriter;
pub const Element = JSC.Cloudflare.Element;
pub const Comment = JSC.Cloudflare.Comment;
pub const TextChunk = JSC.Cloudflare.TextChunk;
pub ... | Zig | generated_classes_list.zig |
// AUTO-GENERATED FILE. Created via .scripts/write-versions.sh
pub const boringssl = "b275c5ce1c88bc06f5a967026d3c0ce1df2be815";
pub const libarchive = "dc321febde83dd0f31158e1be61a7aedda65e7a2";
pub const mimalloc = "7968d4285043401bb36573374710d47a4081a063";
pub const picohttpparser = "066d2b1e9ab820703db0837a7255d9... | Zig | generated_versions_list.zig |
const std = @import("std");
const Allocator = @import("std").mem.Allocator;
const RndGen = std.rand.DefaultPrng;
const tree = @import("engine/tree.zig");
const query = @import("query.zig");
const utils = @import("utils.zig");
pub var rnd: RndGen = undefined;rnd
fn generate() !void {
var t: tree.Tree = undefined;... | Zig | generator.zig |
const Glob = @This();
const globImpl = @import("../../glob.zig");
const globImplAscii = @import("../../glob_ascii.zig");
const GlobWalker = globImpl.BunGlobWalker;
const PathLike = @import("../node/types.zig").PathLike;
const ArgumentsSlice = @import("../node/types.zig").ArgumentsSlice;
const Syscall = @import("../../s... | Zig | glob.zig |
// Portions of this file are derived from works under the MIT License:
//
// Copyright (c) 2023 Devon Govett
// Copyright (c) 2023 Stephen Gregoratto
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in ... | Zig | glob_ascii.zig |
// Adapted from https://github.com/mitchellh/ghostty/blob/fdfa596fdf32c153a812cda7390b4a626040328f/src/unicode/grapheme.zig. Used with permission.
// Generated portion built with zig-macos-aarch64-0.12.0-dev.2823+955fd65cb.
const std = @import("std");
pub fn graphemeBreak(cp1: u21, cp2: u21, state: *BreakState) bool ... | Zig | grapheme.zig |
const getAllocator = @import("../../base.zig").getAllocator;
const bun = @import("root").bun;
const Output = bun.Output;
const std = @import("std");
const Allocator = std.mem.Allocator;
const JSC = bun.JSC;
const MutableString = bun.MutableString;
const lshpack = @import("./lshpack.zig");
const JSValue = JSC.JSValue;
... | Zig | h2_frame_parser.zig |
const std = @import("std");
const Dir = std.fs.Dir;
const FnMeta = std.builtin.Type.Fn;
const FnDecl = std.builtin.Type.Declaration.Data.FnDecl;
const StructMeta = std.builtin.Type.Struct;
const EnumMeta = std.builtin.Type.Enum;
const UnionMeta = std.builtin.Type.Union;
const warn = std.debug.warn;
const StaticExport =... | Zig | header-gen.zig |
const HeaderBuilder = @This();
const StringBuilder = @import("../string_builder.zig");
const Headers = @import("./headers.zig");
const string = @import("root").bun.string;
const HTTPClient = @import("../http.zig");
const Api = @import("../api/schema.zig").Api;
const std = @import("std");
content: StringBuilder = Strin... | Zig | header_builder.zig |
const bindings = @import("root").bun.JSC;
pub const struct_JSC__CallFrame = bindings.CallFrame;
pub const struct_JSC__StringPrototype = bindings.StringPrototype;
pub const struct_JSC__SetIteratorPrototype = bindings.SetIteratorPrototype;
pub const struct_JSC__RegExpPrototype = bindings.RegExpPrototype;
pub const struct... | Zig | headers-replacements.zig |
const Api = @import("../api/schema.zig").Api;
const std = @import("std");
pub const Kv = struct {
name: Api.StringPointer,
value: Api.StringPointer,
};
pub const Entries = std.MultiArrayList(Kv);
| Zig | headers.zig |
const std = @import("std");
const assert = std.debug.assert;
/// An intrusive heap implementation backed by a pairing heap[1] implementation.
///
/// Why? Intrusive data structures require the element type to hold the metadata
/// required for the structure, rather than an additional container structure.
/// There are... | Zig | heap.zig |
const bun = @import("root").bun;
const std = @import("std");
const HeapBreakdown = @This();
pub fn allocator(comptime T: type) std.mem.Allocator {
return malloc_zone_t.get(T).getAllocator();
}
pub const malloc_zone_t = opaque {
const Allocator = std.mem.Allocator;
const vm_size_t = usize;
pub extern ... | Zig | heap_breakdown.zig |
const std = @import("std");
const assert = std.debug.assert;
const mem = std.mem;
const testing = std.testing;
/// An array that efficiently tracks which elements are in use.
/// The pointers are intended to be stable
/// Sorta related to https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p0447r15.html
pub fn Hi... | Zig | hive_array.zig |
const std = @import("std");
const bun = @import("root").bun;
const string = bun.string;
const JSC = @import("root").bun.JSC;
const WebCore = @import("../webcore/response.zig");
const ZigString = JSC.ZigString;
const Base = @import("../base.zig");
const getAllocator = Base.getAllocator;
const JSValue = JSC.JSValue;
cons... | Zig | html_rewriter.zig |
const bun = @import("root").bun;
const picohttp = bun.picohttp;
const JSC = bun.JSC;
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 FeatureFlags = bun.FeatureFlags;
const st... | Zig | http.zig |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.