Unnamed: 0
int64 0
0
| repo_id
stringlengths 5
186
| file_path
stringlengths 15
223
| content
stringlengths 1
32.8M
⌀ |
|---|---|---|---|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/macro argument evaluation.c | AOK
1
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/empty macro block expansion.c | F_HOOK ()
F_HOOK ()
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/#if constant expression.c | long
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/zero argument macro.c | NO_ARGUMENTS
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/preserve comments in macros.c | //aro-args -E -P -CC
1 /*foo*//*bar*/ 2
1 /*foo*//*bar*/ 2
1 /*foo*/
1 /*foo*/
hello/*foo*/1
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/debug dump macro names.c | #define FOO
#define BAR
int x = 42;
#undef FOO
#define FOO |
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/var args macro functions.c | "2,3,4,5,6"
baz bar 3,4
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/debug dump macros.c | #define BAR 43 |
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/empty va args comma delete c99.c | foo(a,)
foo(a,b)
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/incorrect macro arg count.c | TWO_ARGS
TWO_ARGS
TWO_ARGS
TWO_ARGS
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/standard-concatenation-strings-example.c | printf("x" "1" "= %d, x" "2" "= %s", x1, x2);
fputs("strncmp(\"abc\\0d\", \"abc\", '\\4') == 0"
": @\n", s);
"vers2.h"
"vers2 . h"
"INCFILE(2).h"
"INCFILE(2) . h"
"hello";
"hello" ", world"
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/object macro token pasting.c | a1
a1
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/float header netbsd 6.99.26.c |
15
2.2204460492503131e-16
53
308
1024
1.7976931348623157e+308
(-307)
(-1021)
2.2250738585072014e-308
21
6
1.19209290e-7F
24
38
128
3.40282347e+38F
(-37)
(-125)
1.17549435e-38F
2
18
1.08420217248550443401e-19L
64
4932
16384
1.18973149535723176502e+4932L
(-4931)
(-16381)
3.36210314311209350626e-4932L
1
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/stringify invalid escape.c | x[""
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/unspecified expansion.c | 2*9*g
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/macro whitespace.c | "1 2"
"+ /"
"1"
"1 2"
"2"
"3"
"5"
"6"
foo bar
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/gnu variadic macros.h | "2,3,4", 1 __VA_ARGS__ 2,3,4
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/__VA_OPT__.c | 1, 2, 3, 4
a +
__VA_OPT__(1)
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/recursive object macro.c | x
x
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/paste operator whitespace.c | (AY)
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/#elifndef error.c | int
int
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/token paste delete comma gnu.c | fprintf (stderr, "foo");
fprintf (stderr, "foo",);
fprintf (stderr, "foo", "bar");
foo(a)
foo(a,b)
1,
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/digraph pretty print.c | %:%: %: <%<%> > <::>
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/macro re-expansion.c | z[0]
z[0]
z[0]
z[0]
z[0]
h (s)
1
13
z[0] z[0] Z1
1 TAU(2)
1 TAU(1) 1 z[0]
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/preserve comments.c | //aro-args -E -P -C
12
12
1
1
hello1
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/macro token pasting order.c | TEST_0
TEST_M(0)
1
a bc
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/debug dump macros and results.c | #define FOO 42
#define BAR FOO
int x = 42;
#undef FOO
#define FOO 43 |
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/standard-redefinition-reexamination-example.c | f(2 * (y+1)) + f(2 * (f(2 * (z[0])))) % f(2 * (0)) + t(1);
f(2 * (2+(3,4)-0,1)) | f(2 * (\~{ } 5)) & f(2 * (0,1))
^m(0,1);
int i[] = { 1, 23, 4, 5, };
char c[2][6] = { "hello", "" };
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/nested unterminated macro.c | ""
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/standard-placeholder-example.c | int j[] = { 123, 45, 67, 89,
10, 11, 12, };
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/nested macro call.c | x
x
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/unterminated macro function at eof gcc.c | foo
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/float header aarch64-linux-gnu.c |
15
2.2204460492503131e-16
53
308
1024
1.7976931348623157e+308
(-307)
(-1021)
2.2250738585072014e-308
36
6
1.19209290e-7F
24
38
128
3.40282347e+38F
(-37)
(-125)
1.17549435e-38F
2
33
1.92592994438723585305597794258492732e-34L
113
4932
16384
1.18973149535723176508575932662800702e+4932L
(-4931)
(-16381)
3.36210314311209350626267781732175260e-4932L
2
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/float header x86-64-linux.c |
15
2.2204460492503131e-16
53
308
1024
1.7976931348623157e+308
(-307)
(-1021)
2.2250738585072014e-308
21
6
1.19209290e-7F
24
38
128
3.40282347e+38F
(-37)
(-125)
1.17549435e-38F
2
18
1.08420217248550443401e-19L
64
4932
16384
1.18973149535723176502e+4932L
(-4931)
(-16381)
3.36210314311209350626e-4932L
0
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/source epoch.c | "Jan 1 1970"
"00:00:00"
"Thu Jan 1 00:00:00 1970"
|
0 | repos/arocc/test/cases | repos/arocc/test/cases/expanded/macro expansion exhaustion.c | (2 + 2)
|
0 | repos | repos/hexdump-zip/README.md | # hexdump-zip
produce an annotated hexdump of a zipfile
## Build
Download or install [zig](http://ziglang.org/).
(Check the commit log of this repo to see which version was used recently.)
```
zig build
```
Executable binary is at `./zig-out/bin/hexdump-zip`.
## Run
```
hexdump-zip INPUT.zip OUTPUT.hex
```
To print to stdout, you can give `/dev/stdout` as the output path.
|
0 | repos | repos/hexdump-zip/build.zig | const Build = @import("std").Build;
pub fn build(b: *Build) void {
const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{
.preferred_optimize_mode = .ReleaseSafe,
});
const exe = b.addExecutable(.{
.name = "hexdump-zip",
.root_source_file = .{ .path = "src/hexdump-zip.zig" },
.target = target,
.optimize = optimize,
});
b.installArtifact(exe);
b.default_step.dependOn(&exe.step);
}
|
0 | repos/hexdump-zip | repos/hexdump-zip/src/hexdump-zip.zig | const std = @import("std");
fn usage() !void {
std.log.err("usage: INPUT.zip OUTPUT.hex", .{});
return error.Usage;
}
pub fn main() !void {
var gpa_instance: std.heap.GeneralPurposeAllocator(.{}) = .{};
defer _ = gpa_instance.deinit();
const gpa = gpa_instance.allocator();
var args = try std.process.argsWithAllocator(gpa);
defer args.deinit();
_ = args.next() orelse return usage();
const input_path_str = args.next() orelse return usage();
const output_path_str = args.next() orelse return usage();
if (args.next() != null) return usage();
var input_file = try std.fs.cwd().openFile(input_path_str, .{});
defer input_file.close();
var output_file = try std.fs.cwd().createFile(output_path_str, .{});
defer output_file.close();
var zipfile_dumper: ZipfileDumper = undefined;
try zipfile_dumper.init(input_file, output_file, gpa);
defer zipfile_dumper.deinit();
try zipfile_dumper.doIt();
return std.process.cleanExit();
}
const SegmentList = std.ArrayList(Segment);
const SegmentKind = union(enum) {
LocalFile: LocalFileInfo,
CentralDirectoryEntries: CentralDirectoryEntriesInfo,
EndOfCentralDirectory: EndOfCentralDirectoryInfo,
};
const Segment = struct {
offset: u64,
kind: SegmentKind,
};
const LocalFileInfo = struct {
entry_index: u32,
compressed_size: u64,
is_zip64: bool,
};
const EndOfCentralDirectoryInfo = struct {
eocdr_offset: u64,
};
const CentralDirectoryEntriesInfo = struct {
entry_count: u32,
};
fn segmentLessThan(_: void, a: Segment, b: Segment) bool {
return a.offset < b.offset;
}
const Encoding = enum {
None,
Cp437,
Utf8,
};
const error_character = "\xef\xbf\xbd";
const eocdr_size = 22;
const eocdr_search_size: u64 = 0xffff + eocdr_size;
/// end of central dir signature
const eocdr_signature = 0x06054b50;
/// central file header signature
const cfh_signature = 0x02014b50;
/// local file header signature
const lfh_signature = 0x04034b50;
/// optional data descriptor optional signature
const oddo_signature = 0x08074b50;
const ZipfileDumper = struct {
input_file: std.fs.File,
file_size: u64,
offset_padding: usize,
output_file: std.fs.File,
output: @TypeOf(std.io.bufferedWriter(@as(std.fs.File.Writer, undefined))),
segments: SegmentList,
indentation: u2,
mac_archive_utility_overflow_recovery_cursor: ?u64,
const Self = @This();
pub fn init(self: *Self, input_file: std.fs.File, output_file: std.fs.File, allocator: std.mem.Allocator) !void {
// FIXME: return a new object once we have https://github.com/zig-lang/zig/issues/287
self.input_file = input_file;
self.file_size = try self.input_file.getEndPos();
// this limit eliminates most silly overflow checks on the file offset.
if (self.file_size > 0x7fffffffffffffff) return error.FileTooBig;
{
var tmp: [16]u8 = undefined;
self.offset_padding = std.fmt.formatIntBuf(tmp[0..], self.file_size, 16, .lower, .{});
}
self.output_file = output_file;
self.output = std.io.bufferedWriter(self.output_file.writer());
self.segments = SegmentList.init(allocator);
self.indentation = 0;
self.mac_archive_utility_overflow_recovery_cursor = 0;
}
pub fn deinit(self: *Self) void {
self.segments.deinit();
self.* = undefined;
}
pub fn doIt(self: *Self) !void {
try self.findSegments();
try self.dumpSegments();
try self.output.flush();
}
fn findSegments(self: *Self) !void {
// find the eocdr
if (self.file_size < eocdr_size) return error.NotAZipFile;
var eocdr_search_buffer: [eocdr_search_size]u8 = undefined;
const eocdr_search_slice = eocdr_search_buffer[0..@min(self.file_size, eocdr_search_size)];
try self.readNoEof(self.file_size - eocdr_search_slice.len, eocdr_search_slice);
// seek backward over the comment looking for the signature
var comment_length: u16 = 0;
var eocdr_buffer: []const u8 = undefined;
while (true) : (comment_length += 1) {
const cursor = eocdr_search_slice.len - comment_length - eocdr_size;
if (readInt32(eocdr_search_slice, cursor) == eocdr_signature) {
// found it
eocdr_buffer = eocdr_search_slice[cursor .. cursor + eocdr_size];
break;
}
if (cursor == 0) return error.NotAZipFile;
}
const eocdr_offset = self.file_size - comment_length - eocdr_size;
const disk_number = readInt16(eocdr_buffer, 4);
if (disk_number != 0) return error.MultiDiskZipfileNotSupported;
var entry_count: u32 = readInt16(eocdr_buffer, 10);
const size_of_central_directory: u64 = readInt32(eocdr_buffer, 12);
var central_directory_offset: u64 = readInt32(eocdr_buffer, 16);
// TODO: check for ZIP64 format
// check for Mac Archive Utility corruption in the central directory location and size
if (eocdr_offset > 0xffffffff) {
const calculated_central_directory_offset = std.math.sub(u64, eocdr_offset, size_of_central_directory) catch return error.SizeOfCentralDirectoryOverflow;
if (central_directory_offset != calculated_central_directory_offset and
central_directory_offset == calculated_central_directory_offset & 0xffffffff)
{
// Uh oh.
// The alleged size and location of the central appear to have
// been corrupted by the mac archive utility overflow bug.
// Where does the central directory really start?
// Assume it's smaller than 4GB, and search backwards.
central_directory_offset = calculated_central_directory_offset;
while (true) {
if (self.isSignatureAt(central_directory_offset, cfh_signature)) {
// found it.
var warning_count: u2 = 0;
if (central_directory_offset > 0xffffffff) {
self.detectedMauCorruption("offset of start of central directory with respect to the starting disk number");
warning_count += 1;
}
if (central_directory_offset < calculated_central_directory_offset) {
self.detectedMauCorruption("size of the central directory");
warning_count += 1;
}
std.debug.assert(warning_count > 0);
break;
}
central_directory_offset = std.math.sub(u64, central_directory_offset, 0x100000000) catch return error.CentralDirectoryNotFound;
}
}
}
var central_directory_cursor: u64 = central_directory_offset;
{
var entry_index: u32 = 0;
while (entry_index < entry_count) : (entry_index += 1) {
var cfh_buffer: [46]u8 = undefined;
try self.readNoEof(central_directory_cursor, cfh_buffer[0..]);
var compressed_size: u64 = readInt32(&cfh_buffer, 20);
const file_name_length = readInt16(&cfh_buffer, 28);
const extra_fields_length = readInt16(&cfh_buffer, 30);
const file_comment_length = readInt16(&cfh_buffer, 32);
var local_header_offset: u64 = readInt32(&cfh_buffer, 42);
// TODO: check for ZIP64 format
central_directory_cursor += 46;
central_directory_cursor += file_name_length;
central_directory_cursor += extra_fields_length;
central_directory_cursor += file_comment_length;
// check mac stuff
if (self.mac_archive_utility_overflow_recovery_cursor) |*mac_archive_utility_overflow_recovery_cursor| mac_stuff: {
// There might be something fishy going on with overflow.
// Check if the local header is really where it's supposed to be.
if (local_header_offset != mac_archive_utility_overflow_recovery_cursor.* & 0xffffffff) {
// Non-contiguous entries. This is definitely not a mac zip.
self.mac_archive_utility_overflow_recovery_cursor = null;
break :mac_stuff;
}
if (local_header_offset != mac_archive_utility_overflow_recovery_cursor.*) {
// this really looks like corruption.
// peek and see if there's a signature where we suspect.
if (self.isSignatureAt(mac_archive_utility_overflow_recovery_cursor.*, lfh_signature)) {
// ok *maybe* this is a coincidence, but it really looks like corruption.
self.detectedMauCorruption("relative offset of local header");
local_header_offset = mac_archive_utility_overflow_recovery_cursor.*;
}
}
// ok. we've found the local file header.
// now what's the compressed size really?
// peek at the local file header's fields
var lfh_buffer: [30]u8 = undefined;
try self.readNoEof(local_header_offset, lfh_buffer[0..]);
const local_file_name_length = readInt16(&lfh_buffer, 26);
const local_extra_fields_length = readInt16(&lfh_buffer, 28);
mac_archive_utility_overflow_recovery_cursor.* += 30;
mac_archive_utility_overflow_recovery_cursor.* += local_file_name_length;
mac_archive_utility_overflow_recovery_cursor.* += local_extra_fields_length;
mac_archive_utility_overflow_recovery_cursor.* += compressed_size;
// allegedly the cursor is now pointing to the end of the data
const next_thing_start_offset = next_thing_start_offset: {
if (entry_index == entry_count - 1) {
// Supposedly this is the last entry.
if (central_directory_cursor < eocdr_offset) {
// There's apparently unused space in the central directory.
// I wonder if there's actually more entries here.
if (self.isSignatureAt(central_directory_cursor, cfh_signature)) {
// Yep. There's more entries.
self.detectedMauCorruption("total number of entries in the central directory");
entry_count += 0x10000;
}
}
}
if (entry_index == entry_count - 1) {
// This is the last entry.
break :next_thing_start_offset central_directory_offset;
}
// This is not the last entry.
// Read the relative offset of local header for the *next* entry.
// Note that this value itself might be affected by overflow corruption.
break :next_thing_start_offset self.readInt32At(central_directory_cursor + 42) catch {
// There're not enough entries in here.
// This will be an error elsewhere.
self.mac_archive_utility_overflow_recovery_cursor = null;
break :mac_stuff;
};
};
// Mac Archive Utility sometimes includes a 16-byte data descriptor,
// and then the next thing starts immediately afterward.
const distance_to_next_thing = (next_thing_start_offset & 0xffffffff) -% (mac_archive_utility_overflow_recovery_cursor.* & 0xffffffff);
const expect_oddo = if (distance_to_next_thing == 0) false else if (distance_to_next_thing == 16) true else {
// This is not the work of the Mac Archive Utility.
self.mac_archive_utility_overflow_recovery_cursor = null;
break :mac_stuff;
};
// We're reasonably certain we're dealing with mac archive utility.
// Go searching for the signature of the next thing to find the end of this thing.
while (true) {
const possible_signature = self.readInt32At(mac_archive_utility_overflow_recovery_cursor.*) catch {
// Didn't find the signature?
// I guess this isn't a Mac Archive Utility zip file.
self.mac_archive_utility_overflow_recovery_cursor = null;
break :mac_stuff;
};
if (possible_signature == if (expect_oddo) oddo_signature else if (entry_index == entry_count - 1) cfh_signature else @as(u32, lfh_signature)) {
// This is *probably* the end of the file contents.
// Or maybe this signature just happens to show up in the file contents.
// It's impossible to avoid ambiguities like this when trying to recover from the corruption,
// so let's just charge ahead with our heuristic.
if (expect_oddo) {
mac_archive_utility_overflow_recovery_cursor.* += 16;
}
break;
}
// Assume we're dealing with overflow.
mac_archive_utility_overflow_recovery_cursor.* += 0x100000000;
compressed_size += 0x100000000;
}
if (compressed_size > 0xffffffff) {
self.detectedMauCorruption("compressed size");
}
}
try self.segments.append(Segment{
.offset = local_header_offset,
.kind = SegmentKind{
.LocalFile = LocalFileInfo{
.entry_index = entry_index,
.is_zip64 = false,
.compressed_size = compressed_size,
},
},
});
}
}
if (entry_count > 0) {
try self.segments.append(Segment{
.offset = central_directory_offset,
.kind = SegmentKind{
.CentralDirectoryEntries = CentralDirectoryEntriesInfo{ .entry_count = entry_count },
},
});
}
try self.segments.append(Segment{
.offset = eocdr_offset,
.kind = SegmentKind{
.EndOfCentralDirectory = EndOfCentralDirectoryInfo{ .eocdr_offset = eocdr_offset },
},
});
}
fn dumpSegments(self: *Self) !void {
std.sort.insertion(Segment, self.segments.items, {}, segmentLessThan);
var cursor: u64 = 0;
for (self.segments.items, 0..) |segment, i| {
if (i != 0) {
try self.write("\n");
}
if (segment.offset > cursor) {
try self.writeSectionHeader(cursor, "Unused space", .{});
try self.dumpBlobContents(cursor, segment.offset - cursor, Encoding.None);
try self.write("\n");
cursor = segment.offset;
} else if (segment.offset < cursor) {
cursor = segment.offset;
@panic("TODO: overlapping regions");
}
const length = switch (segment.kind) {
SegmentKind.LocalFile => |info| try self.dumpLocalFile(segment.offset, info),
SegmentKind.CentralDirectoryEntries => |info| try self.dumpCentralDirectoryEntries(segment.offset, info),
SegmentKind.EndOfCentralDirectory => |info| try self.dumpEndOfCentralDirectory(segment.offset, info),
};
cursor += length;
}
}
fn dumpLocalFile(self: *Self, offset: u64, info: LocalFileInfo) !u64 {
var cursor = offset;
var lfh_buffer: [30]u8 = undefined;
try self.readNoEof(cursor, lfh_buffer[0..]);
if (readInt32(&lfh_buffer, 0) != lfh_signature) {
try self.writeSectionHeader(offset, "WARNING: invalid local file header signature", .{});
try self.write("\n");
// if this isn't a local file, idk what it is.
// call it unknown
return 0;
}
try self.writeSectionHeader(offset, "Local File Header (#{})", .{info.entry_index});
var lfh_cursor: usize = 0;
try self.readStructField(&lfh_buffer, 4, &lfh_cursor, 4, "Local file header signature");
try self.readStructField(&lfh_buffer, 4, &lfh_cursor, 2, "Version needed to extract (minimum)");
try self.readStructField(&lfh_buffer, 4, &lfh_cursor, 2, "General purpose bit flag");
try self.readStructField(&lfh_buffer, 4, &lfh_cursor, 2, "Compression method");
try self.readStructField(&lfh_buffer, 4, &lfh_cursor, 2, "File last modification time");
try self.readStructField(&lfh_buffer, 4, &lfh_cursor, 2, "File last modification date");
try self.readStructField(&lfh_buffer, 4, &lfh_cursor, 4, "CRC-32");
try self.readStructField(&lfh_buffer, 4, &lfh_cursor, 4, "Compressed size");
try self.readStructField(&lfh_buffer, 4, &lfh_cursor, 4, "Uncompressed size");
try self.readStructField(&lfh_buffer, 4, &lfh_cursor, 2, "File name length (n)");
try self.readStructField(&lfh_buffer, 4, &lfh_cursor, 2, "Extra field length (m)");
cursor += lfh_cursor;
const file_name_length = readInt16(&lfh_buffer, 26);
const general_purpose_bit_flag = readInt16(&lfh_buffer, 6);
const is_utf8 = general_purpose_bit_flag & 0x800 != 0;
const extra_fields_length = readInt16(&lfh_buffer, 28);
if (file_name_length > 0) {
self.indent();
defer self.outdent();
try self.write("\n");
try self.writeSectionHeader(cursor, "File Name", .{});
try self.dumpBlobContents(cursor, file_name_length, if (is_utf8) Encoding.Utf8 else Encoding.Cp437);
cursor += file_name_length;
}
if (extra_fields_length > 0) {
self.indent();
defer self.outdent();
try self.write("\n");
try self.writeSectionHeader(cursor, "Extra Fields", .{});
try self.dumpBlobContents(cursor, extra_fields_length, Encoding.None);
cursor += extra_fields_length;
}
if (info.compressed_size > 0) {
try self.write("\n");
try self.writeSectionHeader(cursor, "File Contents", .{});
try self.dumpBlobContents(cursor, info.compressed_size, Encoding.None);
cursor += info.compressed_size;
}
// check for the optional data descriptor
var data_descriptor_buffer: [16]u8 = undefined;
if (self.readNoEof(cursor, data_descriptor_buffer[0..])) {
if (readInt32(&data_descriptor_buffer, 0) == oddo_signature) {
// this is a data descriptor
try self.write("\n");
try self.writeSectionHeader(cursor, "Optional Data Descriptor", .{});
var data_descriptor_cursor: usize = 0;
try self.readStructField(&data_descriptor_buffer, 4, &data_descriptor_cursor, 4, "optional data descriptor signature");
try self.readStructField(&data_descriptor_buffer, 4, &data_descriptor_cursor, 4, "crc-32");
try self.readStructField(&data_descriptor_buffer, 4, &data_descriptor_cursor, 4, "compressed size");
try self.readStructField(&data_descriptor_buffer, 4, &data_descriptor_cursor, 4, "uncompressed size");
cursor += data_descriptor_cursor;
}
} else |_| {
// ok, so there's no optional data descriptor here
}
return cursor - offset;
}
fn dumpCentralDirectoryEntries(self: *Self, offset: u64, info: CentralDirectoryEntriesInfo) !u64 {
var cursor = offset;
{
var i: u32 = 0;
while (i < info.entry_count) : (i += 1) {
if (i > 0) try self.write("\n");
var cdr_buffer: [46]u8 = undefined;
try self.readNoEof(cursor, cdr_buffer[0..]);
if (readInt32(&cdr_buffer, 0) != cfh_signature) {
try self.writeSectionHeader(cursor, "WARNING: invalid central file header signature", .{});
try self.write("\n");
return 0;
}
try self.writeSectionHeader(cursor, "Central Directory Entry (#{})", .{i});
var cdr_cursor: usize = 0;
try self.readStructField(&cdr_buffer, 4, &cdr_cursor, 4, "Central directory file header signature");
try self.readStructField(&cdr_buffer, 4, &cdr_cursor, 2, "Version made by");
try self.readStructField(&cdr_buffer, 4, &cdr_cursor, 2, "Version needed to extract (minimum)");
try self.readStructField(&cdr_buffer, 4, &cdr_cursor, 2, "General purpose bit flag");
try self.readStructField(&cdr_buffer, 4, &cdr_cursor, 2, "Compression method");
try self.readStructField(&cdr_buffer, 4, &cdr_cursor, 2, "File last modification time");
try self.readStructField(&cdr_buffer, 4, &cdr_cursor, 2, "File last modification date");
try self.readStructField(&cdr_buffer, 4, &cdr_cursor, 4, "CRC-32");
try self.readStructField(&cdr_buffer, 4, &cdr_cursor, 4, "Compressed size");
try self.readStructField(&cdr_buffer, 4, &cdr_cursor, 4, "Uncompressed size");
try self.readStructField(&cdr_buffer, 4, &cdr_cursor, 2, "File name length (n)");
try self.readStructField(&cdr_buffer, 4, &cdr_cursor, 2, "Extra field length (m)");
try self.readStructField(&cdr_buffer, 4, &cdr_cursor, 2, "File comment length (k)");
try self.readStructField(&cdr_buffer, 4, &cdr_cursor, 2, "Disk number where file starts");
try self.readStructField(&cdr_buffer, 4, &cdr_cursor, 2, "Internal file attributes");
try self.readStructField(&cdr_buffer, 4, &cdr_cursor, 4, "External file attributes");
try self.readStructField(&cdr_buffer, 4, &cdr_cursor, 4, "Relative offset of local file header");
cursor += cdr_cursor;
const general_purpose_bit_flag = readInt16(&cdr_buffer, 8);
const is_utf8 = general_purpose_bit_flag & 0x800 != 0;
const file_name_length = readInt16(&cdr_buffer, 28);
const extra_fields_length = readInt16(&cdr_buffer, 30);
const file_comment_length = readInt16(&cdr_buffer, 32);
if (file_name_length > 0) {
self.indent();
defer self.outdent();
try self.writeSectionHeader(cursor, "File name", .{});
try self.dumpBlobContents(cursor, file_name_length, if (is_utf8) Encoding.Utf8 else Encoding.Cp437);
cursor += file_name_length;
}
if (extra_fields_length > 0) {
self.indent();
defer self.outdent();
try self.writeSectionHeader(cursor, "Extra Fields", .{});
try self.dumpBlobContents(cursor, extra_fields_length, Encoding.None);
cursor += extra_fields_length;
}
if (file_comment_length > 0) {
self.indent();
defer self.outdent();
try self.writeSectionHeader(cursor, "File Comment", .{});
try self.dumpBlobContents(cursor, file_comment_length, Encoding.Cp437);
cursor += file_comment_length;
}
}
}
return cursor - offset;
}
fn dumpEndOfCentralDirectory(self: *Self, offset: u64, info: EndOfCentralDirectoryInfo) !u64 {
var total_length: u64 = 0;
if (offset != info.eocdr_offset) {
const zip64_eocdl_offset = info.eocdr_offset - 20;
try self.writeSectionHeader(offset, "Zip64 end of central directory record", .{});
try self.writeSectionHeader(zip64_eocdl_offset, "Zip64 end of central directory locator", .{});
total_length = info.eocdr_offset - offset;
@panic("TODO");
}
try self.writeSectionHeader(offset + total_length, "End of central directory record", .{});
var eocdr_buffer: [22]u8 = undefined;
try self.readNoEof(offset, eocdr_buffer[0..]);
var eocdr_cursor: usize = 0;
try self.readStructField(&eocdr_buffer, 4, &eocdr_cursor, 4, "End of central directory signature");
try self.readStructField(&eocdr_buffer, 4, &eocdr_cursor, 2, "Number of this disk");
try self.readStructField(&eocdr_buffer, 4, &eocdr_cursor, 2, "Disk where central directory starts");
try self.readStructField(&eocdr_buffer, 4, &eocdr_cursor, 2, "Number of central directory records on this disk");
try self.readStructField(&eocdr_buffer, 4, &eocdr_cursor, 2, "Total number of central directory records");
try self.readStructField(&eocdr_buffer, 4, &eocdr_cursor, 4, "Size of central directory (bytes)");
try self.readStructField(&eocdr_buffer, 4, &eocdr_cursor, 4, "Offset of start of central directory, relative to start of archive");
try self.readStructField(&eocdr_buffer, 4, &eocdr_cursor, 2, "Comment Length");
const comment_length = readInt16(&eocdr_buffer, 20);
total_length += 22;
if (comment_length > 0) {
self.indent();
defer self.outdent();
try self.writeSectionHeader(offset + total_length, ".ZIP file comment", .{});
try self.dumpBlobContents(offset + total_length, comment_length, Encoding.Cp437);
total_length += comment_length;
}
return total_length;
}
fn dumpBlobContents(self: *Self, offset: u64, length: u64, encoding: Encoding) !void {
var buffer: [0x1000]u8 = undefined;
const row_length = 16;
var utf8_byte_sequence_buffer: [4]u8 = undefined;
var utf8_bytes_saved: usize = 0;
var utf8_bytes_remaining: usize = 0;
var cursor: u64 = 0;
while (cursor < length) {
const buffer_offset = offset + cursor;
try self.readNoEof(buffer_offset, buffer[0..@min(buffer.len, length - cursor)]);
try self.printIndentation();
const row_start = offset + cursor - buffer_offset;
{
var i: usize = 0;
while (i < row_length - 1 and cursor < length - 1) : (i += 1) {
try self.printf("{x:0>2} ", .{buffer[offset + cursor - buffer_offset]});
cursor += 1;
}
}
try self.printf("{x:0>2}", .{buffer[offset + cursor - buffer_offset]});
cursor += 1;
var row = buffer[row_start .. offset + cursor - buffer_offset];
switch (encoding) {
Encoding.None => {},
Encoding.Cp437 => {
if (length > row_length) {
var i: usize = row.len;
while (i < row_length) : (i += 1) {
try self.write(" ");
}
}
try self.write(" ; cp437\"");
for (row) |c| {
try self.write(cp437[c]);
}
try self.write("\"");
},
Encoding.Utf8 => {
if (length > row_length) {
var i: usize = row.len;
while (i < row_length) : (i += 1) {
try self.write(" ");
}
}
try self.write(" ; utf8\"");
// input is utf8; output is utf8.
var i: usize = 0;
if (utf8_bytes_remaining > 0) {
while (i < utf8_bytes_remaining) : (i += 1) {
utf8_byte_sequence_buffer[utf8_bytes_saved + i] = row[i];
}
try self.dumpUtf8Codepoint(utf8_byte_sequence_buffer[0 .. utf8_bytes_saved + utf8_bytes_remaining]);
utf8_bytes_saved = 0;
utf8_bytes_remaining = 0;
}
while (i < row.len) : (i += 1) {
const utf8_length = std.unicode.utf8ByteSequenceLength(row[i]) catch {
// invalid utf8 start byte. replace with the error character.
try self.write(error_character);
continue;
};
if (i + utf8_length > row.len) {
// this sequence wraps onto the next line.
if (i + utf8_length - row.len > length - cursor) {
// there is no next line. unexpected eof.
try self.write(error_character);
break;
}
var j: usize = 0;
while (j < row.len - i) : (j += 1) {
utf8_byte_sequence_buffer[j] = row[i + j];
}
utf8_bytes_saved = j;
utf8_bytes_remaining = utf8_length - j;
break;
}
// we have a complete codepoint on this row
try self.dumpUtf8Codepoint(row[i .. i + utf8_length]);
i += utf8_length - 1;
}
try self.write("\"");
},
}
try self.write("\n");
}
}
fn dumpUtf8Codepoint(self: *Self, byte_sequence: []const u8) !void {
const codepoint = std.unicode.utf8Decode(byte_sequence) catch {
// invalid utf8 seequcne becomes a single error character.
return self.write(error_character);
};
// some special escapes
switch (codepoint) {
'\n' => return self.write("\\n"),
'\r' => return self.write("\\r"),
'\t' => return self.write("\\t"),
'"' => return self.write("\\\""),
'\\' => return self.write("\\\\"),
else => {},
}
// numeric escapes
switch (codepoint) {
// ascii control codes
0...0x1f, 0x7f => return self.printf("\\x{x:0>2}", .{codepoint}),
// unicode newline characters
0x805, 0x2028, 0x2029 => return self.printf("\\u{x:0>4}", .{codepoint}),
else => {},
}
// literal character
return self.write(byte_sequence);
}
fn writeSectionHeader(self: *Self, offset: u64, comptime fmt: []const u8, args: anytype) !void {
var offset_str_buf: [16]u8 = undefined;
const offset_str = offset_str_buf[0..std.fmt.formatIntBuf(offset_str_buf[0..], offset, 16, .lower, .{ .width = self.offset_padding, .fill = '0' })];
try self.printIndentation();
try self.printf(":0x{s} ; ", .{offset_str});
try self.printf(fmt, args);
try self.write("\n");
}
fn readStructField(
self: *Self,
buffer: []const u8,
comptime max_size: usize,
cursor: *usize,
comptime size: usize,
name: []const u8,
) !void {
comptime std.debug.assert(size <= max_size);
const decimal_width_str = comptime switch (max_size) {
2 => "5",
4 => "10",
8 => "20",
else => unreachable,
};
try self.printIndentation();
switch (size) {
2 => {
const value = readInt16(buffer, cursor.*);
try self.printf( //
"{x:0>2} {x:0>2}" ++ (" " ** (max_size - size)) ++
" ; \"{s}{s}\"" ++ (" " ** (max_size - size)) ++
" ; {d:0>" ++ decimal_width_str ++ "}" ++
" ; 0x{x:0>4}" ++ (" " ** (max_size - size)) ++
" ; {s}" ++
"\n", .{
buffer[cursor.* + 0],
buffer[cursor.* + 1],
cp437[buffer[cursor.* + 0]],
cp437[buffer[cursor.* + 1]],
value,
value,
name,
});
},
4 => {
const value = readInt32(buffer, cursor.*);
try self.printf( //
"{x:0>2} {x:0>2} {x:0>2} {x:0>2}" ++ (" " ** (max_size - size)) ++
" ; \"{s}{s}{s}{s}\"" ++ (" " ** (max_size - size)) ++
" ; {d:0>" ++ decimal_width_str ++ "}" ++
" ; 0x{x:0>8}" ++ (" " ** (max_size - size)) ++
" ; {s}" ++
"\n", .{
buffer[cursor.* + 0],
buffer[cursor.* + 1],
buffer[cursor.* + 2],
buffer[cursor.* + 3],
cp437[buffer[cursor.* + 0]],
cp437[buffer[cursor.* + 1]],
cp437[buffer[cursor.* + 2]],
cp437[buffer[cursor.* + 3]],
value,
value,
name,
});
},
8 => @panic("TODO"),
else => unreachable,
}
cursor.* += size;
}
fn detectedMauCorruption(_: *Self, field_name: []const u8) void {
std.log.warn("WARNING: detected Mac Archive Utility corruption in field: {s}", .{field_name});
}
fn indent(self: *Self) void {
self.indentation += 1;
}
fn outdent(self: *Self) void {
self.indentation -= 1;
}
fn printIndentation(self: *Self) !void {
{
var i: u2 = 0;
while (i < self.indentation) : (i += 1) {
try self.write(" ");
}
}
}
fn write(self: *Self, str: []const u8) !void {
try self.output.writer().writeAll(str);
}
fn printf(self: *Self, comptime fmt: []const u8, args: anytype) !void {
try self.output.writer().print(fmt, args);
}
fn readNoEof(self: *Self, offset: u64, buffer: []u8) !void {
try self.input_file.seekTo(offset);
try self.input_file.reader().readNoEof(buffer);
}
fn readByteAt(self: *Self, offset: u64) !u8 {
var buffer: [1]u8 = undefined;
try self.readNoEof(offset, buffer[0..]);
return buffer[0];
}
fn readInt32At(self: *Self, offset: u64) !u32 {
var buffer: [4]u8 = undefined;
try self.readNoEof(offset, buffer[0..]);
return readInt32(&buffer, 0);
}
fn isSignatureAt(self: *Self, offset: u64, signature: u32) bool {
return signature == (self.readInt32At(offset) catch return false);
}
};
fn readInt16(buffer: []const u8, offset: usize) u16 {
return std.mem.readInt(u16, buffer[offset..][0..2], .little);
}
fn readInt32(buffer: []const u8, offset: usize) u32 {
return std.mem.readInt(u32, buffer[offset..][0..4], .little);
}
fn readInt64(buffer: []const u8, offset: usize) u64 {
return std.mem.readInt(u64, buffer[offset..][0..8], .little);
}
const cp437 = [_][]const u8{
"�", "☺", "☻", "♥", "♦", "♣", "♠", "•", "◘", "○", "◙", "♂", "♀", "♪", "♫", "☼",
"►", "◄", "↕", "‼", "¶", "§", "▬", "↨", "↑", "↓", "→", "←", "∟", "↔", "▲", "▼",
" ", "!", "\"", "#", "$", "%", "&", "'", "(", ")", "*", "+", ",", "-", ".", "/",
"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ":", ";", "<", "=", ">", "?",
"@", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O",
"P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "[", "\\", "]", "^", "_",
"`", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o",
"p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "{", "|", "}", "~", "⌂",
"Ç", "ü", "é", "â", "ä", "à", "å", "ç", "ê", "ë", "è", "ï", "î", "ì", "Ä", "Å",
"É", "æ", "Æ", "ô", "ö", "ò", "û", "ù", "ÿ", "Ö", "Ü", "¢", "£", "¥", "₧", "ƒ",
"á", "í", "ó", "ú", "ñ", "Ñ", "ª", "º", "¿", "⌐", "¬", "½", "¼", "¡", "«", "»",
"░", "▒", "▓", "│", "┤", "╡", "╢", "╖", "╕", "╣", "║", "╗", "╝", "╜", "╛", "┐",
"└", "┴", "┬", "├", "─", "┼", "╞", "╟", "╚", "╔", "╩", "╦", "╠", "═", "╬", "╧",
"╨", "╤", "╥", "╙", "╘", "╒", "╓", "╫", "╪", "┘", "┌", "█", "▄", "▌", "▐", "▀",
"α", "ß", "Γ", "π", "Σ", "σ", "µ", "τ", "Φ", "Θ", "Ω", "δ", "∞", "φ", "ε", "∩",
"≡", "±", "≥", "≤", "⌠", "⌡", "÷", "≈", "°", "∙", "·", "√", "ⁿ", "²", "■", " ",
};
|
0 | repos | repos/zig-generator/zig.mod | id: 9xwrubjr5dq4etfef4rbwkccintq9ear6atnefhv2bffx4y6
name: generator
main: src/lib.zig
license: MIT
description: Async generator type
dev_dependencies:
- src: git https://github.com/Hejsil/zig-bench
|
0 | repos | repos/zig-generator/benchmarks.zig | const std = @import("std");
const generator = @import("generator");
const Handle = generator.Handle;
const Generator = generator.Generator;
const Map = generator.Map;
pub const io_mode = .evented;
const expect = std.testing.expect;
pub fn main() !void {
try benchDrain();
try benchGeneratorVsCallback();
}
pub fn benchDrain() !void {
std.debug.print("\n=== Benchmark: generator draining\n", .{});
const ty = struct {
n: usize,
pub fn generate(self: *@This(), handle: *Handle(u8)) !u8 {
while (self.n > 0) {
try handle.yield(1);
self.n -= 1;
}
return 3;
}
};
// ensure they behave as expected
const G = Generator(ty, u8);
var g = G.init(ty{ .n = 1 });
try g.drain();
try expect(g.state.Returned == 3);
// measure performance
const bench = @import("bench");
try bench.benchmark(struct {
pub const args = [_]usize{ 1, 2, 3, 5, 10, 100 };
pub const arg_names = [_][]const u8{ "1", "2", "3", "5", "10", "100" };
pub fn return_value(n: usize) !void {
var gen = G.init(ty{ .n = n });
try gen.drain();
try expect(gen.state.Returned == 3);
}
});
}
pub fn benchGeneratorVsCallback() !void {
const W = fn (u8) callconv(.Async) anyerror!void;
const busy_work = struct {
fn do(_: u8) callconv(.Async) !void {
std.os.nanosleep(0, 10);
}
};
const no_work = struct {
fn do(_: u8) callconv(.Async) !void {}
};
_ = no_work;
std.debug.print("\n=== Benchmark: generator vs callback\n", .{});
const ty = struct {
pub fn generate(_: *@This(), handle: *Handle(u8)) !u8 {
try handle.yield(0);
try handle.yield(1);
try handle.yield(2);
return 3;
}
};
const tyc = struct {
pub fn run(_: *@This(), cb: fn (u8) callconv(.Async) anyerror!void) !u8 {
var frame_buffer: [64]u8 align(@alignOf(@Frame(busy_work.do))) = undefined;
var result: anyerror!void = undefined;
suspend {
resume @frame();
}
try await @asyncCall(&frame_buffer, &result, cb, .{0});
suspend {
resume @frame();
}
try await @asyncCall(&frame_buffer, &result, cb, .{1});
suspend {
resume @frame();
}
try await @asyncCall(&frame_buffer, &result, cb, .{2});
return 3;
}
};
// ensure they behave as expected
const G = Generator(ty, u8);
var g = G.init(ty{});
try g.drain();
try expect(g.state.Returned == 3);
// measure performance
const bench = @import("bench");
try bench.benchmark(struct {
pub const args = [_]W{
no_work.do,
busy_work.do,
};
pub const arg_names = [_][]const u8{
"no work",
"busy work",
};
pub fn generator(w: W) !void {
var gen = G.init(ty{});
var frame_buffer: [64]u8 align(@alignOf(@Frame(busy_work.do))) = undefined;
var result: anyerror!void = undefined;
while (try gen.next()) |v| {
try await @asyncCall(&frame_buffer, &result, w, .{v});
}
try expect(gen.state.Returned == 3);
}
pub fn callback(w: W) !void {
var c = tyc{};
try expect((try await async c.run(w)) == 3);
}
});
}
|
0 | repos | repos/zig-generator/zigmod.lock | 2
git https://github.com/Hejsil/zig-bench commit-3810f2e56129374c48c54f6fde995e3c941d7976
|
0 | repos | repos/zig-generator/README.md | # Zig Generator
This library provides a way to write generators in Zig.
Features:
* Supports async generator functions
* Propagates generator errors
* Return value capture
## Usage
Here's an example of its basic usage:
```zig
const std = @import("std");
const gen = @import("generator");
const Ty = struct {
pub fn generate(_: *@This(), handle: *gen.Handle(u8)) !u8 {
try handle.yield(0);
try handle.yield(1);
try handle.yield(2);
return 3;
}
};
const G = gen.Generator(Ty, u8);
pub const io_mode = .evented;
pub fn main() !void {
var g = G.init(Ty{});
std.debug.assert((try g.next()).? == 0);
std.debug.assert((try g.next()).? == 1);
std.debug.assert((try g.next()).? == 2);
std.debug.assert((try g.next()) == null);
std.debug.assert(g.state.Returned == 3);
}
```
|
0 | repos | repos/zig-generator/build.zig | const deps = @import("./deps.zig");
const std = @import("std");
pub fn build(b: *std.build.Builder) void {
// Standard release options allow the person running `zig build` to select
// between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
const mode = b.standardReleaseOptions();
const lib = b.addStaticLibrary("zig-generator", "src/lib.zig");
lib.setBuildMode(mode);
lib.install();
const tests = b.addTest("src/tests.zig");
tests.test_evented_io = true;
tests.setBuildMode(mode);
const test_step = b.step("test", "Run library tests");
test_step.dependOn(&tests.step);
const benchmarks = b.addExecutable("zig-generator-benchmarks", "benchmarks.zig");
benchmarks.setBuildMode(.ReleaseFast);
benchmarks.install();
const run_benchmarks = benchmarks.run();
run_benchmarks.step.dependOn(b.getInstallStep());
const benchmarks_step = b.step("bench", "Run benchmarks");
benchmarks_step.dependOn(&run_benchmarks.step);
deps.addAllTo(lib);
deps.addAllTo(tests);
deps.addAllTo(benchmarks);
}
|
0 | repos/zig-generator | repos/zig-generator/src/map.zig | const std = @import("std");
const generator = @import("./generator.zig");
const extractFn = @import("./_.zig").extractFn;
fn initializer(comptime Self: type, comptime G: type, comptime F: type, comptime stateful: bool) type {
return if (stateful) struct {
pub const Mapper = F;
pub fn init(inner: G, f_state: F) Self {
return Self{
.inner = inner,
.state = f_state,
};
}
} else struct {
pub fn init(inner: G) Self {
return Self{
.inner = inner,
};
}
};
}
/// `Map` creates a generator that maps yielded values from wrapped generator `G` of type `I` to type `O`
pub fn Map(comptime G: type, comptime I: type, comptime O: type, comptime F: type, comptime stateful: bool) type {
const f = if (stateful) extractFn(F, fn (*F, I) O) else extractFn(F, fn (I) O);
return generator.Generator(struct {
pub const Inner = G;
inner: G,
state: if (stateful) F else void = undefined,
pub usingnamespace initializer(@This(), G, F, stateful);
pub fn generate(self: *@This(), handle: *generator.Handle(O)) !void {
while (try self.inner.next()) |v| {
if (stateful) try handle.yield(f(&self.state, v)) else try handle.yield(f(v));
}
}
}, I);
}
test {
const expect = std.testing.expect;
const ty = struct {
pub fn generate(_: *@This(), handle: *generator.Handle(u8)) !void {
try handle.yield(0);
try handle.yield(1);
try handle.yield(2);
}
};
const G = Map(generator.Generator(ty, u8), u8, u8, struct {
pub fn incr(i: u8) u8 {
return i + 1;
}
}, false);
var g = G.init(G.Context.init(G.Context.Inner.init(ty{})));
try expect((try g.next()).? == 1);
try expect((try g.next()).? == 2);
try expect((try g.next()).? == 3);
try expect((try g.next()) == null);
try expect(g.state == .Returned);
}
test "stateful" {
const expect = std.testing.expect;
const ty = struct {
pub fn generate(_: *@This(), handle: *generator.Handle(u8)) !void {
try handle.yield(0);
try handle.yield(1);
try handle.yield(2);
}
};
const G = Map(generator.Generator(ty, u8), u8, u8, struct {
n: u8 = 0,
pub fn incr(self: *@This(), i: u8) u8 {
self.n += 1;
return i + self.n;
}
}, true);
var g = G.init(G.Context.init(G.Context.Inner.init(ty{}), G.Context.Mapper{}));
try expect((try g.next()).? == 1);
try expect((try g.next()).? == 3);
try expect((try g.next()).? == 5);
try expect((try g.next()) == null);
try expect(g.state == .Returned);
}
|
0 | repos/zig-generator | repos/zig-generator/src/_.zig | const std = @import("std");
/// Internal use:
///
/// Finds and extracts any function in a given struct `T`
/// that has a type `Sig`
pub fn extractFn(comptime T: type, comptime Sig: type) Sig {
switch (@typeInfo(T)) {
.Struct => {
const decls = std.meta.declarations(T);
inline for (decls) |decl| {
if (decl.is_pub) {
switch (decl.data) {
.Fn => |fn_decl| {
if (fn_decl.fn_type == Sig) {
return @field(T, decl.name);
}
},
else => {},
}
}
}
@compileError("no public functions found");
},
else => @compileError("only structs are allowed"),
}
}
test "extractFn" {
const f = extractFn(struct {
pub fn check(_: u8, _: u8) void {}
pub fn add(a: u8, b: u8) u8 {
return a + b;
}
}, fn (u8, u8) u8);
try std.testing.expect(f(1, 2) == 3);
}
|
0 | repos/zig-generator | repos/zig-generator/src/tests.zig | test {
_ = @import("./join.zig");
_ = @import("./map.zig");
}
|
0 | repos/zig-generator | repos/zig-generator/src/lib.zig | //! This module provides functionality to define async generator functions.
//!
//! It allows one to develop linear algorithms that yield values at certain
//! points without having to maintain re-entrancy manually.
//!
//! ```
//! const std = @import("std");
//! const gen = @import("./src/lib.zig");
//!
//! const Ty = struct {
//! pub fn generate(_: *@This(), handle: *gen.Handle(u8)) !u8 {
//! try handle.yield(0);
//! try handle.yield(1);
//! try handle.yield(2);
//! return 3;
//! }
//! };
//!
//! const G = gen.Generator(Ty, u8);
//!
//! pub const io_mode = .evented;
//!
//! pub fn main() !void {
//! var g = G.init(Ty{});
//!
//! std.debug.assert((try g.next()).? == 0);
//! std.debug.assert((try g.next()).? == 1);
//! std.debug.assert((try g.next()).? == 2);
//! std.debug.assert((try g.next()) == null);
//! std.debug.assert(g.state.Returned == 3);
//! }
//! ```
pub usingnamespace @import("./generator.zig");
pub const Join = @import("./join.zig").Select;
pub const Map = @import("./map.zig").Map;
|
0 | repos/zig-generator | repos/zig-generator/src/join.zig | const std = @import("std");
const generator = @import("./generator.zig");
// pending resolution of https://github.com/ziglang/zig/issues/10442,
// this has to be a function separate from `Join`
fn joinedGenerator(comptime g: type, comptime T: type, comptime allocating: bool) type {
return struct {
generator: g,
state: enum { Next, Awaiting, Returned, Done } = .Next,
frame: if (allocating) *@Frame(next) else @Frame(next) = undefined,
fn next(self: *@This(), counter: *std.atomic.Atomic(usize), frame: anyframe) !?T {
defer {
self.state = .Returned;
if (counter.fetchAdd(1, .SeqCst) == 0) {
resume frame;
}
}
return self.generator.next();
}
};
}
fn initializer(
comptime Self: type,
comptime generators: []const type,
generator_fields: []const std.builtin.TypeInfo.StructField,
comptime allocating: bool,
) type {
return if (allocating) struct {
pub fn init(g: std.meta.Tuple(generators), allocator: std.mem.Allocator) Self {
var s = Self{ .allocator = allocator };
inline for (generator_fields) |_, i| {
s.generators[i] = .{ .generator = g[i] };
}
return s;
}
} else struct {
pub fn init(g: std.meta.Tuple(generators)) Self {
var s = Self{};
inline for (generator_fields) |_, i| {
s.generators[i] = .{ .generator = g[i] };
}
return s;
}
};
}
/// Joins multiple generators into one and yields values as they come from
/// either generator
pub fn Join(comptime generators: []const type, comptime T: type, comptime allocating: bool) type {
var generator_fields: [generators.len]std.builtin.TypeInfo.StructField = undefined;
inline for (generators) |g, field_index| {
const G = joinedGenerator(g, T, allocating);
generator_fields[field_index] = .{
.name = std.fmt.comptimePrint("{d}", .{field_index}),
.field_type = G,
.default_value = @as(?G, null),
.is_comptime = false,
.alignment = @alignOf(G),
};
}
const generators_struct = std.builtin.TypeInfo{
.Struct = .{
.layout = .Auto,
.fields = &generator_fields,
.decls = &[0]std.builtin.TypeInfo.Declaration{},
.is_tuple = true,
},
};
const generator_fields_const = generator_fields;
return generator.Generator(struct {
const Self = @This();
generators: @Type(generators_struct) = undefined,
frame: *@Frame(generate) = undefined,
allocator: if (allocating) std.mem.Allocator else void = undefined,
pub usingnamespace initializer(Self, generators, &generator_fields_const, allocating);
pub fn generate(self: *Self, handle: *generator.Handle(T)) !void {
if (allocating) {
inline for (generator_fields_const) |_, i| {
var g = &self.generators[i];
g.frame = self.allocator.create(@Frame(@TypeOf(g.*).next)) catch |e| {
@setEvalBranchQuota(generators.len * 1000);
inline for (generator_fields_const) |_, i_| {
if (i_ == i) return e;
var g_ = &self.generators[i_];
self.allocator.destroy(g_.frame);
}
};
}
}
defer {
if (allocating) {
inline for (generator_fields_const) |_, i| {
var g = &self.generators[i];
if (g.state != .Done)
self.allocator.destroy(g.frame);
}
}
}
var counter = std.atomic.Atomic(usize).init(0);
var active: usize = self.generators.len;
var reported: usize = 0;
while (true) {
// If there are no new reports, suspend until resumed by one
suspend {
if (counter.swap(0, .SeqCst) == reported) {
// run next() where needed
inline for (generator_fields_const) |_, i| {
var g = &self.generators[i];
if (g.state == .Next) {
g.state = .Awaiting;
if (allocating)
g.frame.* = async g.next(&counter, @frame())
else
g.frame = async g.next(&counter, @frame());
}
}
} else {
reported = 0;
resume @frame();
}
}
reported = counter.load(.SeqCst);
while (true) {
// check for returns
var yielded: usize = 0;
inline for (generator_fields_const) |_, i| {
var g = &self.generators[i];
if (g.state == .Returned) {
yielded += 1;
const value = try await g.frame;
if (value) |v| {
try handle.yield(v);
g.state = .Next;
} else {
if (allocating)
self.allocator.destroy(g.frame);
g.state = .Done;
active -= 1;
}
}
}
// ...until we run out of reports
if (yielded == 0) break;
}
if (active == 0) break;
}
}
}, T);
}
test "basic" {
const expect = std.testing.expect;
const ty = struct {
pub fn generate(_: *@This(), handle: *generator.Handle(u8)) !void {
try handle.yield(1);
try handle.yield(2);
try handle.yield(3);
}
};
const ty1 = struct {
pub fn generate(_: *@This(), handle: *generator.Handle(u8)) !void {
try handle.yield(10);
try handle.yield(20);
try handle.yield(30);
}
};
const G0 = generator.Generator(ty, u8);
const G1 = generator.Generator(ty1, u8);
const G = Join(&[_]type{ G0, G1 }, u8, false);
var g = G.init(G.Context.init(.{ G0.init(ty{}), G1.init(ty1{}) }));
var sum: usize = 0;
while (try g.next()) |v| {
sum += v;
}
try expect(sum == 66);
}
test "with async i/o" {
// determine file size
const test_file = try std.fs.cwd()
.openFile("README.md", std.fs.File.OpenFlags{ .read = true, .write = false });
const test_reader = test_file.reader();
var file_size: usize = 0;
while (true) {
_ = test_reader.readByte() catch break;
file_size += 1;
}
const expect = std.testing.expect;
// prepare reader type
const ty = struct {
pub fn generate(_: *@This(), handle: *generator.Handle(u8)) !void {
const file = try std.fs.cwd()
.openFile("README.md", std.fs.File.OpenFlags{ .read = true, .write = false });
const reader = file.reader();
while (true) {
const byte = reader.readByte() catch return;
try handle.yield(byte);
}
}
};
const G0 = generator.Generator(ty, u8);
const G = Join(&[_]type{ G0, G0 }, u8, false);
var g = G.init(G.Context.init(.{ G0.init(ty{}), G0.init(ty{}) }));
// test
var size: usize = 0;
while (try g.next()) |_| {
size += 1;
}
try expect(size == file_size * 2);
}
test "memory impact of not allocating vs allocating frames" {
const ty = struct {
pub fn generate(_: *@This(), handle: *generator.Handle(u8)) !void {
try handle.yield(1);
try handle.yield(2);
try handle.yield(3);
}
};
const G0 = generator.Generator(ty, u8);
const GAllocating = Join(&[_]type{G0} ** 50, u8, true);
const GNonAllocating = Join(&[_]type{G0} ** 50, u8, false);
_ = GNonAllocating.init(GNonAllocating.Context.init(.{G0.init(ty{})}));
_ = GAllocating.init(GAllocating.Context.init(.{G0.init(ty{})}, std.testing.allocator));
// The assertion below doesn't hold true for all number of joined generators
// as the frame of the allocating Join generator can get larger than of the non-allocating one.
// Could be related to this:
// https://zigforum.org/t/unacceptable-memory-overhead-with-nested-async-function-call/407/5
// try std.testing.expect(@sizeOf(GAllocating) < @sizeOf(GNonAllocating));
}
test "allocating join" {
const expect = std.testing.expect;
const ty = struct {
pub fn generate(_: *@This(), handle: *generator.Handle(u8)) !void {
try handle.yield(1);
try handle.yield(2);
try handle.yield(3);
}
};
const G0 = generator.Generator(ty, u8);
const G = Join(&[_]type{G0}, u8, true);
var g = G.init(G.Context.init(.{G0.init(ty{})}, std.testing.allocator));
try expect((try g.next()).? == 1);
try expect((try g.next()).? == 2);
try expect((try g.next()).? == 3);
try expect((try g.next()) == null);
}
|
0 | repos/zig-generator | repos/zig-generator/src/generator.zig | const std = @import("std");
const assert = std.debug.assert;
pub const Cancellation = error{
GeneratorCancelled,
};
pub const State = enum { Initialized, Started, Error, Returned, Cancelled };
/// Generator handle, to be used in Handle's Ctx type
///
/// `T` is the type that the generator yields
/// `Return` is generator's return type
pub fn Handle(comptime T: type) type {
return struct {
const Self = @This();
const HandleState = enum { Working, Yielded, Cancel };
const Suspension = enum(u8) { Unsuspended, Suspended, Yielded };
frame: *@Frame(yield) = undefined,
gen_frame: anyframe = undefined,
gen_frame_suspended: std.atomic.Atomic(Suspension) = std.atomic.Atomic(Suspension).init(.Unsuspended),
state: union(HandleState) {
Working: void,
Yielded: T,
Cancel: void,
} = .Working,
/// Yields a value
pub fn yield(self: *Self, t: T) error{GeneratorCancelled}!void {
if (self.state == .Cancel) return error.GeneratorCancelled;
suspend {
self.state = .{ .Yielded = t };
self.frame = @frame();
if (self.gen_frame_suspended.swap(.Yielded, .SeqCst) == .Suspended) {
resume self.gen_frame;
}
}
if (self.state == .Cancel) return error.GeneratorCancelled;
self.state = .Working;
}
};
}
/// Generator type allows an async function to yield multiple
/// values, and return an error or a result.
///
/// Ctx type must be a struct and it must have the following function:
///
/// * `generate(self: *@This(), handle: *generator.Handle(T)) !Return`
///
/// where `T` is the type of value yielded by the generator and `Return` is
/// the type of the return value.
///
/// NOTE: In many cases it may be advisable to have `T` be a pointer to a type,
/// particularly if the the yielded type is larger than a machine word.
/// This will eliminate the unnecessary copying of the value and may have a positive
/// impact on performance.
/// This is also a critical consideration if the generator needs to be able to
/// observe changes that occurred to the value during suspension.
pub fn Generator(comptime Ctx: type, comptime T: type) type {
const ty = @typeInfo(Ctx);
comptime {
assert(ty == .Struct);
assert(@hasDecl(Ctx, "generate"));
}
const generate_fn = Ctx.generate;
const generate_fn_info = @typeInfo(@TypeOf(generate_fn));
assert(generate_fn_info == .Fn);
assert(generate_fn_info.Fn.args.len == 2);
const arg1_tinfo = @typeInfo(generate_fn_info.Fn.args[0].arg_type.?);
const arg2_tinfo = @typeInfo(generate_fn_info.Fn.args[1].arg_type.?);
const ret_tinfo = @typeInfo(generate_fn_info.Fn.return_type.?);
// context
assert(arg1_tinfo == .Pointer);
assert(arg1_tinfo.Pointer.child == Ctx);
// Handle
assert(arg2_tinfo == .Pointer);
assert(arg2_tinfo.Pointer.child == Handle(T));
assert(ret_tinfo == .ErrorUnion);
return struct {
const Self = @This();
const Err = ret_tinfo.ErrorUnion.error_set;
const CompleteErrorSet = Err || Cancellation;
pub const Return = ret_tinfo.ErrorUnion.payload;
pub const Context = Ctx;
pub const GeneratorState = union(State) {
Initialized: void,
Started: void,
Error: Err,
Returned: Return,
Cancelled: void,
};
handle: Handle(T) = Handle(T){},
/// Generator's state
///
/// * `.Initialized` -- it hasn't been started yet
/// * `.Started` -- it has been started
/// * `.Returned` -- it has returned a value
/// * `.Error` -- it has returned an error
/// * `.Cancelled` -- it has been cancelled
state: GeneratorState = .Initialized,
/// Generator's own structure
context: Context,
generator_frame: @Frame(generator) = undefined,
/// Initializes a generator
pub fn init(ctx: Ctx) Self {
return Self{
.context = ctx,
};
}
fn generator(self: *Self) void {
if (generate_fn(&self.context, &self.handle)) |val| {
self.state = .{ .Returned = val };
} else |err| {
switch (err) {
error.GeneratorCancelled => {
self.state = .Cancelled;
},
else => |e| {
self.state = .{ .Error = e };
},
}
}
if (self.handle.gen_frame_suspended.swap(.Unsuspended, .SeqCst) == .Suspended) {
resume self.handle.gen_frame;
}
suspend {}
unreachable;
}
/// Returns the next yielded value, or `null` if the generator returned or was cancelled.
/// `next()` propagates errors returned by the generator function.
///
/// .state.Returned union variant can be used to retrieve the return value of the generator
/// .state.Cancelled indicates that the generator was cancelled
/// .state.Error union variant can be used to retrieve the error
///
pub fn next(self: *Self) Err!?T {
switch (self.state) {
.Initialized => {
self.state = .Started;
self.handle.gen_frame = @frame();
self.generator_frame = async self.generator();
},
.Started => {
resume self.handle.frame;
},
else => return null,
}
while (self.state == .Started and self.handle.state == .Working) {
suspend {
if (self.handle.gen_frame_suspended.swap(.Suspended, .SeqCst) == .Yielded) {
resume @frame();
}
}
}
self.handle.gen_frame_suspended.store(.Unsuspended, .SeqCst);
switch (self.state) {
.Started => {
return self.handle.state.Yielded;
},
.Error => |e| return e,
else => return null,
}
}
/// Drains the generator until it is done
pub fn drain(self: *Self) !void {
while (try self.next()) |_| {}
}
/// Cancels the generator
///
/// It won't yield any more values and will run its deferred code.
///
/// However, it may still continue working until it attempts to yield.
/// This is possible if the generator is an async function using other async functions.
///
/// NOTE that the generator must cooperate (or at least, not get in the way) with its cancellation.
/// An uncooperative generator can catch `GeneratorCancelled` error and refuse to be terminated.
/// In such case, the generator will be effectively drained upon an attempt to cancel it.
pub fn cancel(self: *Self) void {
self.handle.state = .Cancel;
}
};
}
test "basic generator" {
const expect = std.testing.expect;
const ty = struct {
pub fn generate(_: *@This(), handle: *Handle(u8)) !void {
try handle.yield(0);
try handle.yield(1);
try handle.yield(2);
}
};
const G = Generator(ty, u8);
var g = G.init(ty{});
try expect((try g.next()).? == 0);
try expect((try g.next()).? == 1);
try expect((try g.next()).? == 2);
try expect((try g.next()) == null);
try expect(g.state == .Returned);
try expect((try g.next()) == null);
}
test "generator with async i/o" {
const expect = std.testing.expect;
const ty = struct {
pub fn generate(_: *@This(), handle: *Handle(u8)) !void {
const file = try std.fs.cwd()
.openFile("README.md", std.fs.File.OpenFlags{ .read = true, .write = false });
const reader = file.reader();
while (true) {
const byte = reader.readByte() catch return;
try handle.yield(byte);
}
}
};
const G = Generator(ty, u8);
var g = G.init(ty{});
var bytes: usize = 0;
while (try g.next()) |_| {
bytes += 1;
}
try expect(bytes > 0);
}
test "generator with async await" {
const expect = std.testing.expect;
const ty = struct {
fn doAsync() callconv(.Async) u8 {
suspend {
resume @frame();
}
return 1;
}
pub fn generate(_: *@This(), handle: *Handle(u8)) !void {
try handle.yield(await async doAsync());
}
};
const G = Generator(ty, u8);
var g = G.init(ty{});
try expect((try g.next()).? == 1);
}
test "context" {
const expect = std.testing.expect;
const ty = struct {
a: u8 = 1,
pub fn generate(_: *@This(), handle: *Handle(u8)) !void {
try handle.yield(0);
try handle.yield(1);
try handle.yield(2);
}
};
const G = Generator(ty, u8);
var g = G.init(ty{});
try expect(g.context.a == 1);
}
test "errors in generators" {
const expect = std.testing.expect;
const ty = struct {
pub fn generate(_: *@This(), handle: *Handle(u8)) !void {
try handle.yield(0);
try handle.yield(1);
return error.SomeError;
}
};
const G = Generator(ty, u8);
var g = G.init(ty{});
try expect((try g.next()).? == 0);
try expect((try g.next()).? == 1);
_ = g.next() catch |err| {
try expect(g.state == .Error);
try expect((try g.next()) == null);
switch (err) {
error.SomeError => {
return;
},
else => {
@panic("incorrect error has been captured");
},
}
return;
};
@panic("error should have been generated");
}
test "return value in generator" {
const expect = std.testing.expect;
const ty = struct {
complete: bool = false,
pub fn generate(self: *@This(), handle: *Handle(u8)) !u8 {
defer {
self.complete = true;
}
try handle.yield(0);
try handle.yield(1);
try handle.yield(2);
return 3;
}
};
const G = Generator(ty, u8);
var g = G.init(ty{});
try expect((try g.next()).? == 0);
try expect((try g.next()).? == 1);
try expect((try g.next()).? == 2);
try expect((try g.next()) == null);
try expect(g.state == .Returned);
try expect(g.state.Returned == 3);
try expect(g.context.complete);
}
test "drain" {
const expect = std.testing.expect;
const ty = struct {
pub fn generate(_: *@This(), handle: *Handle(u8)) !u8 {
try handle.yield(0);
try handle.yield(1);
try handle.yield(2);
return 3;
}
};
const G = Generator(ty, u8);
var g = G.init(ty{});
try g.drain();
try expect(g.state.Returned == 3);
}
test "cancel" {
const expect = std.testing.expect;
const ty = struct {
drained: bool = false,
cancelled: bool = false,
pub fn generate(self: *@This(), handle: *Handle(u8)) !u8 {
errdefer |e| {
if (e == error.GeneratorCancelled) {
self.cancelled = true;
}
}
try handle.yield(0);
try handle.yield(1);
try handle.yield(2);
self.drained = true;
return 3;
}
};
const G = Generator(ty, u8);
// cancel before yielding
var g = G.init(ty{});
g.cancel();
try expect((try g.next()) == null);
try expect(g.state == .Cancelled);
try expect(!g.context.drained);
try expect(g.context.cancelled);
// cancel after yielding
g = G.init(ty{});
try expect((try g.next()).? == 0);
g.cancel();
try expect((try g.next()) == null);
try expect(g.state == .Cancelled);
try expect(!g.context.drained);
try expect(g.context.cancelled);
}
test "uncooperative cancellation" {
const expect = std.testing.expect;
const ty = struct {
drained: bool = false,
ignored_termination_0: bool = false,
ignored_termination_1: bool = false,
pub fn generate(self: *@This(), handle: *Handle(u8)) !void {
handle.yield(0) catch {
self.ignored_termination_0 = true;
};
handle.yield(1) catch {
self.ignored_termination_1 = true;
};
self.drained = true;
}
};
const G = Generator(ty, u8);
// Cancel before yielding
var g = G.init(ty{});
g.cancel();
try expect((try g.next()) == null);
try expect(g.state == .Returned);
try expect(g.context.drained);
try expect(g.context.ignored_termination_0);
try expect(g.context.ignored_termination_1);
// Cancel after yielding
g = G.init(ty{});
try expect((try g.next()).? == 0);
g.cancel();
try expect((try g.next()) == null);
try expect(g.state == .Returned);
try expect(g.context.drained);
try expect(g.context.ignored_termination_0);
try expect(g.context.ignored_termination_1);
}
|
0 | repos | repos/zig-args/zig.mod | id: xzxo5rnug8wjvplr5pxamvgegg989aqmli57pi8ah7p93kx8
name: args
main: args.zig
license: MIT
description: Simple-to-use argument parser with struct-based config
dependencies:
|
0 | repos | repos/zig-args/demo_verb.zig | const std = @import("std");
const argsParser = @import("args");
pub fn main() !u8 {
const argsAllocator = std.heap.page_allocator;
const options = argsParser.parseWithVerbForCurrentProcess(
struct {
// this declares long option that can come before or after verb
output: ?[]const u8 = null,
// This declares short-hand options for single hyphen
pub const shorthands = .{
.o = "output",
};
},
union(enum) {
compact: struct {
// This declares long options for double hyphen
host: ?[]const u8 = null,
port: u16 = 3420,
mode: enum { default, special, slow, fast } = .default,
// This declares short-hand options for single hyphen
pub const shorthands = .{
.H = "host",
.p = "port",
};
},
reload: struct {
// This declares long options for double hyphen
force: bool = false,
// This declares short-hand options for single hyphen
pub const shorthands = .{
.f = "force",
};
},
forward: void,
@"zero-sized": struct {},
},
argsAllocator,
.print,
) catch return 1;
defer options.deinit();
std.debug.print("executable name: {?s}\n", .{options.executable_name});
// non-verb/global options
inline for (std.meta.fields(@TypeOf(options.options))) |fld| {
std.debug.print("\t{s} = {any}\n", .{
fld.name,
@field(options.options, fld.name),
});
}
// verb options
if (options.verb) |verb| {
switch (verb) {
.compact => |opts| {
inline for (std.meta.fields(@TypeOf(opts))) |fld| {
std.debug.print("\t{s} = {any}\n", .{
fld.name,
@field(opts, fld.name),
});
}
},
.reload => |opts| {
inline for (std.meta.fields(@TypeOf(opts))) |fld| {
std.debug.print("\t{s} = {any}\n", .{
fld.name,
@field(opts, fld.name),
});
}
},
.forward => std.debug.print("\t`forward` verb with no options received\n", .{}),
.@"zero-sized" => std.debug.print("\t`zero-sized` verb received\n", .{}),
}
}
std.debug.print("parsed positionals:\n", .{});
for (options.positionals) |arg| {
std.debug.print("\t'{s}'\n", .{arg});
}
return 0;
}
|
0 | repos | repos/zig-args/demo.zig | const std = @import("std");
const argsParser = @import("args");
pub fn main() !u8 {
const argsAllocator = std.heap.page_allocator;
const Options = struct {
// This declares long options for double hyphen
output: ?[]const u8 = null,
@"with-offset": bool = false,
@"with-hexdump": bool = false,
@"intermix-source": bool = false,
numberOfBytes: ?i32 = null,
signed_number: ?i64 = null,
unsigned_number: ?u64 = null,
mode: enum { default, special, slow, fast } = .default,
help: bool = false,
// This declares short-hand options for single hyphen
pub const shorthands = .{
.S = "intermix-source",
.b = "with-hexdump",
.O = "with-offset",
.o = "output",
};
pub const meta = .{
.option_docs = .{
.output = "output help",
.@"with-offset" = "with-offset help",
.@"with-hexdump" = "with-hexdump help",
.@"intermix-source" = "intermix-source",
.numberOfBytes = "numberOfBytes help",
.signed_number = "signed_number help",
.unsigned_number = "unsigned_number help",
.mode = "mode help",
.help = "help help",
},
};
};
const options = argsParser.parseForCurrentProcess(Options, argsAllocator, .print) catch return 1;
defer options.deinit();
std.debug.print("executable name: {?s}\n", .{options.executable_name});
std.debug.print("parsed options:\n", .{});
inline for (std.meta.fields(@TypeOf(options.options))) |fld| {
std.debug.print("\t{s} = {any}\n", .{
fld.name,
@field(options.options, fld.name),
});
}
std.debug.print("parsed positionals:\n", .{});
for (options.positionals) |arg| {
std.debug.print("\t'{s}'\n", .{arg});
}
try argsParser.printHelp(Options, options.executable_name orelse "demo", std.io.getStdOut().writer());
return 0;
}
|
0 | repos | repos/zig-args/gyro.zzz | pkgs:
args:
version: 0.0.0
description: "Simple-to-use argument parser with struct-based config"
license: MIT
source_url: "https://github.com/MasterQ32/zig-args"
tags:
option-parser
option-parsing
root: args.zig
files:
README.md
LICENSE
|
0 | repos | repos/zig-args/README.md | # Zig Argument Parser
Simple-to-use argument parser with struct-based config
## Features
- Automatic option generation from a config struct
- Familiar *look & feel*:
- Everything after the first `--` is assumed to be a positional argument
- A single `-` is interpreted as a positional argument which can be used as the stdin/stdout file placeholder
- Short options with no argument can be combined into a single argument: `-dfe`
- Long options can use either `--option=value` or `--option value` syntax (use `--option=--` if you need `--` as a long option argument)
- verbs (sub-commands), with verb specific options. Non-verb specific (global) options can come before or after the
verb on the command line. Non-verb option arguments are processed *before* determining verb. (see `demo_verb.zig`)
- Integrated support for primitive types:
- All integer types (signed & unsigned)
- Floating point types
- Booleans (takes optional argument. If no argument given, the bool is set, otherwise, one of `yes`, `true`, `y`, `no`, `false`, `n` is interpreted)
- Strings
- Enumerations
## Use in your project
Add the dependency in your `build.zig.zon` by running the following command:
```bash
zig fetch --save=args git+https://github.com/ikskuh/zig-args#master
```
Add it to your exe in `build.zig`:
```zig
exe.root_module.addImport("args", b.dependency("args", .{ .target = target, .optimize = optimize }).module("args"));
```
Then you can import it from your code:
```zig
const argsParser = @import("args");
```
## Example
```zig
const options = argsParser.parseForCurrentProcess(struct {
// This declares long options for double hyphen
output: ?[]const u8 = null,
@"with-offset": bool = false,
@"with-hexdump": bool = false,
@"intermix-source": bool = false,
numberOfBytes: ?i32 = null,
signed_number: ?i64 = null,
unsigned_number: ?u64 = null,
mode: enum { default, special, slow, fast } = .default,
// This declares short-hand options for single hyphen
pub const shorthands = .{
.S = "intermix-source",
.b = "with-hexdump",
.O = "with-offset",
.o = "output",
};
}, argsAllocator, .print) catch return 1;
defer options.deinit();
std.debug.print("executable name: {?s}\n", .{options.executable_name});
std.debug.print("parsed options:\n", .{});
inline for (std.meta.fields(@TypeOf(options.options))) |fld| {
std.debug.print("\t{s} = {any}\n", .{
fld.name,
@field(options.options, fld.name),
});
}
std.debug.print("parsed positionals:\n", .{});
for (options.positionals) |arg| {
std.debug.print("\t'{s}'\n", .{arg});
}
```
|
0 | repos | repos/zig-args/build.zig.zon | .{
.name = "zig-args",
.version = "0.0.0",
.minimum_zig_version = "0.12.0",
.paths = .{
"args.zig",
"demo.zig",
"demo_verb.zig",
"build.zig",
},
}
|
0 | repos | repos/zig-args/build.zig | const std = @import("std");
pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const target = b.standardTargetOptions(.{});
const args_mod = b.addModule("args", .{
.root_source_file = b.path("args.zig"),
});
const main_tests = b.addTest(.{
.root_source_file = b.path("args.zig"),
.optimize = optimize,
.target = target,
});
const run_main_tests = b.addRunArtifact(main_tests);
// Standard demo
const demo_exe = b.addExecutable(.{
.name = "demo",
.root_source_file = b.path("demo.zig"),
.optimize = optimize,
.target = target,
});
demo_exe.root_module.addImport("args", args_mod);
const run_demo = b.addRunArtifact(demo_exe);
run_demo.addArgs(&[_][]const u8{
"--output", "demo", "--with-offset", "--signed_number=-10", "--unsigned_number", "20", "--mode", "slow", "help", "this", "is", "borked",
});
// Demo with verbs
const demo_verb_exe = b.addExecutable(.{
.name = "demo_verb",
.root_source_file = b.path("demo_verb.zig"),
.optimize = optimize,
.target = target,
});
demo_verb_exe.root_module.addImport("args", args_mod);
const run_demo_verb_1 = b.addRunArtifact(demo_verb_exe);
run_demo_verb_1.addArgs(&[_][]const u8{
"compact", "--host=localhost", "-p", "4030", "--mode", "fast", "help", "this", "is", "borked",
});
const run_demo_verb_2 = b.addRunArtifact(demo_verb_exe);
run_demo_verb_2.addArgs(&[_][]const u8{
"reload", "-f",
});
const run_demo_verb_3 = b.addRunArtifact(demo_verb_exe);
run_demo_verb_3.addArgs(&[_][]const u8{
"forward",
});
const run_demo_verb_4 = b.addRunArtifact(demo_verb_exe);
run_demo_verb_4.addArgs(&[_][]const u8{
"zero-sized",
});
const test_step = b.step("test", "Runs the test suite.");
test_step.dependOn(&run_main_tests.step);
test_step.dependOn(&run_demo.step);
test_step.dependOn(&run_demo_verb_1.step);
test_step.dependOn(&run_demo_verb_2.step);
test_step.dependOn(&run_demo_verb_3.step);
test_step.dependOn(&run_demo_verb_4.step);
}
|
0 | repos | repos/zig-args/args.zig | const std = @import("std");
/// Parses arguments for the given specification and our current process.
/// - `Spec` is the configuration of the arguments.
/// - `allocator` is the allocator that is used to allocate all required memory
/// - `error_handling` defines how parser errors will be handled.
pub fn parseForCurrentProcess(comptime Spec: type, allocator: std.mem.Allocator, comptime error_handling: ErrorHandling) !ParseArgsResult(Spec, null) {
// Use argsWithAllocator for portability.
// All data allocated by the ArgIterator is freed at the end of the function.
// Data returned to the user is always duplicated using the allocator.
var args = try std.process.argsWithAllocator(allocator);
defer args.deinit();
const executable_name = args.next() orelse {
try error_handling.process(error.NoExecutableName, Error{
.option = "",
.kind = .missing_executable_name,
});
// we do not assume any more arguments appear here anyways...
return error.NoExecutableName;
};
var result = try parseInternal(Spec, null, &args, allocator, error_handling);
result.executable_name = try allocator.dupeZ(u8, executable_name);
return result;
}
/// Parses arguments for the given specification and our current process.
/// - `Spec` is the configuration of the arguments.
/// - `allocator` is the allocator that is used to allocate all required memory
/// - `error_handling` defines how parser errors will be handled.
pub fn parseWithVerbForCurrentProcess(comptime Spec: type, comptime Verb: type, allocator: std.mem.Allocator, comptime error_handling: ErrorHandling) !ParseArgsResult(Spec, Verb) {
// Use argsWithAllocator for portability.
// All data allocated by the ArgIterator is freed at the end of the function.
// Data returned to the user is always duplicated using the allocator.
var args = try std.process.argsWithAllocator(allocator);
defer args.deinit();
const executable_name = args.next() orelse {
try error_handling.process(error.NoExecutableName, Error{
.option = "",
.kind = .missing_executable_name,
});
// we do not assume any more arguments appear here anyways...
return error.NoExecutableName;
};
var result = try parseInternal(Spec, Verb, &args, allocator, error_handling);
result.executable_name = try allocator.dupeZ(u8, executable_name);
return result;
}
/// Parses arguments for the given specification.
/// - `Generic` is the configuration of the arguments.
/// - `args_iterator` is a pointer to an std.process.ArgIterator that will yield the command line arguments.
/// - `allocator` is the allocator that is used to allocate all required memory
/// - `error_handling` defines how parser errors will be handled.
///
/// Note that `.executable_name` in the result will not be set!
pub fn parse(comptime Generic: type, args_iterator: anytype, allocator: std.mem.Allocator, comptime error_handling: ErrorHandling) !ParseArgsResult(Generic, null) {
return parseInternal(Generic, null, args_iterator, allocator, error_handling);
}
/// Parses arguments for the given specification using a `Verb` method.
/// This means that the first positional argument is interpreted as a verb, that can
/// be considered a sub-command that provides more specific options.
/// - `Generic` is the configuration of the arguments.
/// - `Verb` is the configuration of the verbs.
/// - `args_iterator` is a pointer to an std.process.ArgIterator that will yield the command line arguments.
/// - `allocator` is the allocator that is used to allocate all required memory
/// - `error_handling` defines how parser errors will be handled.
///
/// Note that `.executable_name` in the result will not be set!
pub fn parseWithVerb(comptime Generic: type, comptime Verb: type, args_iterator: anytype, allocator: std.mem.Allocator, comptime error_handling: ErrorHandling) !ParseArgsResult(Generic, Verb) {
return parseInternal(Generic, Verb, args_iterator, allocator, error_handling);
}
/// Same as parse, but with anytype argument for testability
fn parseInternal(comptime Generic: type, comptime MaybeVerb: ?type, args_iterator: anytype, allocator: std.mem.Allocator, comptime error_handling: ErrorHandling) !ParseArgsResult(Generic, MaybeVerb) {
var result = ParseArgsResult(Generic, MaybeVerb){
.arena = std.heap.ArenaAllocator.init(allocator),
.options = Generic{},
.verb = if (MaybeVerb != null) null else {}, // no verb by default
.positionals = undefined,
.executable_name = null,
};
errdefer result.arena.deinit();
var result_arena_allocator = result.arena.allocator();
var arglist = std.ArrayList([:0]const u8).init(allocator);
defer arglist.deinit();
var last_error: ?anyerror = null;
while (args_iterator.next()) |item| {
if (std.mem.startsWith(u8, item, "--")) {
if (std.mem.eql(u8, item, "--")) {
// double hyphen is considered 'everything from here now is positional'
result.raw_start_index = arglist.items.len;
break;
}
const Pair = struct {
name: []const u8,
value: ?[]const u8,
};
const pair = if (std.mem.indexOf(u8, item, "=")) |index|
Pair{
.name = item[2..index],
.value = item[index + 1 ..],
}
else
Pair{
.name = item[2..],
.value = null,
};
var found = false;
inline for (std.meta.fields(Generic)) |fld| {
if (std.mem.eql(u8, pair.name, fld.name)) {
try parseOption(Generic, result_arena_allocator, &result.options, args_iterator, error_handling, &last_error, fld.name, pair.value);
found = true;
}
}
if (MaybeVerb) |Verb| {
if (result.verb) |*verb| {
if (!found) {
const Tag = std.meta.Tag(Verb);
inline for (std.meta.fields(Verb)) |verb_info| {
if (verb.* == @field(Tag, verb_info.name)) {
if (comptime canHaveFieldsAndIsNotZeroSized(verb_info.type)) {
inline for (std.meta.fields(verb_info.type)) |fld| {
if (std.mem.eql(u8, pair.name, fld.name)) {
try parseOption(
verb_info.type,
result_arena_allocator,
&@field(verb.*, verb_info.name),
args_iterator,
error_handling,
&last_error,
fld.name,
pair.value,
);
found = true;
}
}
}
}
}
}
}
}
if (!found) {
last_error = error.EncounteredUnknownArgument;
try error_handling.process(error.EncounteredUnknownArgument, Error{
.option = pair.name,
.kind = .unknown,
});
}
} else if (std.mem.startsWith(u8, item, "-")) {
if (std.mem.eql(u8, item, "-")) {
// single hyphen is considered a positional argument
try arglist.append(try result_arena_allocator.dupeZ(u8, item));
} else {
var any_shorthands = false;
for (item[1..], 0..) |char, index| {
var option_name = [2]u8{ '-', char };
var found = false;
if (@hasDecl(Generic, "shorthands")) {
any_shorthands = true;
inline for (std.meta.fields(@TypeOf(Generic.shorthands))) |fld| {
if (fld.name.len != 1)
@compileError("All shorthand fields must be exactly one character long!");
if (fld.name[0] == char) {
const real_name = @field(Generic.shorthands, fld.name);
const real_fld_type = @TypeOf(@field(result.options, real_name));
// -2 because we stripped of the "-" at the beginning
if (requiresArg(real_fld_type) and index != item.len - 2) {
last_error = error.EncounteredUnexpectedArgument;
try error_handling.process(error.EncounteredUnexpectedArgument, Error{
.option = &option_name,
.kind = .invalid_placement,
});
} else {
try parseOption(Generic, result_arena_allocator, &result.options, args_iterator, error_handling, &last_error, real_name, null);
}
found = true;
}
}
}
if (MaybeVerb) |Verb| {
if (result.verb) |*verb| {
if (!found) {
const Tag = std.meta.Tag(Verb);
inline for (std.meta.fields(Verb)) |verb_info| {
const VerbType = verb_info.type;
if (comptime canHaveFieldsAndIsNotZeroSized(VerbType)) {
if (verb.* == @field(Tag, verb_info.name)) {
const target_value = &@field(verb.*, verb_info.name);
if (@hasDecl(VerbType, "shorthands")) {
any_shorthands = true;
inline for (std.meta.fields(@TypeOf(VerbType.shorthands))) |fld| {
if (fld.name.len != 1)
@compileError("All shorthand fields must be exactly one character long!");
if (fld.name[0] == char) {
const real_name = @field(VerbType.shorthands, fld.name);
const real_fld_type = @TypeOf(@field(target_value.*, real_name));
// -2 because we stripped of the "-" at the beginning
if (requiresArg(real_fld_type) and index != item.len - 2) {
last_error = error.EncounteredUnexpectedArgument;
try error_handling.process(error.EncounteredUnexpectedArgument, Error{
.option = &option_name,
.kind = .invalid_placement,
});
} else {
try parseOption(VerbType, result_arena_allocator, target_value, args_iterator, error_handling, &last_error, real_name, null);
}
last_error = null; // we need to reset that error here, as it was set previously
found = true;
}
}
}
}
}
}
}
}
}
if (!found) {
last_error = error.EncounteredUnknownArgument;
try error_handling.process(error.EncounteredUnknownArgument, Error{
.option = &option_name,
.kind = .unknown,
});
}
}
if (!any_shorthands) {
try error_handling.process(error.EncounteredUnsupportedArgument, Error{
.option = item,
.kind = .unsupported,
});
}
}
} else {
if (MaybeVerb) |Verb| {
if (result.verb == null) {
inline for (std.meta.fields(Verb)) |fld| {
if (std.mem.eql(u8, item, fld.name)) {
// found active verb, default-initialize it
result.verb = @unionInit(Verb, fld.name, fld.type{});
}
}
if (result.verb == null) {
try error_handling.process(error.EncounteredUnknownVerb, Error{
.option = "verb",
.kind = .unsupported,
});
}
continue;
}
}
try arglist.append(try result_arena_allocator.dupeZ(u8, item));
}
}
if (last_error != null)
return error.InvalidArguments;
// This will consume the rest of the arguments as positional ones.
// Only executes when the above loop is broken.
while (args_iterator.next()) |item| {
try arglist.append(try result_arena_allocator.dupeZ(u8, item));
}
result.positionals = try arglist.toOwnedSlice();
return result;
}
fn canHaveFieldsAndIsNotZeroSized(comptime T: type) bool {
return switch (@typeInfo(T)) {
.@"struct", .@"union", .@"enum", .error_set => @sizeOf(T) != 0,
else => false,
};
}
/// The return type of the argument parser.
pub fn ParseArgsResult(comptime Generic: type, comptime MaybeVerb: ?type) type {
if (@typeInfo(Generic) != .@"struct")
@compileError("Generic argument definition must be a struct");
if (MaybeVerb) |Verb| {
const ti: std.builtin.Type = @typeInfo(Verb);
if (ti != .@"union" or ti.@"union".tag_type == null)
@compileError("Verb must be a tagged union");
}
return struct {
const Self = @This();
/// Exports the type of options.
pub const GenericOptions = Generic;
pub const Verbs = MaybeVerb orelse void;
arena: std.heap.ArenaAllocator,
/// The options with either default or set values.
options: Generic,
/// The verb that was parsed or `null` if no first positional was provided.
/// Is `void` when verb parsing is disabled
verb: if (MaybeVerb) |Verb| ?Verb else void,
/// The positional arguments that were passed to the process.
positionals: [][:0]const u8,
// The index of the first "raw arg", meaning the first arg after "--"
raw_start_index: ?usize = null,
/// Name of the executable file (or: zeroth argument)
executable_name: ?[:0]const u8,
pub fn deinit(self: Self) void {
self.arena.child_allocator.free(self.positionals);
if (self.executable_name) |n|
self.arena.child_allocator.free(n);
self.arena.deinit();
}
};
}
/// Returns true if the given type requires an argument to be parsed.
fn requiresArg(comptime T: type) bool {
const H = struct {
fn doesArgTypeRequireArg(comptime Type: type) bool {
if (Type == []const u8)
return true;
return switch (@as(std.builtin.TypeId, @typeInfo(Type))) {
.int, .float, .@"enum" => true,
.bool => false,
.@"struct", .@"union" => true,
.pointer => true,
else => @compileError(@typeName(Type) ++ " is not a supported argument type!"),
};
}
};
const ti = @typeInfo(T);
if (ti == .optional) {
return H.doesArgTypeRequireArg(ti.optional.child);
} else {
return H.doesArgTypeRequireArg(T);
}
}
/// Parses a boolean option.
fn parseBoolean(str: []const u8) !bool {
return switch (str.len) {
1 => switch (str[0]) {
'y', 'Y', 't', 'T' => true,
'n', 'N', 'f', 'F' => false,
else => error.NotABooleanValue,
},
2 => if (std.ascii.eqlIgnoreCase("no", str)) false else error.NotABooleanValue,
3 => if (std.ascii.eqlIgnoreCase("yes", str)) true else error.NotABooleanValue,
4 => if (std.ascii.eqlIgnoreCase("true", str)) true else error.NotABooleanValue,
5 => if (std.ascii.eqlIgnoreCase("false", str)) false else error.NotABooleanValue,
else => error.NotABooleanValue,
};
}
/// Parses an int option.
fn parseInt(comptime T: type, str: []const u8) !T {
var buf = str;
var multiplier: T = 1;
if (buf.len != 0) {
var base1024 = false;
if (std.ascii.toLower(buf[buf.len - 1]) == 'i') { //ki vs k for instance
buf.len -= 1;
base1024 = true;
}
if (buf.len != 0) {
const pow: u3 = switch (buf[buf.len - 1]) {
'k', 'K' => 1, //kilo
'm', 'M' => 2, //mega
'g', 'G' => 3, //giga
't', 'T' => 4, //tera
'p', 'P' => 5, //peta
else => 0,
};
if (pow != 0) {
buf.len -= 1;
if (comptime std.math.maxInt(T) < 1024)
return error.Overflow;
const base: T = if (base1024) 1024 else 1000;
multiplier = try std.math.powi(T, base, @as(T, @intCast(pow)));
}
}
}
const ret: T = switch (@typeInfo(T).int.signedness) {
.signed => try std.fmt.parseInt(T, buf, 0),
.unsigned => try std.fmt.parseUnsigned(T, buf, 0),
};
return try std.math.mul(T, ret, multiplier);
}
test "parseInt" {
const tst = std.testing;
try tst.expectEqual(@as(i32, 50), try parseInt(i32, "50"));
try tst.expectEqual(@as(i32, 6000), try parseInt(i32, "6k"));
try tst.expectEqual(@as(u32, 2048), try parseInt(u32, "0x2KI"));
try tst.expectEqual(@as(i8, 0), try parseInt(i8, "0"));
try tst.expectEqual(@as(usize, 10_000_000_000), try parseInt(usize, "0xAg"));
try tst.expectError(error.Overflow, parseInt(i2, "1m"));
try tst.expectError(error.Overflow, parseInt(u16, "1Ti"));
}
/// Converts an argument value to the target type.
fn convertArgumentValue(comptime T: type, allocator: std.mem.Allocator, textInput: []const u8) !T {
switch (@typeInfo(T)) {
.optional => |opt| return try convertArgumentValue(opt.child, allocator, textInput),
.bool => if (textInput.len > 0)
return try parseBoolean(textInput)
else
return true, // boolean options are always true
.int => return try parseInt(T, textInput),
.float => return try std.fmt.parseFloat(T, textInput),
.@"enum" => {
if (@hasDecl(T, "parse")) {
return try T.parse(textInput);
} else {
return std.meta.stringToEnum(T, textInput) orelse return error.InvalidEnumeration;
}
},
.@"struct", .@"union" => {
if (@hasDecl(T, "parse")) {
return try T.parse(textInput);
} else {
@compileError(@typeName(T) ++ " has no public visible `fn parse([]const u8) !T`!");
}
},
.pointer => |ptr| switch (ptr.size) {
.Slice => {
if (ptr.child != u8) {
@compileError(@typeName(T) ++ " is not a supported pointer type, only slices of u8 are supported");
}
// If the type contains a sentinel dupe the text input to a new buffer.
// This is equivalent to allocator.dupeZ but works with any sentinel.
if (comptime std.meta.sentinel(T)) |sentinel| {
const data = try allocator.alloc(u8, textInput.len + 1);
@memcpy(data[0..textInput.len], textInput);
data[textInput.len] = sentinel;
return data[0..textInput.len :sentinel];
}
// Otherwise the type is []const u8 so just return the text input.
return textInput;
},
else => @compileError(@typeName(T) ++ " is not a supported pointer type!"),
},
else => @compileError(@typeName(T) ++ " is not a supported argument type!"),
}
}
/// Parses an option value into the correct type.
fn parseOption(
comptime Spec: type,
arena: std.mem.Allocator,
target_struct: *Spec,
args: anytype,
comptime error_handling: ErrorHandling,
last_error: *?anyerror,
/// The name of the option that is currently parsed.
comptime name: []const u8,
/// Optional pre-defined value for options that use `--foo=bar`
value: ?[]const u8,
) !void {
const field_type = @TypeOf(@field(target_struct, name));
const final_value = if (value) |val| blk: {
// use the literal value
const res = try arena.dupeZ(u8, val);
break :blk res;
} else if (requiresArg(field_type)) blk: {
// fetch from parser
const val = args.next();
if (val == null or std.mem.eql(u8, val.?, "--")) {
last_error.* = error.MissingArgument;
try error_handling.process(error.MissingArgument, Error{
.option = "--" ++ name,
.kind = .missing_argument,
});
return;
}
const res = try arena.dupeZ(u8, val.?);
break :blk res;
} else blk: {
// argument is "empty"
break :blk "";
};
@field(target_struct, name) = convertArgumentValue(field_type, arena, final_value) catch |err| {
last_error.* = err;
try error_handling.process(err, Error{
.option = "--" ++ name,
.kind = .{ .invalid_value = final_value },
});
// we couldn't parse the value, so we return a undefined value as we have signalled an
// error and won't return this anyways.
return;
};
}
/// A collection of errors that were encountered while parsing arguments.
pub const ErrorCollection = struct {
const Self = @This();
arena: std.heap.ArenaAllocator,
list: std.ArrayList(Error),
pub fn init(allocator: std.mem.Allocator) Self {
return Self{
.arena = std.heap.ArenaAllocator.init(allocator),
.list = std.ArrayList(Error).init(allocator),
};
}
pub fn deinit(self: *Self) void {
self.list.deinit();
self.arena.deinit();
self.* = undefined;
}
/// Returns the current enumeration of errors.
pub fn errors(self: Self) []const Error {
return self.list.items;
}
/// Appends an error to the collection
fn insert(self: *Self, err: Error) !void {
const dupe = Error{
.option = try self.arena.allocator().dupe(u8, err.option),
.kind = switch (err.kind) {
.invalid_value => |v| Error.Kind{
.invalid_value = try self.arena.allocator().dupe(u8, v),
},
// flat copy
.unknown, .out_of_memory, .unsupported, .invalid_placement, .missing_argument, .missing_executable_name, .unknown_verb => err.kind,
},
};
try self.list.append(dupe);
}
};
/// An argument parsing error.
pub const Error = struct {
const Self = @This();
/// The option that yielded the error
option: []const u8,
/// The kind of error, might include additional information
kind: Kind,
pub fn format(self: Self, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
_ = fmt;
_ = options;
switch (self.kind) {
.unknown => try writer.print("The option {s} does not exist", .{self.option}),
.invalid_value => |value| try writer.print("Invalid value '{s}' for option {s}", .{ value, self.option }),
.out_of_memory => try writer.print("Out of memory while parsing option {s}", .{self.option}),
.unsupported => try writer.writeAll("Short command line options are not supported."),
.invalid_placement => try writer.writeAll("An option with argument must be the last option for short command line options."),
.missing_argument => try writer.print("Missing argument for option {s}", .{self.option}),
.missing_executable_name => try writer.writeAll("Failed to get executable name from the argument list!"),
.unknown_verb => try writer.print("Unknown verb '{s}'.", .{self.option}),
}
}
pub const Kind = union(enum) {
/// When the argument itself is unknown
unknown,
/// When the parsing of an argument value failed
invalid_value: []const u8,
/// When the parsing of an argument value triggered a out of memory error
out_of_memory,
/// When the argument is a short argument and no shorthands are enabled
unsupported,
/// Can only happen when a shorthand for an option requires an argument, but is followed by more shorthands.
invalid_placement,
/// An option was passed that requires an argument, but the option was passed last.
missing_argument,
/// This error has an empty option name and can only happen when parsing the argument list for a process.
missing_executable_name,
/// This error has the verb as an option name and will happen when a verb is provided that is not known.
unknown_verb,
};
};
/// The error handling method that should be used.
pub const ErrorHandling = union(enum) {
const Self = @This();
/// Do not print or process any errors, just
/// return a fitting error on the first argument mismatch.
silent,
/// Print errors to stderr and return a `error.InvalidArguments`.
print,
/// Collect errors into the error collection and return
/// `error.InvalidArguments` when any error was encountered.
collect: *ErrorCollection,
/// Forwards the parsing error to a functionm
forward: fn (err: Error) anyerror!void,
/// Processes an error with the given handling method.
fn process(comptime self: Self, src_error: anytype, err: Error) !void {
if (@typeInfo(@TypeOf(src_error)) != .error_set)
@compileError("src_error must be a error union!");
switch (self) {
.silent => return src_error,
.print => try std.io.getStdErr().writer().print("{}\n", .{err}),
.collect => |collection| try collection.insert(err),
.forward => |func| try func(err),
}
}
};
test {
std.testing.refAllDecls(@This());
}
test "ErrorCollection" {
var option_buf = "option".*;
var invalid_buf = "invalid".*;
var ec = ErrorCollection.init(std.testing.allocator);
defer ec.deinit();
try ec.insert(Error{
.option = &option_buf,
.kind = .{ .invalid_value = &invalid_buf },
});
option_buf = undefined;
invalid_buf = undefined;
try std.testing.expectEqualStrings("option", ec.errors()[0].option);
try std.testing.expectEqualStrings("invalid", ec.errors()[0].kind.invalid_value);
}
const TestIterator = struct {
sequence: []const [:0]const u8,
index: usize = 0,
pub fn init(items: []const [:0]const u8) TestIterator {
return TestIterator{ .sequence = items };
}
pub fn next(self: *@This()) ?[:0]const u8 {
if (self.index >= self.sequence.len)
return null;
const result = self.sequence[self.index];
self.index += 1;
return result;
}
};
const TestEnum = enum { default, special, slow, fast };
const TestGenericOptions = struct {
output: ?[]const u8 = null,
@"with-offset": bool = false,
@"with-hexdump": bool = false,
@"intermix-source": bool = false,
numberOfBytes: ?i32 = null,
signed_number: ?i64 = null,
unsigned_number: ?u64 = null,
mode: TestEnum = .default,
// This declares short-hand options for single hyphen
pub const shorthands = .{
.S = "intermix-source",
.b = "with-hexdump",
.O = "with-offset",
.o = "output",
};
};
const TestVerb = union(enum) {
magic: MagicOptions,
booze: BoozeOptions,
const MagicOptions = struct { invoke: bool = false };
const BoozeOptions = struct {
cocktail: bool = false,
longdrink: bool = false,
pub const shorthands = .{
.c = "cocktail",
.l = "longdrink",
};
};
};
test "basic parsing (no verbs)" {
var titerator = TestIterator.init(&[_][:0]const u8{
"--output",
"foobar",
"--with-offset",
"--numberOfBytes",
"-250",
"--unsigned_number",
"0xFF00FF",
"positional 1",
"--mode",
"special",
"positional 2",
});
var args = try parseInternal(TestGenericOptions, null, &titerator, std.testing.allocator, .print);
defer args.deinit();
try std.testing.expectEqual(@as(?[:0]const u8, null), args.executable_name);
try std.testing.expect(void == @TypeOf(args.verb));
try std.testing.expectEqual(@as(usize, 2), args.positionals.len);
try std.testing.expectEqualStrings("positional 1", args.positionals[0]);
try std.testing.expectEqualStrings("positional 2", args.positionals[1]);
try std.testing.expectEqualStrings("foobar", args.options.output.?);
try std.testing.expectEqual(@as(?i32, -250), args.options.numberOfBytes);
try std.testing.expectEqual(@as(?u64, 0xFF00FF), args.options.unsigned_number);
try std.testing.expectEqual(TestEnum.special, args.options.mode);
try std.testing.expectEqual(@as(?i64, null), args.options.signed_number);
try std.testing.expectEqual(true, args.options.@"with-offset");
try std.testing.expectEqual(false, args.options.@"with-hexdump");
try std.testing.expectEqual(false, args.options.@"intermix-source");
}
test "shorthand parsing (no verbs)" {
var titerator = TestIterator.init(&[_][:0]const u8{
"-o",
"foobar",
"-O",
"--numberOfBytes",
"-250",
"--unsigned_number",
"0xFF00FF",
"positional 1",
"--mode",
"special",
"positional 2",
});
var args = try parseInternal(TestGenericOptions, null, &titerator, std.testing.allocator, .print);
defer args.deinit();
try std.testing.expectEqual(@as(?[:0]const u8, null), args.executable_name);
try std.testing.expect(void == @TypeOf(args.verb));
try std.testing.expectEqual(@as(usize, 2), args.positionals.len);
try std.testing.expectEqualStrings("positional 1", args.positionals[0]);
try std.testing.expectEqualStrings("positional 2", args.positionals[1]);
try std.testing.expectEqualStrings("foobar", args.options.output.?);
try std.testing.expectEqual(@as(?i32, -250), args.options.numberOfBytes);
try std.testing.expectEqual(@as(?u64, 0xFF00FF), args.options.unsigned_number);
try std.testing.expectEqual(TestEnum.special, args.options.mode);
try std.testing.expectEqual(@as(?i64, null), args.options.signed_number);
try std.testing.expectEqual(true, args.options.@"with-offset");
try std.testing.expectEqual(false, args.options.@"with-hexdump");
try std.testing.expectEqual(false, args.options.@"intermix-source");
}
test "basic parsing (with verbs)" {
var titerator = TestIterator.init(&[_][:0]const u8{
"--output", // non-verb options can come before or after verb
"foobar",
"booze", // verb
"--with-offset",
"--numberOfBytes",
"-250",
"--unsigned_number",
"0xFF00FF",
"positional 1",
"--mode",
"special",
"positional 2",
"--cocktail",
});
var args = try parseInternal(TestGenericOptions, TestVerb, &titerator, std.testing.allocator, .print);
defer args.deinit();
try std.testing.expectEqual(@as(?[:0]const u8, null), args.executable_name);
try std.testing.expect(?TestVerb == @TypeOf(args.verb));
try std.testing.expectEqual(@as(usize, 2), args.positionals.len);
try std.testing.expectEqualStrings("positional 1", args.positionals[0]);
try std.testing.expectEqualStrings("positional 2", args.positionals[1]);
try std.testing.expectEqualStrings("foobar", args.options.output.?);
try std.testing.expectEqual(@as(?i32, -250), args.options.numberOfBytes);
try std.testing.expectEqual(@as(?u64, 0xFF00FF), args.options.unsigned_number);
try std.testing.expectEqual(TestEnum.special, args.options.mode);
try std.testing.expectEqual(@as(?i64, null), args.options.signed_number);
try std.testing.expectEqual(true, args.options.@"with-offset");
try std.testing.expectEqual(false, args.options.@"with-hexdump");
try std.testing.expectEqual(false, args.options.@"intermix-source");
try std.testing.expect(args.verb.? == .booze);
const booze = args.verb.?.booze;
try std.testing.expectEqual(true, booze.cocktail);
try std.testing.expectEqual(false, booze.longdrink);
}
test "shorthand parsing (with verbs)" {
var titerator = TestIterator.init(&[_][:0]const u8{
"booze", // verb
"-o",
"foobar",
"-O",
"--numberOfBytes",
"-250",
"--unsigned_number",
"0xFF00FF",
"positional 1",
"--mode",
"special",
"positional 2",
"-c", // --cocktail
});
var args = try parseInternal(TestGenericOptions, TestVerb, &titerator, std.testing.allocator, .print);
defer args.deinit();
try std.testing.expectEqual(@as(?[:0]const u8, null), args.executable_name);
try std.testing.expect(?TestVerb == @TypeOf(args.verb));
try std.testing.expectEqual(@as(usize, 2), args.positionals.len);
try std.testing.expectEqualStrings("positional 1", args.positionals[0]);
try std.testing.expectEqualStrings("positional 2", args.positionals[1]);
try std.testing.expectEqualStrings("foobar", args.options.output.?);
try std.testing.expectEqual(@as(?i32, -250), args.options.numberOfBytes);
try std.testing.expectEqual(@as(?u64, 0xFF00FF), args.options.unsigned_number);
try std.testing.expectEqual(TestEnum.special, args.options.mode);
try std.testing.expectEqual(@as(?i64, null), args.options.signed_number);
try std.testing.expectEqual(true, args.options.@"with-offset");
try std.testing.expectEqual(false, args.options.@"with-hexdump");
try std.testing.expectEqual(false, args.options.@"intermix-source");
try std.testing.expect(args.verb.? == .booze);
const booze = args.verb.?.booze;
try std.testing.expectEqual(true, booze.cocktail);
try std.testing.expectEqual(false, booze.longdrink);
}
test "strings with sentinel" {
var titerator = TestIterator.init(&[_][:0]const u8{
"--output",
"foobar",
});
var args = try parseInternal(
struct {
output: ?[:0]const u8 = null,
},
null,
&titerator,
std.testing.allocator,
.print,
);
defer args.deinit();
try std.testing.expectEqual(@as(?[:0]const u8, null), args.executable_name);
try std.testing.expect(void == @TypeOf(args.verb));
try std.testing.expectEqual(@as(usize, 0), args.positionals.len);
try std.testing.expectEqualStrings("foobar", args.options.output.?);
}
test "option argument --" {
var titerator = TestIterator.init(&[_][:0]const u8{
"--output",
"--",
});
try std.testing.expectError(error.MissingArgument, parseInternal(
struct {
output: ?[:0]const u8 = null,
},
null,
&titerator,
std.testing.allocator,
.silent,
));
}
test "index of raw indicator --" {
var titerator = TestIterator.init(&[_][:0]const u8{ "stdin", "-", "--", "not-stdin", "-", "--" });
var args = try parseInternal(
struct {},
null,
&titerator,
std.testing.allocator,
.print,
);
defer args.deinit();
try std.testing.expectEqual(args.raw_start_index, 2);
try std.testing.expectEqual(args.positionals.len, 5);
}
fn reserved_argument(arg: []const u8) bool {
return std.mem.eql(u8, arg, "shorthands") or std.mem.eql(u8, arg, "meta");
}
pub fn printHelp(comptime Generic: type, name: []const u8, writer: anytype) !void {
if (!@hasDecl(Generic, "meta")) {
@compileError("Missing meta declaration in Generic");
}
const Meta = @TypeOf(Generic.meta);
try writer.print("Usage: {s}", .{name});
if (@hasField(Meta, "usage_summary")) {
try writer.print(" {s}", .{Generic.meta.usage_summary});
}
try writer.print("\n\n", .{});
if (@hasField(Meta, "full_text")) {
try writer.print("{s}\n\n", .{Generic.meta.full_text});
}
if (@hasField(Meta, "option_docs")) {
const fields = std.meta.fields(Generic);
try writer.print("Options:\n", .{});
comptime var maxOptionLength = 0;
inline for (fields) |field| {
if (!reserved_argument(field.name)) {
if (!@hasField(@TypeOf(Generic.meta.option_docs), field.name)) {
@compileError("option_docs not specified for field: " ++ field.name);
}
}
if (field.name.len > maxOptionLength) {
maxOptionLength = field.name.len;
}
}
inline for (fields) |field| {
if (!reserved_argument(field.name)) {
if (@hasDecl(Generic, "shorthands")) {
var foundShorthand = false;
inline for (std.meta.fields(@TypeOf(Generic.shorthands))) |shorthand| {
const option = @field(Generic.shorthands, shorthand.name);
if (std.mem.eql(u8, option, field.name)) {
try writer.print(" -{s}, ", .{shorthand.name});
foundShorthand = true;
}
}
if (!foundShorthand)
try writer.print(" ", .{});
}
if (@hasDecl(Generic, "wrap_len")) {
var it = std.mem.splitScalar(u8, @field(Generic.meta.option_docs, field.name), ' ');
const threshold = Generic.wrap_len;
var line_len: usize = 0;
var newline = false;
var first = true;
while (it.next()) |word| {
if (first) {
const fmtString = std.fmt.comptimePrint("--{{s: <{}}} {{s}}", .{maxOptionLength});
try writer.print(fmtString, .{ field.name, word });
first = false;
} else if (newline) {
const fmtString = std.fmt.comptimePrint("\n{{s: <{}}} {{s}}", .{maxOptionLength + 10});
try writer.print(fmtString, .{ " ", word });
newline = false;
} else {
try writer.print(" {s}", .{word});
}
line_len += word.len;
if (line_len >= threshold) {
newline = true;
line_len = 0;
}
}
try writer.writeByte('\n');
} else {
const fmtString = std.fmt.comptimePrint("--{{s: <{}}} {{s}}\n", .{maxOptionLength});
try writer.print(fmtString, .{ field.name, @field(Generic.meta.option_docs, field.name) });
}
}
}
}
}
test "full help" {
const Options = struct {
boolflag: bool = false,
stringflag: []const u8 = "hello",
pub const shorthands = .{
.b = "boolflag",
};
pub const meta = .{
.name = "test",
.full_text = "testing tool",
.usage_summary = "[--boolflag] [--stringflag]",
.option_docs = .{
.boolflag = "a boolean flag",
.stringflag = "a string flag",
},
};
};
var test_buffer = std.ArrayList(u8).init(std.testing.allocator);
defer test_buffer.deinit();
try printHelp(Options, "test", test_buffer.writer());
const expected =
\\Usage: test [--boolflag] [--stringflag]
\\
\\testing tool
\\
\\Options:
\\ -b, --boolflag a boolean flag
\\ --stringflag a string flag
\\
;
try std.testing.expectEqualStrings(expected, test_buffer.items);
}
test "help with no usage summary" {
const Options = struct {
boolflag: bool = false,
stringflag: []const u8 = "hello",
pub const shorthands = .{
.b = "boolflag",
};
pub const meta = .{
.full_text = "testing tool",
.option_docs = .{
.boolflag = "a boolean flag",
.stringflag = "a string flag",
},
};
};
var test_buffer = std.ArrayList(u8).init(std.testing.allocator);
defer test_buffer.deinit();
try printHelp(Options, "test", test_buffer.writer());
const expected =
\\Usage: test
\\
\\testing tool
\\
\\Options:
\\ -b, --boolflag a boolean flag
\\ --stringflag a string flag
\\
;
try std.testing.expectEqualStrings(expected, test_buffer.items);
}
test "help with wrapping" {
const Options = struct {
boolflag: bool = false,
stringflag: []const u8 = "hello",
pub const shorthands = .{
.b = "boolflag",
};
pub const wrap_len = 10;
pub const meta = .{
.full_text = "testing tool",
.option_docs = .{
.boolflag = "a boolean flag with a pretty long description about booleans",
.stringflag = "a string flag with another long description about strings",
},
};
};
var test_buffer = std.ArrayList(u8).init(std.testing.allocator);
defer test_buffer.deinit();
try printHelp(Options, "test", test_buffer.writer());
const expected =
\\Usage: test
\\
\\testing tool
\\
\\Options:
\\ -b, --boolflag a boolean flag
\\ with a pretty
\\ long description
\\ about booleans
\\ --stringflag a string flag
\\ with another
\\ long description
\\ about strings
\\
;
try std.testing.expectEqualStrings(expected, test_buffer.items);
}
|
0 | repos | repos/zig-curl/build.zig.zon | .{
.name = "curl",
.version = "0.1.0",
.paths = .{
"src",
"libs",
"build.zig",
"build.zig.zon",
"LICENSE",
},
.dependencies = .{
.curl = .{
// https://github.com/curl/curl/releases/tag/curl-8_8_0
.url = "https://github.com/curl/curl/releases/download/curl-8_8_0/curl-8.8.0.tar.gz",
.hash = "12207d52e2cf89a5750ad273648c6f4cdeb5b4c19d171f0b1a3215cf592ca677fd94",
.lazy = true,
},
// https://github.com/madler/zlib/releases/tag/v1.3.1
.zlib = .{
.url = "https://github.com/madler/zlib/releases/download/v1.3.1/zlib-1.3.1.tar.gz",
.hash = "1220c1854d7b4c2b5cbdd8ce6593c37e4bf1ac4032664735e1537c3848becb3b5834",
.lazy = true,
},
.mbedtls = .{
.url = "https://github.com/Mbed-TLS/mbedtls/archive/refs/tags/v3.6.0.tar.gz",
.hash = "1220358fd78ebfb68dde5b77787d5325f1f89e901d448ae0da0187811be53dd3ec7c",
.lazy = true,
},
},
}
|
0 | repos | repos/zig-curl/build.zig | const std = @import("std");
const Build = std.Build;
const Step = Build.Step;
const Module = Build.Module;
const MODULE_NAME = "curl";
pub fn build(b: *Build) void {
const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{});
const link_vendor = b.option(bool, "link_vendor", "Whether link to vendored libcurl (default: true)") orelse true;
const module = b.addModule(MODULE_NAME, .{
.root_source_file = b.path("src/root.zig"),
.link_libc = true,
.target = target,
.optimize = optimize,
});
var libcurl: ?*Step.Compile = null;
if (link_vendor) {
if (buildLibcurl(b, target, optimize)) |v| {
libcurl = v;
module.linkLibrary(v);
} else {
return;
}
}
try addExample(b, "basic", module, libcurl, target, optimize);
try addExample(b, "advanced", module, libcurl, target, optimize);
try addExample(b, "multi", module, libcurl, target, optimize);
try addExample(b, "header", module, libcurl, target, optimize);
const main_tests = b.addTest(.{
.root_source_file = b.path("src/root.zig"),
.target = target,
.optimize = optimize,
.link_libc = true,
});
if (libcurl) |lib| {
main_tests.linkLibrary(lib);
} else {
main_tests.linkSystemLibrary("curl");
}
const run_main_tests = b.addRunArtifact(main_tests);
const test_step = b.step("test", "Run library tests");
test_step.dependOn(&run_main_tests.step);
const check_step = b.step("check", "Used for checking the library");
inline for (.{ "basic", "advanced", "multi" }) |name| {
const check_exe = b.addExecutable(.{
.name = "check-" ++ name,
.root_source_file = b.path("examples/" ++ name ++ ".zig"),
.target = target,
.optimize = optimize,
.link_libc = true,
});
check_exe.root_module.addImport(MODULE_NAME, module);
check_step.dependOn(&check_exe.step);
}
}
fn buildLibcurl(
b: *Build,
target: Build.ResolvedTarget,
optimize: std.builtin.OptimizeMode,
) ?*Step.Compile {
const curl = @import("libs/curl.zig").create(b, target, optimize);
const tls = @import("libs/mbedtls.zig").create(b, target, optimize);
const zlib = @import("libs/zlib.zig").create(b, target, optimize);
if (curl == null or tls == null or zlib == null) {
return null;
}
const libcurl = curl.?;
libcurl.linkLibrary(tls.?);
libcurl.linkLibrary(zlib.?);
return libcurl;
}
fn addExample(
b: *Build,
comptime name: []const u8,
curl_module: *Module,
libcurl: ?*Step.Compile,
target: Build.ResolvedTarget,
optimize: std.builtin.OptimizeMode,
) !void {
const exe = b.addExecutable(.{
.name = name,
.root_source_file = b.path("examples/" ++ name ++ ".zig"),
.target = target,
.optimize = optimize,
.link_libc = true,
});
b.installArtifact(exe);
exe.root_module.addImport(MODULE_NAME, curl_module);
if (libcurl) |lib| {
exe.linkLibrary(lib);
} else {
exe.linkSystemLibrary("curl");
}
const run_step = b.step(
"run-" ++ name,
std.fmt.comptimePrint("Run {s} example", .{name}),
);
run_step.dependOn(&b.addRunArtifact(exe).step);
}
|
0 | repos/zig-curl | repos/zig-curl/.woodpecker/ci.yml | steps:
- name: zig
image: ghcr.io/jiacai2050/playground:zig-20240808-b5c8f704
# https://woodpecker-ci.org/docs/usage/workflow-syntax#entrypoint
# Change entrypoint to `bash -lc`
entrypoint: ["/bin/bash", "-lc", "echo $CI_SCRIPT | base64 -d | /bin/bash -e"]
commands:
- asdf plugin add golang https://github.com/asdf-community/asdf-golang.git
- asdf install golang latest && asdf global golang latest
- ./.github/server.sh
- make test
- make run
when:
- event: [push, cron]
cron: ci*
|
0 | repos/zig-curl | repos/zig-curl/src/Multi.zig | const std = @import("std");
const errors = @import("errors.zig");
const util = @import("util.zig");
const Easy = @import("Easy.zig");
const c = util.c;
const mem = std.mem;
const fmt = std.fmt;
const Allocator = mem.Allocator;
const checkMCode = errors.checkMCode;
const Self = @This();
multi: *c.CURLM,
pub fn init() !Self {
const core = c.curl_multi_init();
if (core == null) {
return error.InitMulti;
}
return .{ .multi = core.? };
}
pub fn deinit(self: Self) void {
_ = self;
}
/// Adds the easy handle to the multi_handle.
/// https://curl.se/libcurl/c/curl_multi_add_handle.html
pub fn addHandle(self: Self, easy: Easy) !void {
try easy.setCommonOpts();
return checkMCode(c.curl_multi_add_handle(self.multi, easy.handle));
}
/// Removes a given easy_handle from the multi_handle.
/// https://curl.se/libcurl/c/curl_multi_remove_handle.html
pub fn removeHandle(self: Self, handle: *c.CURL) !void {
return checkMCode(c.curl_multi_remove_handle(self.multi, handle));
}
/// Performs transfers on all the added handles that need attention in a non-blocking fashion.
/// Returns the number of handles that still transfer data. When that reaches zero, all transfers are done.
/// https://curl.se/libcurl/c/curl_multi_perform.html
pub fn perform(self: Self) !c_int {
var still_running: c_int = undefined;
try checkMCode(c.curl_multi_perform(self.multi, &still_running));
return still_running;
}
/// Polls all file descriptors used by the curl easy handles contained in the given multi handle set.
/// Return the number of file descriptors on which there is activity.
/// https://curl.se/libcurl/c/curl_multi_poll.html
pub fn poll(self: Self, extra_fds: ?[]c.curl_waitfd, timeout_ms: c_int) !c_int {
var num_fds: c_int = undefined;
var fds: ?[*]c.curl_waitfd = null;
var fd_len: c_uint = 0;
if (extra_fds) |v| {
fds = v.ptr;
fd_len = @intCast(v.len);
}
try checkMCode(c.curl_multi_poll(self.multi, fds, fd_len, timeout_ms, &num_fds));
return num_fds;
}
/// Wakes up a sleeping curl_multi_poll call that is currently (or is about to be) waiting for activity or a timeout.
/// This function can be called from any thread.
/// https://curl.se/libcurl/c/curl_multi_wakeup.html
pub fn wakeup(self: Self) !void {
try checkMCode(c.curl_multi_wakeup(self.multi));
}
pub const Info = struct {
msgs_in_queue: c_int,
msg: *c.CURLMsg,
};
/// Ask the multi handle if there are any messages from the individual transfers.
/// https://curl.se/libcurl/c/curl_multi_info_read.html
pub fn readInfo(self: Self) !Info {
var msgs_in_queue: c_int = undefined;
const msg = c.curl_multi_info_read(self.multi, &msgs_in_queue);
if (msg == null) {
return error.InfoReadExhausted;
}
return Info{
.msg = msg.?,
.msgs_in_queue = msgs_in_queue,
};
}
|
0 | repos/zig-curl | repos/zig-curl/src/Easy.zig | const std = @import("std");
const errors = @import("errors.zig");
const util = @import("util.zig");
const c = util.c;
const mem = std.mem;
const fmt = std.fmt;
const Allocator = mem.Allocator;
const checkCode = errors.checkCode;
const Buffer = util.Buffer;
const hasParseHeaderSupport = @import("util.zig").hasParseHeaderSupport;
const Self = @This();
allocator: Allocator,
handle: *c.CURL,
timeout_ms: usize,
user_agent: [:0]const u8,
ca_bundle: ?Buffer,
pub const Method = enum {
GET,
POST,
PUT,
HEAD,
PATCH,
DELETE,
fn asString(self: Method) [:0]const u8 {
return @tagName(self);
}
};
pub const Headers = struct {
headers: ?*c.struct_curl_slist,
allocator: Allocator,
pub fn init(allocator: Allocator) !Headers {
return .{
.allocator = allocator,
.headers = null,
};
}
pub fn deinit(self: Headers) void {
c.curl_slist_free_all(self.headers);
}
pub fn add(self: *Headers, name: []const u8, value: []const u8) !void {
const header = try std.fmt.allocPrintZ(self.allocator, "{s}: {s}", .{ name, value });
defer self.allocator.free(header);
self.headers = c.curl_slist_append(self.headers, header) orelse {
return errors.HeaderError.OutOfMemory;
};
}
};
pub const Response = struct {
body: ?Buffer = null,
status_code: i32,
handle: *c.CURL,
allocator: Allocator,
pub fn deinit(self: Response) void {
if (self.body) |body| {
body.deinit();
}
}
fn polyfill_struct_curl_header() type {
if (hasParseHeaderSupport()) {
return c.struct_curl_header;
} else {
// return a dummy struct to make it compile on old version.
return struct {
value: [:0]const u8,
};
}
}
pub const Header = struct {
c_header: *polyfill_struct_curl_header(),
name: []const u8,
/// Get the first value associated with the given key.
/// Applications need to copy the data if it wants to keep it around.
pub fn get(self: Header) []const u8 {
return mem.sliceTo(self.c_header.value, 0);
}
};
/// Gets the header associated with the given name.
pub fn getHeader(self: Response, name: [:0]const u8) errors.HeaderError!?Header {
if (comptime !hasParseHeaderSupport()) {
return error.NoCurlHeaderSupport;
}
var header: ?*c.struct_curl_header = null;
return Response.getHeaderInner(
self.handle,
name,
-1, // request, -1 means last request
&header,
);
}
fn getHeaderInner(easy: ?*c.CURL, name: [:0]const u8, request: c_int, hout: *?*c.struct_curl_header) errors.HeaderError!?Header {
const code = c.curl_easy_header(
easy,
name.ptr,
0, // index, 0 means first header
c.CURLH_HEADER,
request,
hout,
);
return if (errors.headerErrorFrom(code)) |err| switch (err) {
error.Missing, error.NoHeaders => null,
else => err,
} else .{
.c_header = hout.*.?,
.name = name,
};
}
pub const HeaderIterator = struct {
handle: *c.CURL,
name: ?[:0]const u8,
request: ?usize,
c_header: ?*polyfill_struct_curl_header() = null,
pub fn next(self: *HeaderIterator) !?Header {
if (comptime !hasParseHeaderSupport()) {
return error.NoCurlHeaderSupport;
}
const request: c_int = if (self.request) |v| @intCast(v) else -1;
if (self.name) |filter_name| {
if (self.c_header) |c_header| {
// fast path
if (c_header.*.index + 1 == c_header.*.amount) {
return null;
}
} else {
return Response.getHeaderInner(self.handle, filter_name, request, &self.c_header);
}
}
while (c.curl_easy_nextheader(
self.handle,
c.CURLH_HEADER,
request,
self.c_header,
)) |c_header| {
self.c_header = c_header;
const name = std.mem.sliceTo(c_header.*.name, 0);
if (self.name) |filter_name| {
if (!std.ascii.eqlIgnoreCase(name, filter_name)) {
continue;
}
}
return Header{
.c_header = c_header,
.name = name,
};
} else {
return null;
}
}
};
pub const IterateHeadersOptions = struct {
/// Only iterate over headers matching a specific name.
name: ?[:0]const u8 = null,
/// Which request you want headers from. Useful when there are redirections.
/// Leaving `null` means the last request.
request: ?usize = null,
};
pub fn iterateHeaders(self: Response, options: IterateHeadersOptions) errors.HeaderError!HeaderIterator {
if (comptime !hasParseHeaderSupport()) {
return error.NoCurlHeaderSupport;
}
return HeaderIterator{
.handle = self.handle,
.name = options.name,
.request = options.request,
};
}
pub fn getRedirectCount(self: Response) !usize {
var redirects: c_long = undefined;
try checkCode(c.curl_easy_getinfo(self.handle, c.CURLINFO_REDIRECT_COUNT, &redirects));
return @intCast(redirects);
}
};
pub const MultiPart = struct {
mime_handle: *c.curl_mime,
allocator: Allocator,
pub const DataSource = union(enum) {
/// Set a mime part's body content from memory data.
/// Data will get copied when send request.
/// Setting large data is memory consuming: one might consider using `data_callback` in such a case.
data: []const u8,
/// Set a mime part's body data from a file contents.
file: [:0]const u8,
// TODO: https://curl.se/libcurl/c/curl_mime_data_cb.html
// data_callback: u8,
};
pub fn deinit(self: MultiPart) void {
c.curl_mime_free(self.mime_handle);
}
pub fn addPart(self: MultiPart, name: [:0]const u8, source: DataSource) !void {
const part = if (c.curl_mime_addpart(self.mime_handle)) |part| part else return error.MimeAddPart;
try checkCode(c.curl_mime_name(part, name));
switch (source) {
.data => |slice| {
try checkCode(c.curl_mime_data(part, slice.ptr, slice.len));
},
.file => |filepath| {
try checkCode(c.curl_mime_filedata(part, filepath));
},
}
}
};
pub const Upload = struct {
file: std.fs.File,
file_len: u64,
pub fn init(path: []const u8) !Upload {
const file = try std.fs.cwd().openFile(path, .{});
const md = try file.metadata();
return .{ .file = file, .file_len = md.size() };
}
pub fn deinit(self: Upload) void {
self.file.close();
}
pub fn readFunction(ptr: [*c]c_char, size: c_uint, nmemb: c_uint, user_data: *anyopaque) callconv(.C) c_uint {
const up: *Upload = @alignCast(@ptrCast(user_data));
const max_length = @min(size * nmemb, up.file_len);
var buf: [*]u8 = @ptrCast(ptr);
const n = up.file.read(buf[0..max_length]) catch |e| {
std.log.err("Upload read file failed, err:{any}\n", .{e});
return c.CURL_READFUNC_ABORT;
};
return @intCast(n);
}
};
/// Init options for Easy handle
pub const Options = struct {
// Note that the vendored libcurl is compiled with mbedtls and does not include a CA bundle,
// so this should be set when link with vendored libcurl, otherwise https
// requests will fail.
ca_bundle: ?Buffer = null,
/// The maximum time in milliseconds that the entire transfer operation to take.
default_timeout_ms: usize = 30_000,
default_user_agent: [:0]const u8 = "zig-curl/0.1.0",
};
pub fn init(allocator: Allocator, options: Options) !Self {
return if (c.curl_easy_init()) |handle|
.{
.allocator = allocator,
.handle = handle,
.ca_bundle = options.ca_bundle,
.timeout_ms = options.default_timeout_ms,
.user_agent = options.default_user_agent,
}
else
error.CurlInit;
}
pub fn deinit(self: Self) void {
c.curl_easy_cleanup(self.handle);
}
pub fn createHeaders(self: Self) !Headers {
return Headers.init(self.allocator);
}
pub fn createMultiPart(self: Self) !MultiPart {
return if (c.curl_mime_init(self.handle)) |h|
.{
.allocator = self.allocator,
.mime_handle = h,
}
else
error.MimeInit;
}
pub fn setUrl(self: Self, url: [:0]const u8) !void {
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_URL, url.ptr));
}
pub fn setMaxRedirects(self: Self, redirects: u32) !void {
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_MAXREDIRS, @as(c_long, redirects)));
}
pub fn setMethod(self: Self, method: Method) !void {
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_CUSTOMREQUEST, method.asString().ptr));
}
pub fn setVerbose(self: Self, verbose: bool) !void {
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_VERBOSE, verbose));
}
pub fn setPostFields(self: Self, body: []const u8) !void {
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_POSTFIELDS, body.ptr));
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_POSTFIELDSIZE, body.len));
}
pub fn setMultiPart(self: Self, multi_part: MultiPart) !void {
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_MIMEPOST, multi_part.mime_handle));
}
pub fn setUpload(self: Self, up: *Upload) !void {
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_UPLOAD, @as(c_int, 1)));
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_READFUNCTION, Upload.readFunction));
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_READDATA, up));
}
pub fn setFollowLocation(self: Self, enable: bool) !void {
const param: c_long = @intCast(@intFromBool(enable));
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_FOLLOWLOCATION, param));
}
pub fn reset(self: Self) void {
c.curl_easy_reset(self.handle);
}
pub fn setHeaders(self: Self, headers: Headers) !void {
if (headers.headers) |c_headers| {
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_HTTPHEADER, c_headers));
}
}
pub fn setUnixSocketPath(self: Self, path: [:0]const u8) !void {
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_UNIX_SOCKET_PATH, path.ptr));
}
pub fn setWritedata(self: Self, data: *const anyopaque) !void {
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_WRITEDATA, data));
}
pub fn setWritefunction(
self: Self,
func: *const fn ([*c]c_char, c_uint, c_uint, *anyopaque) callconv(.C) c_uint,
) !void {
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_WRITEFUNCTION, func));
}
pub fn setUsername(self: Self, username: [:0]const u8) !void {
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_USERNAME, username.ptr));
}
pub fn setPassword(self: Self, password: [:0]const u8) !void {
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_PASSWORD, password.ptr));
}
/// Perform sends an HTTP request and returns an HTTP response.
pub fn perform(self: Self) !Response {
try self.setCommonOpts();
try checkCode(c.curl_easy_perform(self.handle));
var status_code: c_long = 0;
try checkCode(c.curl_easy_getinfo(self.handle, c.CURLINFO_RESPONSE_CODE, &status_code));
return .{
.status_code = @intCast(status_code),
.handle = self.handle,
.body = null,
.allocator = self.allocator,
};
}
/// Get issues a GET to the specified URL.
pub fn get(self: Self, url: [:0]const u8) !Response {
var buf = Buffer.init(self.allocator);
try self.setWritefunction(bufferWriteCallback);
try self.setWritedata(&buf);
try self.setUrl(url);
var resp = try self.perform();
resp.body = buf;
return resp;
}
/// Head issues a HEAD to the specified URL.
pub fn head(self: Self, url: [:0]const u8) !Response {
try self.setUrl(url);
try self.setMethod(.HEAD);
return self.perform();
}
/// Post issues a POST to the specified URL.
pub fn post(self: Self, url: [:0]const u8, content_type: []const u8, body: []const u8) !Response {
var buf = Buffer.init(self.allocator);
try self.setWritefunction(bufferWriteCallback);
try self.setWritedata(&buf);
try self.setUrl(url);
try self.setPostFields(body);
var headers = try self.createHeaders();
defer headers.deinit();
try headers.add("Content-Type", content_type);
try self.setHeaders(headers);
var resp = try self.perform();
resp.body = buf;
return resp;
}
/// Upload issues a PUT request to upload file.
pub fn upload(self: Self, url: [:0]const u8, path: []const u8) !Response {
var up = try Upload.init(path);
defer up.deinit();
try self.setUpload(&up);
var buf = Buffer.init(self.allocator);
try self.setWritefunction(bufferWriteCallback);
try self.setWritedata(&buf);
try self.setUrl(url);
var resp = try self.perform();
resp.body = buf;
return resp;
}
/// Used for write response via `Buffer` type.
// https://curl.se/libcurl/c/CURLOPT_WRITEFUNCTION.html
// size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata);
pub fn bufferWriteCallback(ptr: [*c]c_char, size: c_uint, nmemb: c_uint, user_data: *anyopaque) callconv(.C) c_uint {
const real_size = size * nmemb;
var buffer: *Buffer = @alignCast(@ptrCast(user_data));
var typed_data: [*]u8 = @ptrCast(ptr);
buffer.appendSlice(typed_data[0..real_size]) catch return 0;
return real_size;
}
pub fn setCommonOpts(self: Self) !void {
if (self.ca_bundle) |bundle| {
// https://curl.se/libcurl/c/CURLOPT_CAINFO_BLOB.html
// Different TLS backends might require higher verison of libcurl.
// BearSSL (since 7.79.0), mbedTLS (since 7.81.0), rustls (since 7.82.0), wolfSSL (since 8.2.0)
if (!c.CURL_AT_LEAST_VERSION(7, 77, 0)) {
return error.NoCaInfoBlobSupport;
}
const blob = c.curl_blob{
.data = @constCast(bundle.items.ptr),
.len = bundle.items.len,
.flags = c.CURL_BLOB_NOCOPY,
};
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_CAINFO_BLOB, blob));
}
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_TIMEOUT_MS, self.timeout_ms));
try checkCode(c.curl_easy_setopt(self.handle, c.CURLOPT_USERAGENT, self.user_agent.ptr));
}
|
0 | repos/zig-curl | repos/zig-curl/src/root.zig | const std = @import("std");
const util = @import("util.zig");
const checkCode = @import("errors.zig").checkCode;
pub const Easy = @import("Easy.zig");
pub const Multi = @import("Multi.zig");
pub const bufferWriteCallback = Easy.bufferWriteCallback;
pub const printLibcurlVersion = util.printLibcurlVersion;
pub const hasParseHeaderSupport = util.hasParseHeaderSupport;
pub const urlEncode = util.urlEncode;
pub const allocCABundle = util.allocCABundle;
pub const Buffer = util.Buffer;
pub const libcurl = util.c;
/// This function sets up the program environment that libcurl needs.
/// Since this function is not thread safe before libcurl 7.84.0, this function
/// must be called before the program calls any other function in libcurl.
/// A common place is in the beginning of the program. More see:
/// https://curl.se/libcurl/c/curl_global_init.html
pub fn globalInit() !void {
try checkCode(libcurl.curl_global_init(libcurl.CURL_GLOBAL_ALL));
}
/// This function releases resources acquired by curl_global_init.
pub fn globalDeinit() void {
libcurl.curl_global_cleanup();
}
test {
std.testing.refAllDecls(@This());
}
|
0 | repos/zig-curl | repos/zig-curl/src/errors.zig | const std = @import("std");
const assert = @import("std").debug.assert;
const c = @import("util.zig").c;
pub const HeaderError = error{
BadIndex,
Missing,
NoHeaders,
NoRequest,
OutOfMemory,
BadArgument,
NotBuiltIn,
UnknownHeaderError,
/// This means there is no `curl_easy_header` method in current libcurl.
NoCurlHeaderSupport,
};
pub fn headerErrorFrom(code: c.CURLHcode) ?HeaderError {
// https://curl.se/libcurl/c/libcurl-errors.html
return switch (code) {
c.CURLHE_OK => null,
c.CURLHE_BADINDEX => error.BadIndex,
c.CURLHE_MISSING => error.Missing,
c.CURLHE_NOHEADERS => error.NoHeaders,
c.CURLHE_NOREQUEST => error.NoRequest,
c.CURLHE_OUT_OF_MEMORY => error.OutOfMemory,
c.CURLHE_BAD_ARGUMENT => error.BadArgument,
c.CURLHE_NOT_BUILT_IN => error.NotBuiltIn,
else => error.UnknownHeaderError,
};
}
pub fn checkCode(code: c.CURLcode) !void {
if (code == c.CURLE_OK) {
return;
}
// https://curl.se/libcurl/c/libcurl-errors.html
std.log.debug("curl err code:{d}, msg:{s}\n", .{ code, c.curl_easy_strerror(code) });
return error.Unexpected;
}
pub fn checkMCode(code: c.CURLMcode) !void {
if (code == c.CURLM_OK) {
return;
}
// https://curl.se/libcurl/c/libcurl-errors.html
std.log.debug("curlm err code:{d}, msg:{s}\n", .{
code,
c.curl_multi_strerror(code),
});
return error.Unexpected;
}
|
0 | repos/zig-curl | repos/zig-curl/src/util.zig | const std = @import("std");
pub const c = @cImport({
@cInclude("curl/curl.h");
});
const Allocator = std.mem.Allocator;
const Encoder = std.base64.standard.Encoder;
pub const Buffer = std.ArrayList(u8);
pub fn encode_base64(allocator: Allocator, input: []const u8) ![]const u8 {
const encoded_len = Encoder.calcSize(input.len);
const dest = try allocator.alloc(u8, encoded_len);
return Encoder.encode(dest, input);
}
pub fn printLibcurlVersion() void {
const v = c.curl_version_info(c.CURLVERSION_NOW);
std.debug.print(
\\Libcurl build info
\\Host: {s}
\\Version: {s}
\\SSL version: {s}
\\Libz version: {s}
\\Protocols:
, .{
v.*.host,
v.*.version,
v.*.ssl_version,
v.*.libz_version,
});
var i: usize = 0;
while (v.*.protocols[i] != null) {
std.debug.print(" {s}", .{
v.*.protocols[i],
});
i += 1;
} else {
std.debug.print("\n", .{});
}
// feature_names is introduced in 7.87.0
if (@hasField(c.struct_curl_version_info_data, "feature_names")) {
std.debug.print("Features:", .{});
i = 0;
while (v.*.feature_names[i] != null) {
std.debug.print(" {s}", .{
v.*.feature_names[i],
});
i += 1;
} else {
std.debug.print("\n", .{});
}
}
}
pub fn hasParseHeaderSupport() bool {
// `curl_header` is officially supported since 7.84.0.
// https://everything.curl.dev/helpers/headerapi/index.html
return c.CURL_AT_LEAST_VERSION(7, 84, 0);
}
comptime {
// `CURL_AT_LEAST_VERSION` is only available since 7.43.0
// https://curl.se/libcurl/c/symbols-in-versions.html
if (!@hasDecl(c, "CURL_AT_LEAST_VERSION")) {
@compileError("Libcurl version must at least 7.43.0");
}
}
pub fn urlEncode(string: [:0]const u8) ?[]const u8 {
const r = c.curl_easy_escape(null, string.ptr, @intCast(string.len));
return std.mem.sliceTo(r.?, 0);
}
test "url encode" {
inline for (.{
.{
"https://github.com/",
"https%3A%2F%2Fgithub.com%2F",
},
.{
"https://httpbin.org/anything/你好",
"https%3A%2F%2Fhttpbin.org%2Fanything%2F%E4%BD%A0%E5%A5%BD",
},
}) |case| {
const input = case.@"0";
const expected = case.@"1";
const actual = urlEncode(input);
try std.testing.expectEqualStrings(expected, actual.?);
}
}
const CERT_MARKER_BEGIN = "-----BEGIN CERTIFICATE-----";
const CERT_MARKER_END = "\n-----END CERTIFICATE-----\n";
pub fn allocCABundle(allocator: std.mem.Allocator) !Buffer {
var bundle: std.crypto.Certificate.Bundle = .{};
defer bundle.deinit(allocator);
var blob = Buffer.init(allocator);
try bundle.rescan(allocator);
var iter = bundle.map.iterator();
while (iter.next()) |entry| {
const der = try std.crypto.Certificate.der.Element.parse(bundle.bytes.items, entry.value_ptr.*);
const cert = bundle.bytes.items[entry.value_ptr.*..der.slice.end];
const encoded = try encode_base64(allocator, cert);
defer allocator.free(encoded);
try blob.ensureUnusedCapacity(CERT_MARKER_BEGIN.len + CERT_MARKER_END.len + encoded.len);
try blob.appendSlice(CERT_MARKER_BEGIN);
for (encoded, 0..) |char, n| {
if (n % 64 == 0) try blob.append('\n');
try blob.append(char);
}
try blob.appendSlice(CERT_MARKER_END);
}
return blob;
}
|
0 | repos/zig-curl | repos/zig-curl/examples/advanced.zig | const std = @import("std");
const println = @import("util.zig").println;
const mem = std.mem;
const Allocator = mem.Allocator;
const curl = @import("curl");
const Easy = curl.Easy;
const UA = "Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/115.0";
const Response = struct {
headers: struct {
@"User-Agent": []const u8,
Authorization: []const u8,
},
json: struct {
name: []const u8,
age: usize,
},
method: []const u8,
url: []const u8,
};
fn putWithCustomHeader(allocator: Allocator, easy: Easy) !void {
const body =
\\ {"name": "John", "age": 15}
;
const headers = blk: {
var h = try easy.createHeaders();
errdefer h.deinit();
try h.add("content-type", "application/json");
try h.add("user-agent", UA);
try h.add("Authorization", "Basic YWxhZGRpbjpvcGVuc2VzYW1l");
break :blk h;
};
defer headers.deinit();
try easy.setUrl("https://httpbin.org/anything/zig-curl");
try easy.setHeaders(headers);
try easy.setMethod(.PUT);
try easy.setVerbose(true);
try easy.setPostFields(body);
var buf = curl.Buffer.init(allocator);
try easy.setWritedata(&buf);
try easy.setWritefunction(curl.bufferWriteCallback);
var resp = try easy.perform();
resp.body = buf;
defer resp.deinit();
std.debug.print("Status code: {d}\nBody: {s}\n", .{
resp.status_code,
resp.body.?.items,
});
const parsed = try std.json.parseFromSlice(Response, allocator, resp.body.?.items, .{
.ignore_unknown_fields = true,
});
defer parsed.deinit();
try std.testing.expectEqualDeep(
parsed.value,
Response{
.headers = .{
.@"User-Agent" = UA,
.Authorization = "Basic YWxhZGRpbjpvcGVuc2VzYW1l",
},
.json = .{
.name = "John",
.age = 15,
},
.method = "PUT",
.url = "https://httpbin.org/anything/zig-curl",
},
);
// Get response header `date`.
const date_header = resp.getHeader("date") catch |err| {
std.debug.print("Get header error: {any}\n", .{err});
return;
};
if (date_header) |h| {
std.debug.print("date header: {s}\n", .{h.get()});
} else {
std.debug.print("date header not found\n", .{});
}
}
fn postMutliPart(easy: Easy) !void {
// Reset old options, e.g. headers.
easy.reset();
const multi_part = try easy.createMultiPart();
try multi_part.addPart("foo", .{ .data = "hello foo" });
try multi_part.addPart("bar", .{ .data = "hello bar" });
try multi_part.addPart("build.zig", .{ .file = "build.zig" });
try multi_part.addPart("readme", .{ .file = "README.org" });
defer multi_part.deinit();
try easy.setUrl("https://httpbin.org/anything/mp");
try easy.setMethod(.PUT);
try easy.setMultiPart(multi_part);
try easy.setVerbose(true);
var buf = curl.Buffer.init(easy.allocator);
try easy.setWritedata(&buf);
try easy.setWritefunction(curl.bufferWriteCallback);
var resp = try easy.perform();
resp.body = buf;
defer resp.deinit();
std.debug.print("resp:{s}\n", .{resp.body.?.items});
}
pub fn main() !void {
const allocator = std.heap.page_allocator;
const ca_bundle = try curl.allocCABundle(allocator);
defer ca_bundle.deinit();
const easy = try Easy.init(allocator, .{
.ca_bundle = ca_bundle,
});
defer easy.deinit();
println("PUT with custom header demo");
try putWithCustomHeader(allocator, easy);
try postMutliPart(easy);
}
|
0 | repos/zig-curl | repos/zig-curl/examples/util.zig | const std = @import("std");
const SEP = "-" ** 20;
pub fn println(msg: []const u8) void {
std.debug.print("{s}{s}{s}\n", .{ SEP, msg, SEP });
}
|
0 | repos/zig-curl | repos/zig-curl/examples/basic.zig | const std = @import("std");
const println = @import("util.zig").println;
const mem = std.mem;
const Allocator = mem.Allocator;
const curl = @import("curl");
const Easy = curl.Easy;
const LOCAL_SERVER_ADDR = "http://localhost:8182";
fn get(allocator: Allocator, easy: Easy) !void {
try easy.setVerbose(true);
const resp = try easy.get("https://httpbin.org/anything");
defer resp.deinit();
const body = resp.body.?.items;
std.debug.print("Status code: {d}\nBody: {s}\n", .{
resp.status_code,
body,
});
const Response = struct {
headers: struct {
Host: []const u8,
},
method: []const u8,
};
const parsed = try std.json.parseFromSlice(Response, allocator, body, .{
.ignore_unknown_fields = true,
});
defer parsed.deinit();
try std.testing.expectEqualDeep(parsed.value, Response{
.headers = .{ .Host = "httpbin.org" },
.method = "GET",
});
}
fn post(allocator: Allocator, easy: Easy) !void {
const payload =
\\{"name": "John", "age": 15}
;
try easy.setVerbose(false);
const resp = try easy.post("https://httpbin.org/anything", "application/json", payload);
defer resp.deinit();
std.debug.print("Status code: {d}\nBody: {s}\n", .{
resp.status_code,
resp.body.?.items,
});
const Response = struct {
headers: struct {
@"Content-Type": []const u8,
},
json: struct {
name: []const u8,
age: u32,
},
method: []const u8,
};
const parsed = try std.json.parseFromSlice(Response, allocator, resp.body.?.items, .{ .ignore_unknown_fields = true });
defer parsed.deinit();
try std.testing.expectEqualDeep(parsed.value, Response{
.headers = .{ .@"Content-Type" = "application/json" },
.json = .{ .name = "John", .age = 15 },
.method = "POST",
});
}
fn upload(allocator: Allocator, easy: Easy) !void {
const path = "LICENSE";
const resp = try easy.upload(LOCAL_SERVER_ADDR ++ "/anything", path);
const Response = struct {
method: []const u8,
body_len: usize,
};
const parsed = try std.json.parseFromSlice(Response, allocator, resp.body.?.items, .{ .ignore_unknown_fields = true });
defer parsed.deinit();
try std.testing.expectEqualDeep(parsed.value, Response{
.body_len = 1086,
.method = "PUT",
});
std.debug.print("Status code: {d}\nBody: {s}\n", .{
resp.status_code,
resp.body.?.items,
});
}
pub fn main() !void {
const allocator = std.heap.page_allocator;
const ca_bundle = try curl.allocCABundle(allocator);
defer ca_bundle.deinit();
const easy = try Easy.init(allocator, .{
.ca_bundle = ca_bundle,
});
defer easy.deinit();
println("GET demo");
try get(allocator, easy);
println("POST demo");
easy.reset();
try post(allocator, easy);
println("Upload demo");
easy.reset();
try upload(allocator, easy);
}
|
0 | repos/zig-curl | repos/zig-curl/examples/multi.zig | const std = @import("std");
const println = @import("util.zig").println;
const mem = std.mem;
const Allocator = mem.Allocator;
const curl = @import("curl");
const Easy = curl.Easy;
const Multi = curl.Multi;
const c = curl.libcurl;
pub fn main() !void {
const allocator = std.heap.page_allocator;
const multi = try Multi.init();
defer multi.deinit();
const easy = try Easy.init(allocator, .{});
try easy.setUrl("http://httpbin.org/headers");
try multi.addHandle(easy);
const easy2 = try Easy.init(allocator, .{});
try easy2.setUrl("http://httpbin.org/ip");
try multi.addHandle(easy2);
var running = true;
while (running) {
const transfer = try multi.perform();
running = transfer != 0;
std.debug.print("num of transfer {any}\n", .{transfer});
const num_fds = try multi.poll(null, 3000);
std.debug.print("ret = {any}\n", .{num_fds});
}
running = true;
while (running) {
const info = try multi.readInfo();
running = info.msgs_in_queue != 0;
try multi.removeHandle(info.msg.easy_handle.?);
c.curl_easy_cleanup(info.msg.easy_handle.?);
std.debug.print("info {any}\n", .{info});
}
}
|
0 | repos/zig-curl | repos/zig-curl/examples/header.zig | const std = @import("std");
const curl = @import("curl");
const Easy = curl.Easy;
const println = @import("util.zig").println;
fn iterateHeaders(easy: Easy) !void {
// Reset old options, e.g. headers.
easy.reset();
const resp = try easy.get("https://httpbin.org/response-headers?X-Foo=1&X-Foo=2&X-Foo=3");
defer resp.deinit();
std.debug.print("Iterating all headers...\n", .{});
{
var iter = try resp.iterateHeaders(.{});
while (try iter.next()) |header| {
std.debug.print(" {s}: {s}\n", .{ header.name, header.get() });
}
}
// Iterating X-Foo only
{
var iter = try resp.iterateHeaders(.{ .name = "X-Foo" });
const expected_values = .{ "1", "2", "3" };
inline for (expected_values) |expected| {
const header = try iter.next() orelse unreachable;
try std.testing.expectEqualStrings(header.get(), expected);
}
try std.testing.expect((try iter.next()) == null);
}
}
fn iterateRedirectedHeaders(easy: Easy) !void {
// Reset old options, e.g. headers.
easy.reset();
try easy.setFollowLocation(true);
const resp = try easy.get("https://httpbin.org/redirect/1");
defer resp.deinit();
const redirects = try resp.getRedirectCount();
try std.testing.expectEqual(redirects, 1);
for (0..redirects + 1) |i| {
std.debug.print("Request #{} headers:\n", .{i});
var iter = try resp.iterateHeaders(.{ .request = i });
while (try iter.next()) |header| {
std.debug.print(" {s}: {s}\n", .{ header.name, header.get() });
}
}
// Iterating content-type only
const expected_values = [_][]const u8{ "text/html; charset=utf-8", "application/json" };
var count: usize = 0;
for (0..redirects + 1) |i| {
var iter = try resp.iterateHeaders(.{ .request = i, .name = "Content-Type" });
while (try iter.next()) |header| {
try std.testing.expectEqualStrings(header.get(), expected_values[count]);
count += 1;
}
}
try std.testing.expectEqual(count, 2);
}
pub fn main() !void {
const allocator = std.heap.page_allocator;
const ca_bundle = try curl.allocCABundle(allocator);
defer ca_bundle.deinit();
const easy = try Easy.init(allocator, .{
.ca_bundle = ca_bundle,
});
defer easy.deinit();
if (comptime !curl.hasParseHeaderSupport()) {
std.debug.print("Libcurl version too old, don't support parse headers.\n", .{});
return;
}
println("Iterate headers demo");
try iterateHeaders(easy);
println("Redirected headers demo");
try iterateRedirectedHeaders(easy);
}
|
0 | repos/zig-curl | repos/zig-curl/server/main.go | package main
import (
"encoding/json"
"fmt"
"html"
"io"
"log"
"net/http"
)
type Response struct {
Method string `json:"method"`
Path string `json:"path"`
Body string `json:"body"`
BodyLen int `json:"body_len"`
Headers map[string]string `json:"headers"`
}
func main() {
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
})
http.HandleFunc("/anything", func(w http.ResponseWriter, r *http.Request) {
bs, err := io.ReadAll(r.Body)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
defer r.Body.Close()
headers := map[string]string{}
for k, v := range r.Header {
headers[k] = v[0]
}
ret := Response{
Method: r.Method,
Path: r.URL.Path,
Body: string(bs),
BodyLen: len(bs),
Headers: headers,
}
err = json.NewEncoder(w).Encode(ret)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
})
log.Println("Listening on :8182")
log.Fatal(http.ListenAndServe(":8182", nil))
}
|
0 | repos/zig-curl | repos/zig-curl/server/go.mod | module server
go 1.20.0
|
0 | repos/zig-curl | repos/zig-curl/libs/zlib.zig | const std = @import("std");
pub fn create(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode) ?*std.Build.Step.Compile {
const lib = b.addStaticLibrary(.{
.name = "z",
.target = target,
.optimize = optimize,
.link_libc = true,
});
const zlib_dep = b.lazyDependency("zlib", .{
.target = target,
.optimize = optimize,
}) orelse return null;
inline for (srcs) |s| {
lib.addCSourceFile(.{
.file = zlib_dep.path(s),
.flags = &.{"-std=c89"},
});
}
lib.installHeader(zlib_dep.path("zlib.h"), "zlib.h");
lib.installHeader(zlib_dep.path("zconf.h"), "zconf.h");
return lib;
}
const srcs = &.{
"adler32.c",
"compress.c",
"crc32.c",
"deflate.c",
"gzclose.c",
"gzlib.c",
"gzread.c",
"gzwrite.c",
"inflate.c",
"infback.c",
"inftrees.c",
"inffast.c",
"trees.c",
"uncompr.c",
"zutil.c",
};
|
0 | repos/zig-curl | repos/zig-curl/libs/curl.zig | const std = @import("std");
pub fn create(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode) ?*std.Build.Step.Compile {
const lib = b.addStaticLibrary(.{
.name = "curl",
.target = target,
.optimize = optimize,
.link_libc = true,
});
const curl_dep = b.lazyDependency("curl", .{
.target = target,
.optimize = optimize,
}) orelse return null;
inline for (srcs) |s| {
lib.addCSourceFile(.{
.file = curl_dep.path(s),
.flags = &.{"-std=gnu89"},
});
}
lib.addIncludePath(curl_dep.path("lib"));
lib.addIncludePath(curl_dep.path("include"));
lib.installHeadersDirectory(curl_dep.path("include/curl"), "curl", .{});
lib.defineCMacro("BUILDING_LIBCURL", null);
lib.defineCMacro("CURL_STATICLIB", "1");
lib.defineCMacro("CURL_DISABLE_LDAP", "1");
lib.defineCMacro("CURL_DISABLE_LDAPS", "1");
lib.defineCMacro("USE_MBEDTLS", "1");
lib.defineCMacro("CURL_DISABLE_DICT", "1");
lib.defineCMacro("CURL_DISABLE_FILE", "1");
lib.defineCMacro("CURL_DISABLE_FTP", "1");
lib.defineCMacro("CURL_DISABLE_GOPHER", "1");
lib.defineCMacro("CURL_DISABLE_IMAP", "1");
lib.defineCMacro("CURL_DISABLE_MQTT", "1");
lib.defineCMacro("CURL_DISABLE_POP3", "1");
lib.defineCMacro("CURL_DISABLE_RTSP", "1");
lib.defineCMacro("CURL_DISABLE_SMB", "1");
lib.defineCMacro("CURL_DISABLE_SMTP", "1");
lib.defineCMacro("CURL_DISABLE_TELNET", "1");
lib.defineCMacro("CURL_DISABLE_TFTP", "1");
lib.defineCMacro("HAVE_LIBZ", "1");
lib.defineCMacro("HAVE_ZLIB_H", "1");
if (target.result.os.tag == .windows) {
lib.linkSystemLibrary("bcrypt");
return lib;
}
lib.defineCMacro("CURL_EXTERN_SYMBOL", "__attribute__ ((__visibility__ (\"default\"))");
const isDarwin = target.result.isDarwin();
if (!isDarwin)
lib.defineCMacro("ENABLE_IPV6", "1");
lib.defineCMacro("HAVE_ALARM", "1");
lib.defineCMacro("HAVE_ALLOCA_H", "1");
lib.defineCMacro("HAVE_ARPA_INET_H", "1");
lib.defineCMacro("HAVE_ARPA_TFTP_H", "1");
lib.defineCMacro("HAVE_ASSERT_H", "1");
lib.defineCMacro("HAVE_BASENAME", "1");
lib.defineCMacro("HAVE_BOOL_T", "1");
lib.defineCMacro("HAVE_BUILTIN_AVAILABLE", "1");
lib.defineCMacro("HAVE_CLOCK_GETTIME_MONOTONIC", "1");
lib.defineCMacro("HAVE_DLFCN_H", "1");
lib.defineCMacro("HAVE_ERRNO_H", "1");
lib.defineCMacro("HAVE_FCNTL", "1");
lib.defineCMacro("HAVE_FCNTL_H", "1");
lib.defineCMacro("HAVE_FCNTL_O_NONBLOCK", "1");
lib.defineCMacro("HAVE_FREEADDRINFO", "1");
lib.defineCMacro("HAVE_FTRUNCATE", "1");
lib.defineCMacro("HAVE_GETADDRINFO", "1");
lib.defineCMacro("HAVE_GETEUID", "1");
lib.defineCMacro("HAVE_GETPPID", "1");
lib.defineCMacro("HAVE_GETHOSTBYNAME", "1");
if (!isDarwin)
lib.defineCMacro("HAVE_GETHOSTBYNAME_R", "1");
lib.defineCMacro("HAVE_GETHOSTBYNAME_R_6", "1");
lib.defineCMacro("HAVE_GETHOSTNAME", "1");
lib.defineCMacro("HAVE_GETPPID", "1");
lib.defineCMacro("HAVE_GETPROTOBYNAME", "1");
lib.defineCMacro("HAVE_GETPEERNAME", "1");
lib.defineCMacro("HAVE_GETSOCKNAME", "1");
lib.defineCMacro("HAVE_IF_NAMETOINDEX", "1");
lib.defineCMacro("HAVE_GETPWUID", "1");
lib.defineCMacro("HAVE_GETPWUID_R", "1");
lib.defineCMacro("HAVE_GETRLIMIT", "1");
lib.defineCMacro("HAVE_GETTIMEOFDAY", "1");
lib.defineCMacro("HAVE_GMTIME_R", "1");
lib.defineCMacro("HAVE_IFADDRS_H", "1");
lib.defineCMacro("HAVE_INET_ADDR", "1");
lib.defineCMacro("HAVE_INET_PTON", "1");
lib.defineCMacro("HAVE_SA_FAMILY_T", "1");
lib.defineCMacro("HAVE_INTTYPES_H", "1");
lib.defineCMacro("HAVE_IOCTL", "1");
lib.defineCMacro("HAVE_IOCTL_FIONBIO", "1");
lib.defineCMacro("HAVE_IOCTL_SIOCGIFADDR", "1");
lib.defineCMacro("HAVE_LDAP_URL_PARSE", "1");
lib.defineCMacro("HAVE_LIBGEN_H", "1");
lib.defineCMacro("HAVE_IDN2_H", "1");
lib.defineCMacro("HAVE_LL", "1");
lib.defineCMacro("HAVE_LOCALE_H", "1");
lib.defineCMacro("HAVE_LOCALTIME_R", "1");
lib.defineCMacro("HAVE_LONGLONG", "1");
lib.defineCMacro("HAVE_MALLOC_H", "1");
lib.defineCMacro("HAVE_MEMORY_H", "1");
if (!isDarwin)
lib.defineCMacro("HAVE_MSG_NOSIGNAL", "1");
lib.defineCMacro("HAVE_NETDB_H", "1");
lib.defineCMacro("HAVE_NETINET_IN_H", "1");
lib.defineCMacro("HAVE_NETINET_TCP_H", "1");
if (target.result.os.tag == .linux)
lib.defineCMacro("HAVE_LINUX_TCP_H", "1");
lib.defineCMacro("HAVE_NET_IF_H", "1");
lib.defineCMacro("HAVE_PIPE", "1");
lib.defineCMacro("HAVE_POLL", "1");
lib.defineCMacro("HAVE_POLL_FINE", "1");
lib.defineCMacro("HAVE_POLL_H", "1");
lib.defineCMacro("HAVE_POSIX_STRERROR_R", "1");
lib.defineCMacro("HAVE_PTHREAD_H", "1");
lib.defineCMacro("HAVE_PWD_H", "1");
lib.defineCMacro("HAVE_RECV", "1");
lib.defineCMacro("HAVE_SELECT", "1");
lib.defineCMacro("HAVE_SEND", "1");
lib.defineCMacro("HAVE_FSETXATTR", "1");
lib.defineCMacro("HAVE_FSETXATTR_5", "1");
lib.defineCMacro("HAVE_SETJMP_H", "1");
lib.defineCMacro("HAVE_SETLOCALE", "1");
lib.defineCMacro("HAVE_SETRLIMIT", "1");
lib.defineCMacro("HAVE_SETSOCKOPT", "1");
lib.defineCMacro("HAVE_SIGACTION", "1");
lib.defineCMacro("HAVE_SIGINTERRUPT", "1");
lib.defineCMacro("HAVE_SIGNAL", "1");
lib.defineCMacro("HAVE_SIGNAL_H", "1");
lib.defineCMacro("HAVE_SIGSETJMP", "1");
lib.defineCMacro("HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID", "1");
lib.defineCMacro("HAVE_SOCKET", "1");
lib.defineCMacro("HAVE_STDBOOL_H", "1");
lib.defineCMacro("HAVE_STDINT_H", "1");
lib.defineCMacro("HAVE_STDIO_H", "1");
lib.defineCMacro("HAVE_STDLIB_H", "1");
lib.defineCMacro("HAVE_STRCASECMP", "1");
lib.defineCMacro("HAVE_STRDUP", "1");
lib.defineCMacro("HAVE_STRERROR_R", "1");
lib.defineCMacro("HAVE_STRINGS_H", "1");
lib.defineCMacro("HAVE_STRING_H", "1");
lib.defineCMacro("HAVE_STRSTR", "1");
lib.defineCMacro("HAVE_STRTOK_R", "1");
lib.defineCMacro("HAVE_STRTOLL", "1");
lib.defineCMacro("HAVE_STRUCT_SOCKADDR_STORAGE", "1");
lib.defineCMacro("HAVE_STRUCT_TIMEVAL", "1");
lib.defineCMacro("HAVE_SYS_IOCTL_H", "1");
lib.defineCMacro("HAVE_SYS_PARAM_H", "1");
lib.defineCMacro("HAVE_SYS_POLL_H", "1");
lib.defineCMacro("HAVE_SYS_RESOURCE_H", "1");
lib.defineCMacro("HAVE_SYS_SELECT_H", "1");
lib.defineCMacro("HAVE_SYS_SOCKET_H", "1");
lib.defineCMacro("HAVE_SYS_STAT_H", "1");
lib.defineCMacro("HAVE_SYS_TIME_H", "1");
lib.defineCMacro("HAVE_SYS_TYPES_H", "1");
lib.defineCMacro("HAVE_SYS_UIO_H", "1");
lib.defineCMacro("HAVE_SYS_UN_H", "1");
lib.defineCMacro("HAVE_TERMIOS_H", "1");
lib.defineCMacro("HAVE_TERMIO_H", "1");
lib.defineCMacro("HAVE_TIME_H", "1");
lib.defineCMacro("HAVE_UNAME", "1");
lib.defineCMacro("HAVE_UNISTD_H", "1");
lib.defineCMacro("HAVE_UTIME", "1");
lib.defineCMacro("HAVE_UTIMES", "1");
lib.defineCMacro("HAVE_UTIME_H", "1");
lib.defineCMacro("HAVE_VARIADIC_MACROS_C99", "1");
lib.defineCMacro("HAVE_VARIADIC_MACROS_GCC", "1");
lib.defineCMacro("OS", "\"Linux\"");
lib.defineCMacro("RANDOM_FILE", "\"/dev/urandom\"");
lib.defineCMacro("RECV_TYPE_ARG1", "int");
lib.defineCMacro("RECV_TYPE_ARG2", "void *");
lib.defineCMacro("RECV_TYPE_ARG3", "size_t");
lib.defineCMacro("RECV_TYPE_ARG4", "int");
lib.defineCMacro("RECV_TYPE_RETV", "ssize_t");
lib.defineCMacro("SEND_QUAL_ARG2", "const");
lib.defineCMacro("SEND_TYPE_ARG1", "int");
lib.defineCMacro("SEND_TYPE_ARG2", "void *");
lib.defineCMacro("SEND_TYPE_ARG3", "size_t");
lib.defineCMacro("SEND_TYPE_ARG4", "int");
lib.defineCMacro("SEND_TYPE_RETV", "ssize_t");
lib.defineCMacro("SIZEOF_INT", "4");
lib.defineCMacro("SIZEOF_SHORT", "2");
lib.defineCMacro("SIZEOF_LONG", "8");
lib.defineCMacro("SIZEOF_OFF_T", "8");
lib.defineCMacro("SIZEOF_CURL_OFF_T", "8");
lib.defineCMacro("SIZEOF_SIZE_T", "8");
lib.defineCMacro("SIZEOF_TIME_T", "8");
lib.defineCMacro("STDC_HEADERS", "1");
lib.defineCMacro("TIME_WITH_SYS_TIME", "1");
lib.defineCMacro("USE_THREADS_POSIX", "1");
lib.defineCMacro("USE_UNIX_SOCKETS", null);
lib.defineCMacro("_FILE_OFFSET_BITS", "64");
return lib;
}
const srcs = &.{
"lib/cookie.c",
"lib/http_chunks.c",
"lib/escape.c",
"lib/version_win32.c",
"lib/url.c",
"lib/base64.c",
"lib/mqtt.c",
"lib/setopt.c",
"lib/telnet.c",
"lib/hostip.c",
"lib/curl_gethostname.c",
"lib/connect.c",
"lib/socks_sspi.c",
"lib/cf-socket.c",
"lib/curl_fnmatch.c",
"lib/curl_gssapi.c",
"lib/http1.c",
"lib/multi.c",
"lib/gopher.c",
"lib/noproxy.c",
"lib/curl_sasl.c",
"lib/dict.c",
"lib/bufref.c",
"lib/slist.c",
"lib/curl_trc.c",
"lib/vtls/rustls.c",
"lib/vtls/mbedtls.c",
"lib/vtls/wolfssl.c",
"lib/vtls/schannel.c",
"lib/vtls/gtls.c",
"lib/vtls/sectransp.c",
"lib/vtls/vtls.c",
"lib/vtls/mbedtls_threadlock.c",
"lib/vtls/schannel_verify.c",
"lib/vtls/hostcheck.c",
"lib/vtls/bearssl.c",
"lib/vtls/openssl.c",
"lib/vtls/x509asn1.c",
"lib/vtls/keylog.c",
"lib/file.c",
"lib/socks_gssapi.c",
"lib/select.c",
"lib/socketpair.c",
"lib/curl_memrchr.c",
"lib/cfilters.c",
"lib/strtok.c",
"lib/version.c",
"lib/fopen.c",
"lib/http_aws_sigv4.c",
"lib/mprintf.c",
"lib/curl_path.c",
"lib/parsedate.c",
"lib/rename.c",
"lib/ftplistparser.c",
"lib/content_encoding.c",
"lib/mime.c",
"lib/rand.c",
"lib/curl_des.c",
"lib/curl_ntlm_core.c",
"lib/pop3.c",
"lib/curl_sspi.c",
"lib/smb.c",
"lib/conncache.c",
"lib/inet_pton.c",
"lib/if2ip.c",
"lib/openldap.c",
"lib/http_digest.c",
"lib/cf-h1-proxy.c",
"lib/asyn-thread.c",
"lib/strerror.c",
"lib/ftp.c",
"lib/strdup.c",
"lib/memdebug.c",
"lib/speedcheck.c",
"lib/vquic/curl_ngtcp2.c",
"lib/vquic/curl_msh3.c",
"lib/vquic/vquic.c",
"lib/vquic/curl_quiche.c",
"lib/getinfo.c",
"lib/http2.c",
"lib/vauth/oauth2.c",
"lib/vauth/vauth.c",
"lib/vauth/digest_sspi.c",
"lib/vauth/digest.c",
"lib/vauth/cram.c",
"lib/vauth/cleartext.c",
"lib/vauth/krb5_sspi.c",
"lib/vauth/spnego_sspi.c",
"lib/vauth/ntlm_sspi.c",
"lib/vauth/spnego_gssapi.c",
"lib/vauth/ntlm.c",
"lib/vauth/krb5_gssapi.c",
"lib/vauth/gsasl.c",
"lib/md4.c",
"lib/bufq.c",
"lib/curl_get_line.c",
"lib/hostip4.c",
"lib/curl_rtmp.c",
"lib/amigaos.c",
"lib/share.c",
"lib/warnless.c",
"lib/hostsyn.c",
"lib/md5.c",
"lib/strtoofft.c",
"lib/altsvc.c",
"lib/formdata.c",
"lib/dynbuf.c",
"lib/curl_addrinfo.c",
"lib/hostasyn.c",
"lib/doh.c",
"lib/request.c",
"lib/cw-out.c",
"lib/curl_sha512_256.c",
"lib/vtls/cipher_suite.c",
"lib/easygetopt.c",
"lib/ldap.c",
"lib/nonblock.c",
"lib/idn.c",
"lib/pingpong.c",
"lib/imap.c",
"lib/vssh/libssh.c",
"lib/vssh/wolfssh.c",
"lib/vssh/libssh2.c",
"lib/splay.c",
"lib/krb5.c",
"lib/progress.c",
"lib/cf-haproxy.c",
"lib/easyoptions.c",
"lib/curl_range.c",
"lib/curl_endian.c",
"lib/http_proxy.c",
"lib/inet_ntop.c",
"lib/timeval.c",
"lib/asyn-ares.c",
"lib/rtsp.c",
"lib/sha256.c",
"lib/curl_threads.c",
"lib/easy.c",
"lib/dynhds.c",
"lib/tftp.c",
"lib/hsts.c",
"lib/smtp.c",
"lib/hash.c",
"lib/cf-https-connect.c",
"lib/getenv.c",
"lib/headers.c",
"lib/system_win32.c",
"lib/http_ntlm.c",
"lib/psl.c",
"lib/ws.c",
"lib/hostip6.c",
"lib/curl_multibyte.c",
"lib/netrc.c",
"lib/llist.c",
"lib/urlapi.c",
"lib/strcase.c",
"lib/sendf.c",
"lib/timediff.c",
"lib/http.c",
"lib/cf-h2-proxy.c",
"lib/socks.c",
"lib/http_negotiate.c",
"lib/transfer.c",
"lib/c-hyper.c",
"lib/hmac.c",
"lib/fileinfo.c",
};
|
0 | repos/zig-curl | repos/zig-curl/libs/mbedtls.zig | const std = @import("std");
const ResolvedTarget = std.Build.ResolvedTarget;
pub fn create(b: *std.Build, target: ResolvedTarget, optimize: std.builtin.OptimizeMode) ?*std.Build.Step.Compile {
const lib = b.addStaticLibrary(.{
.name = "mbedtls",
.target = target,
.optimize = optimize,
.link_libc = true,
});
const mbedtls_dep = b.lazyDependency("mbedtls", .{
.target = target,
.optimize = optimize,
}) orelse return null;
inline for (srcs) |s| {
lib.addCSourceFile(.{ .file = mbedtls_dep.path(s), .flags = &.{"-std=c99"} });
}
lib.addIncludePath(mbedtls_dep.path("include"));
lib.addIncludePath(mbedtls_dep.path("library"));
lib.installHeadersDirectory(mbedtls_dep.path("include/mbedtls"), "mbedtls", .{});
lib.installHeadersDirectory(mbedtls_dep.path("include/psa"), "psa", .{});
if (target.result.os.tag == .windows) {
lib.linkSystemLibrary("ws2_32");
}
return lib;
}
const srcs = &.{
"library/aes.c",
"library/aesni.c",
"library/aesce.c",
"library/aria.c",
"library/asn1parse.c",
"library/asn1write.c",
"library/base64.c",
"library/bignum.c",
"library/bignum_core.c",
"library/bignum_mod.c",
"library/bignum_mod_raw.c",
"library/camellia.c",
"library/ccm.c",
"library/chacha20.c",
"library/chachapoly.c",
"library/cipher.c",
"library/cipher_wrap.c",
"library/constant_time.c",
"library/cmac.c",
"library/ctr_drbg.c",
"library/des.c",
"library/dhm.c",
"library/ecdh.c",
"library/ecdsa.c",
"library/ecjpake.c",
"library/ecp.c",
"library/ecp_curves.c",
"library/entropy.c",
"library/entropy_poll.c",
"library/error.c",
"library/gcm.c",
"library/hkdf.c",
"library/hmac_drbg.c",
"library/lmots.c",
"library/lms.c",
"library/md.c",
"library/md5.c",
"library/memory_buffer_alloc.c",
"library/nist_kw.c",
"library/oid.c",
"library/padlock.c",
"library/pem.c",
"library/pk.c",
"library/pk_ecc.c",
"library/pk_wrap.c",
"library/pkcs12.c",
"library/pkcs5.c",
"library/pkparse.c",
"library/pkwrite.c",
"library/platform.c",
"library/platform_util.c",
"library/poly1305.c",
"library/psa_crypto.c",
"library/psa_crypto_aead.c",
"library/psa_crypto_cipher.c",
"library/psa_crypto_client.c",
"library/psa_crypto_ffdh.c",
"library/psa_crypto_driver_wrappers_no_static.c",
"library/psa_crypto_ecp.c",
"library/psa_crypto_hash.c",
"library/psa_crypto_mac.c",
"library/psa_crypto_pake.c",
"library/psa_crypto_rsa.c",
"library/psa_crypto_se.c",
"library/psa_crypto_slot_management.c",
"library/psa_crypto_storage.c",
"library/psa_its_file.c",
"library/psa_util.c",
"library/ripemd160.c",
"library/rsa.c",
"library/rsa_alt_helpers.c",
"library/sha1.c",
"library/sha3.c",
"library/sha256.c",
"library/sha512.c",
"library/threading.c",
"library/timing.c",
"library/version.c",
"library/version_features.c",
"library/pkcs7.c",
"library/x509.c",
"library/x509_create.c",
"library/x509_crl.c",
"library/x509_crt.c",
"library/x509_csr.c",
"library/x509write_crt.c",
"library/x509write_csr.c",
"library/debug.c",
"library/mps_reader.c",
"library/mps_trace.c",
"library/net_sockets.c",
"library/ssl_cache.c",
"library/ssl_ciphersuites.c",
"library/ssl_client.c",
"library/ssl_cookie.c",
"library/ssl_debug_helpers_generated.c",
"library/ssl_msg.c",
"library/ssl_ticket.c",
"library/ssl_tls.c",
"library/ssl_tls12_client.c",
"library/ssl_tls12_server.c",
"library/ssl_tls13_keys.c",
"library/ssl_tls13_server.c",
"library/ssl_tls13_client.c",
"library/ssl_tls13_generic.c",
};
|
0 | repos | repos/bitcoinzig.org/.eslintrc.json | {
"extends": "next/core-web-vitals"
}
|
0 | repos | repos/bitcoinzig.org/package.json | {
"name": "bitcoinzig.org",
"version": "0.1.0",
"private": true,
"scripts": {
"dev": "next dev",
"build": "next build",
"start": "next start",
"lint": "next lint"
},
"dependencies": {
"react": "^18",
"react-dom": "^18",
"next": "14.2.7"
},
"devDependencies": {
"typescript": "^5",
"@types/node": "^20",
"@types/react": "^18",
"@types/react-dom": "^18",
"postcss": "^8",
"tailwindcss": "^3.4.1",
"eslint": "^8",
"eslint-config-next": "14.2.7"
}
}
|
0 | repos | repos/bitcoinzig.org/next.config.mjs | /** @type {import('next').NextConfig} */
const nextConfig = {};
export default nextConfig;
|
0 | repos | repos/bitcoinzig.org/postcss.config.mjs | /** @type {import('postcss-load-config').Config} */
const config = {
plugins: {
tailwindcss: {},
},
};
export default config;
|
0 | repos | repos/bitcoinzig.org/package-lock.json | {
"name": "bitcoinzig.org",
"version": "0.1.0",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "bitcoinzig.org",
"version": "0.1.0",
"dependencies": {
"next": "14.2.7",
"react": "^18",
"react-dom": "^18"
},
"devDependencies": {
"@types/node": "^20",
"@types/react": "^18",
"@types/react-dom": "^18",
"eslint": "^8",
"eslint-config-next": "14.2.7",
"postcss": "^8",
"tailwindcss": "^3.4.1",
"typescript": "^5"
}
},
"node_modules/@alloc/quick-lru": {
"version": "5.2.0",
"resolved": "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz",
"integrity": "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==",
"dev": true,
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/@eslint-community/eslint-utils": {
"version": "4.4.0",
"resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz",
"integrity": "sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==",
"dev": true,
"dependencies": {
"eslint-visitor-keys": "^3.3.0"
},
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
},
"peerDependencies": {
"eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
}
},
"node_modules/@eslint-community/regexpp": {
"version": "4.11.0",
"resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.11.0.tgz",
"integrity": "sha512-G/M/tIiMrTAxEWRfLfQJMmGNX28IxBg4PBz8XqQhqUHLFI6TL2htpIB1iQCj144V5ee/JaKyT9/WZ0MGZWfA7A==",
"dev": true,
"engines": {
"node": "^12.0.0 || ^14.0.0 || >=16.0.0"
}
},
"node_modules/@eslint/eslintrc": {
"version": "2.1.4",
"resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.4.tgz",
"integrity": "sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==",
"dev": true,
"dependencies": {
"ajv": "^6.12.4",
"debug": "^4.3.2",
"espree": "^9.6.0",
"globals": "^13.19.0",
"ignore": "^5.2.0",
"import-fresh": "^3.2.1",
"js-yaml": "^4.1.0",
"minimatch": "^3.1.2",
"strip-json-comments": "^3.1.1"
},
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
},
"funding": {
"url": "https://opencollective.com/eslint"
}
},
"node_modules/@eslint/js": {
"version": "8.57.0",
"resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.57.0.tgz",
"integrity": "sha512-Ys+3g2TaW7gADOJzPt83SJtCDhMjndcDMFVQ/Tj9iA1BfJzFKD9mAUXT3OenpuPHbI6P/myECxRJrofUsDx/5g==",
"dev": true,
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
}
},
"node_modules/@humanwhocodes/config-array": {
"version": "0.11.14",
"resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.14.tgz",
"integrity": "sha512-3T8LkOmg45BV5FICb15QQMsyUSWrQ8AygVfC7ZG32zOalnqrilm018ZVCw0eapXux8FtA33q8PSRSstjee3jSg==",
"deprecated": "Use @eslint/config-array instead",
"dev": true,
"dependencies": {
"@humanwhocodes/object-schema": "^2.0.2",
"debug": "^4.3.1",
"minimatch": "^3.0.5"
},
"engines": {
"node": ">=10.10.0"
}
},
"node_modules/@humanwhocodes/module-importer": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
"integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
"dev": true,
"engines": {
"node": ">=12.22"
},
"funding": {
"type": "github",
"url": "https://github.com/sponsors/nzakas"
}
},
"node_modules/@humanwhocodes/object-schema": {
"version": "2.0.3",
"resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-2.0.3.tgz",
"integrity": "sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==",
"deprecated": "Use @eslint/object-schema instead",
"dev": true
},
"node_modules/@isaacs/cliui": {
"version": "8.0.2",
"resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
"integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==",
"dev": true,
"dependencies": {
"string-width": "^5.1.2",
"string-width-cjs": "npm:string-width@^4.2.0",
"strip-ansi": "^7.0.1",
"strip-ansi-cjs": "npm:strip-ansi@^6.0.1",
"wrap-ansi": "^8.1.0",
"wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0"
},
"engines": {
"node": ">=12"
}
},
"node_modules/@isaacs/cliui/node_modules/ansi-regex": {
"version": "6.0.1",
"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz",
"integrity": "sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==",
"dev": true,
"engines": {
"node": ">=12"
},
"funding": {
"url": "https://github.com/chalk/ansi-regex?sponsor=1"
}
},
"node_modules/@isaacs/cliui/node_modules/strip-ansi": {
"version": "7.1.0",
"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
"integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
"dev": true,
"dependencies": {
"ansi-regex": "^6.0.1"
},
"engines": {
"node": ">=12"
},
"funding": {
"url": "https://github.com/chalk/strip-ansi?sponsor=1"
}
},
"node_modules/@jridgewell/gen-mapping": {
"version": "0.3.5",
"resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.5.tgz",
"integrity": "sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==",
"dev": true,
"dependencies": {
"@jridgewell/set-array": "^1.2.1",
"@jridgewell/sourcemap-codec": "^1.4.10",
"@jridgewell/trace-mapping": "^0.3.24"
},
"engines": {
"node": ">=6.0.0"
}
},
"node_modules/@jridgewell/resolve-uri": {
"version": "3.1.2",
"resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
"integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
"dev": true,
"engines": {
"node": ">=6.0.0"
}
},
"node_modules/@jridgewell/set-array": {
"version": "1.2.1",
"resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz",
"integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==",
"dev": true,
"engines": {
"node": ">=6.0.0"
}
},
"node_modules/@jridgewell/sourcemap-codec": {
"version": "1.5.0",
"resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz",
"integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==",
"dev": true
},
"node_modules/@jridgewell/trace-mapping": {
"version": "0.3.25",
"resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz",
"integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==",
"dev": true,
"dependencies": {
"@jridgewell/resolve-uri": "^3.1.0",
"@jridgewell/sourcemap-codec": "^1.4.14"
}
},
"node_modules/@next/env": {
"version": "14.2.7",
"resolved": "https://registry.npmjs.org/@next/env/-/env-14.2.7.tgz",
"integrity": "sha512-OTx9y6I3xE/eih+qtthppwLytmpJVPM5PPoJxChFsbjIEFXIayG0h/xLzefHGJviAa3Q5+Fd+9uYojKkHDKxoQ=="
},
"node_modules/@next/eslint-plugin-next": {
"version": "14.2.7",
"resolved": "https://registry.npmjs.org/@next/eslint-plugin-next/-/eslint-plugin-next-14.2.7.tgz",
"integrity": "sha512-+7xh142AdhZGjY9/L0iFo7mqRBMJHe+q+uOL+hto1Lfo9DeWCGcR6no4StlFbVSVcA6fQLKEX6y6qhMsSKbgNQ==",
"dev": true,
"dependencies": {
"glob": "10.3.10"
}
},
"node_modules/@next/swc-darwin-arm64": {
"version": "14.2.7",
"resolved": "https://registry.npmjs.org/@next/swc-darwin-arm64/-/swc-darwin-arm64-14.2.7.tgz",
"integrity": "sha512-UhZGcOyI9LE/tZL3h9rs/2wMZaaJKwnpAyegUVDGZqwsla6hMfeSj9ssBWQS9yA4UXun3pPhrFLVnw5KXZs3vw==",
"cpu": [
"arm64"
],
"optional": true,
"os": [
"darwin"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-darwin-x64": {
"version": "14.2.7",
"resolved": "https://registry.npmjs.org/@next/swc-darwin-x64/-/swc-darwin-x64-14.2.7.tgz",
"integrity": "sha512-ys2cUgZYRc+CbyDeLAaAdZgS7N1Kpyy+wo0b/gAj+SeOeaj0Lw/q+G1hp+DuDiDAVyxLBCJXEY/AkhDmtihUTA==",
"cpu": [
"x64"
],
"optional": true,
"os": [
"darwin"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-linux-arm64-gnu": {
"version": "14.2.7",
"resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-14.2.7.tgz",
"integrity": "sha512-2xoWtE13sUJ3qrC1lwE/HjbDPm+kBQYFkkiVECJWctRASAHQ+NwjMzgrfqqMYHfMxFb5Wws3w9PqzZJqKFdWcQ==",
"cpu": [
"arm64"
],
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-linux-arm64-musl": {
"version": "14.2.7",
"resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-14.2.7.tgz",
"integrity": "sha512-+zJ1gJdl35BSAGpkCbfyiY6iRTaPrt3KTl4SF/B1NyELkqqnrNX6cp4IjjjxKpd64/7enI0kf6b9O1Uf3cL0pw==",
"cpu": [
"arm64"
],
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-linux-x64-gnu": {
"version": "14.2.7",
"resolved": "https://registry.npmjs.org/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-14.2.7.tgz",
"integrity": "sha512-m6EBqrskeMUzykBrv0fDX/28lWIBGhMzOYaStp0ihkjzIYJiKUOzVYD1gULHc8XDf5EMSqoH/0/TRAgXqpQwmw==",
"cpu": [
"x64"
],
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-linux-x64-musl": {
"version": "14.2.7",
"resolved": "https://registry.npmjs.org/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-14.2.7.tgz",
"integrity": "sha512-gUu0viOMvMlzFRz1r1eQ7Ql4OE+hPOmA7smfZAhn8vC4+0swMZaZxa9CSIozTYavi+bJNDZ3tgiSdMjmMzRJlQ==",
"cpu": [
"x64"
],
"optional": true,
"os": [
"linux"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-win32-arm64-msvc": {
"version": "14.2.7",
"resolved": "https://registry.npmjs.org/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-14.2.7.tgz",
"integrity": "sha512-PGbONHIVIuzWlYmLvuFKcj+8jXnLbx4WrlESYlVnEzDsa3+Q2hI1YHoXaSmbq0k4ZwZ7J6sWNV4UZfx1OeOlbQ==",
"cpu": [
"arm64"
],
"optional": true,
"os": [
"win32"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-win32-ia32-msvc": {
"version": "14.2.7",
"resolved": "https://registry.npmjs.org/@next/swc-win32-ia32-msvc/-/swc-win32-ia32-msvc-14.2.7.tgz",
"integrity": "sha512-BiSY5umlx9ed5RQDoHcdbuKTUkuFORDqzYKPHlLeS+STUWQKWziVOn3Ic41LuTBvqE0TRJPKpio9GSIblNR+0w==",
"cpu": [
"ia32"
],
"optional": true,
"os": [
"win32"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@next/swc-win32-x64-msvc": {
"version": "14.2.7",
"resolved": "https://registry.npmjs.org/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-14.2.7.tgz",
"integrity": "sha512-pxsI23gKWRt/SPHFkDEsP+w+Nd7gK37Hpv0ngc5HpWy2e7cKx9zR/+Q2ptAUqICNTecAaGWvmhway7pj/JLEWA==",
"cpu": [
"x64"
],
"optional": true,
"os": [
"win32"
],
"engines": {
"node": ">= 10"
}
},
"node_modules/@nodelib/fs.scandir": {
"version": "2.1.5",
"resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
"integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
"dev": true,
"dependencies": {
"@nodelib/fs.stat": "2.0.5",
"run-parallel": "^1.1.9"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/@nodelib/fs.stat": {
"version": "2.0.5",
"resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
"integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
"dev": true,
"engines": {
"node": ">= 8"
}
},
"node_modules/@nodelib/fs.walk": {
"version": "1.2.8",
"resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
"integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
"dev": true,
"dependencies": {
"@nodelib/fs.scandir": "2.1.5",
"fastq": "^1.6.0"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/@nolyfill/is-core-module": {
"version": "1.0.39",
"resolved": "https://registry.npmjs.org/@nolyfill/is-core-module/-/is-core-module-1.0.39.tgz",
"integrity": "sha512-nn5ozdjYQpUCZlWGuxcJY/KpxkWQs4DcbMCmKojjyrYDEAGy4Ce19NN4v5MduafTwJlbKc99UA8YhSVqq9yPZA==",
"dev": true,
"engines": {
"node": ">=12.4.0"
}
},
"node_modules/@pkgjs/parseargs": {
"version": "0.11.0",
"resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
"integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==",
"dev": true,
"optional": true,
"engines": {
"node": ">=14"
}
},
"node_modules/@rushstack/eslint-patch": {
"version": "1.10.4",
"resolved": "https://registry.npmjs.org/@rushstack/eslint-patch/-/eslint-patch-1.10.4.tgz",
"integrity": "sha512-WJgX9nzTqknM393q1QJDJmoW28kUfEnybeTfVNcNAPnIx210RXm2DiXiHzfNPJNIUUb1tJnz/l4QGtJ30PgWmA==",
"dev": true
},
"node_modules/@swc/counter": {
"version": "0.1.3",
"resolved": "https://registry.npmjs.org/@swc/counter/-/counter-0.1.3.tgz",
"integrity": "sha512-e2BR4lsJkkRlKZ/qCHPw9ZaSxc0MVUd7gtbtaB7aMvHeJVYe8sOB8DBZkP2DtISHGSku9sCK6T6cnY0CtXrOCQ=="
},
"node_modules/@swc/helpers": {
"version": "0.5.5",
"resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.5.tgz",
"integrity": "sha512-KGYxvIOXcceOAbEk4bi/dVLEK9z8sZ0uBB3Il5b1rhfClSpcX0yfRO0KmTkqR2cnQDymwLB+25ZyMzICg/cm/A==",
"dependencies": {
"@swc/counter": "^0.1.3",
"tslib": "^2.4.0"
}
},
"node_modules/@types/json5": {
"version": "0.0.29",
"resolved": "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz",
"integrity": "sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==",
"dev": true
},
"node_modules/@types/node": {
"version": "20.16.3",
"resolved": "https://registry.npmjs.org/@types/node/-/node-20.16.3.tgz",
"integrity": "sha512-/wdGiWRkMOm53gAsSyFMXFZHbVg7C6CbkrzHNpaHoYfsUWPg7m6ZRKtvQjgvQ9i8WT540a3ydRlRQbxjY30XxQ==",
"dev": true,
"dependencies": {
"undici-types": "~6.19.2"
}
},
"node_modules/@types/prop-types": {
"version": "15.7.12",
"resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.12.tgz",
"integrity": "sha512-5zvhXYtRNRluoE/jAp4GVsSduVUzNWKkOZrCDBWYtE7biZywwdC2AcEzg+cSMLFRfVgeAFqpfNabiPjxFddV1Q==",
"dev": true
},
"node_modules/@types/react": {
"version": "18.3.5",
"resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.5.tgz",
"integrity": "sha512-WeqMfGJLGuLCqHGYRGHxnKrXcTitc6L/nBUWfWPcTarG3t9PsquqUMuVeXZeca+mglY4Vo5GZjCi0A3Or2lnxA==",
"dev": true,
"dependencies": {
"@types/prop-types": "*",
"csstype": "^3.0.2"
}
},
"node_modules/@types/react-dom": {
"version": "18.3.0",
"resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.3.0.tgz",
"integrity": "sha512-EhwApuTmMBmXuFOikhQLIBUn6uFg81SwLMOAUgodJF14SOBOCMdU04gDoYi0WOJJHD144TL32z4yDqCW3dnkQg==",
"dev": true,
"dependencies": {
"@types/react": "*"
}
},
"node_modules/@typescript-eslint/parser": {
"version": "7.2.0",
"resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-7.2.0.tgz",
"integrity": "sha512-5FKsVcHTk6TafQKQbuIVkXq58Fnbkd2wDL4LB7AURN7RUOu1utVP+G8+6u3ZhEroW3DF6hyo3ZEXxgKgp4KeCg==",
"dev": true,
"dependencies": {
"@typescript-eslint/scope-manager": "7.2.0",
"@typescript-eslint/types": "7.2.0",
"@typescript-eslint/typescript-estree": "7.2.0",
"@typescript-eslint/visitor-keys": "7.2.0",
"debug": "^4.3.4"
},
"engines": {
"node": "^16.0.0 || >=18.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/typescript-eslint"
},
"peerDependencies": {
"eslint": "^8.56.0"
},
"peerDependenciesMeta": {
"typescript": {
"optional": true
}
}
},
"node_modules/@typescript-eslint/scope-manager": {
"version": "7.2.0",
"resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-7.2.0.tgz",
"integrity": "sha512-Qh976RbQM/fYtjx9hs4XkayYujB/aPwglw2choHmf3zBjB4qOywWSdt9+KLRdHubGcoSwBnXUH2sR3hkyaERRg==",
"dev": true,
"dependencies": {
"@typescript-eslint/types": "7.2.0",
"@typescript-eslint/visitor-keys": "7.2.0"
},
"engines": {
"node": "^16.0.0 || >=18.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/typescript-eslint"
}
},
"node_modules/@typescript-eslint/types": {
"version": "7.2.0",
"resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-7.2.0.tgz",
"integrity": "sha512-XFtUHPI/abFhm4cbCDc5Ykc8npOKBSJePY3a3s+lwumt7XWJuzP5cZcfZ610MIPHjQjNsOLlYK8ASPaNG8UiyA==",
"dev": true,
"engines": {
"node": "^16.0.0 || >=18.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/typescript-eslint"
}
},
"node_modules/@typescript-eslint/typescript-estree": {
"version": "7.2.0",
"resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-7.2.0.tgz",
"integrity": "sha512-cyxS5WQQCoBwSakpMrvMXuMDEbhOo9bNHHrNcEWis6XHx6KF518tkF1wBvKIn/tpq5ZpUYK7Bdklu8qY0MsFIA==",
"dev": true,
"dependencies": {
"@typescript-eslint/types": "7.2.0",
"@typescript-eslint/visitor-keys": "7.2.0",
"debug": "^4.3.4",
"globby": "^11.1.0",
"is-glob": "^4.0.3",
"minimatch": "9.0.3",
"semver": "^7.5.4",
"ts-api-utils": "^1.0.1"
},
"engines": {
"node": "^16.0.0 || >=18.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/typescript-eslint"
},
"peerDependenciesMeta": {
"typescript": {
"optional": true
}
}
},
"node_modules/@typescript-eslint/typescript-estree/node_modules/brace-expansion": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
"integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
"dev": true,
"dependencies": {
"balanced-match": "^1.0.0"
}
},
"node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": {
"version": "9.0.3",
"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz",
"integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==",
"dev": true,
"dependencies": {
"brace-expansion": "^2.0.1"
},
"engines": {
"node": ">=16 || 14 >=14.17"
},
"funding": {
"url": "https://github.com/sponsors/isaacs"
}
},
"node_modules/@typescript-eslint/visitor-keys": {
"version": "7.2.0",
"resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-7.2.0.tgz",
"integrity": "sha512-c6EIQRHhcpl6+tO8EMR+kjkkV+ugUNXOmeASA1rlzkd8EPIriavpWoiEz1HR/VLhbVIdhqnV6E7JZm00cBDx2A==",
"dev": true,
"dependencies": {
"@typescript-eslint/types": "7.2.0",
"eslint-visitor-keys": "^3.4.1"
},
"engines": {
"node": "^16.0.0 || >=18.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/typescript-eslint"
}
},
"node_modules/@ungap/structured-clone": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.0.tgz",
"integrity": "sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==",
"dev": true
},
"node_modules/acorn": {
"version": "8.12.1",
"resolved": "https://registry.npmjs.org/acorn/-/acorn-8.12.1.tgz",
"integrity": "sha512-tcpGyI9zbizT9JbV6oYE477V6mTlXvvi0T0G3SNIYE2apm/G5huBa1+K89VGeovbg+jycCrfhl3ADxErOuO6Jg==",
"dev": true,
"bin": {
"acorn": "bin/acorn"
},
"engines": {
"node": ">=0.4.0"
}
},
"node_modules/acorn-jsx": {
"version": "5.3.2",
"resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
"integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
"dev": true,
"peerDependencies": {
"acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
}
},
"node_modules/ajv": {
"version": "6.12.6",
"resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
"integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
"dev": true,
"dependencies": {
"fast-deep-equal": "^3.1.1",
"fast-json-stable-stringify": "^2.0.0",
"json-schema-traverse": "^0.4.1",
"uri-js": "^4.2.2"
},
"funding": {
"type": "github",
"url": "https://github.com/sponsors/epoberezkin"
}
},
"node_modules/ansi-regex": {
"version": "5.0.1",
"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
"integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/ansi-styles": {
"version": "4.3.0",
"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
"integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
"dev": true,
"dependencies": {
"color-convert": "^2.0.1"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/chalk/ansi-styles?sponsor=1"
}
},
"node_modules/any-promise": {
"version": "1.3.0",
"resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz",
"integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==",
"dev": true
},
"node_modules/anymatch": {
"version": "3.1.3",
"resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
"integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
"dev": true,
"dependencies": {
"normalize-path": "^3.0.0",
"picomatch": "^2.0.4"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/arg": {
"version": "5.0.2",
"resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz",
"integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==",
"dev": true
},
"node_modules/argparse": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
"integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
"dev": true
},
"node_modules/aria-query": {
"version": "5.1.3",
"resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.1.3.tgz",
"integrity": "sha512-R5iJ5lkuHybztUfuOAznmboyjWq8O6sqNqtK7CLOqdydi54VNbORp49mb14KbWgG1QD3JFO9hJdZ+y4KutfdOQ==",
"dev": true,
"dependencies": {
"deep-equal": "^2.0.5"
}
},
"node_modules/array-buffer-byte-length": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.1.tgz",
"integrity": "sha512-ahC5W1xgou+KTXix4sAO8Ki12Q+jf4i0+tmk3sC+zgcynshkHxzpXdImBehiUYKKKDwvfFiJl1tZt6ewscS1Mg==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.5",
"is-array-buffer": "^3.0.4"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/array-includes": {
"version": "3.1.8",
"resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.8.tgz",
"integrity": "sha512-itaWrbYbqpGXkGhZPGUulwnhVf5Hpy1xiCFsGqyIGglbBxmG5vSjxQen3/WGOjPpNEv1RtBLKxbmVXm8HpJStQ==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"define-properties": "^1.2.1",
"es-abstract": "^1.23.2",
"es-object-atoms": "^1.0.0",
"get-intrinsic": "^1.2.4",
"is-string": "^1.0.7"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/array-union": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz",
"integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/array.prototype.findlast": {
"version": "1.2.5",
"resolved": "https://registry.npmjs.org/array.prototype.findlast/-/array.prototype.findlast-1.2.5.tgz",
"integrity": "sha512-CVvd6FHg1Z3POpBLxO6E6zr+rSKEQ9L6rZHAaY7lLfhKsWYUBBOuMs0e9o24oopj6H+geRCX0YJ+TJLBK2eHyQ==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"define-properties": "^1.2.1",
"es-abstract": "^1.23.2",
"es-errors": "^1.3.0",
"es-object-atoms": "^1.0.0",
"es-shim-unscopables": "^1.0.2"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/array.prototype.findlastindex": {
"version": "1.2.5",
"resolved": "https://registry.npmjs.org/array.prototype.findlastindex/-/array.prototype.findlastindex-1.2.5.tgz",
"integrity": "sha512-zfETvRFA8o7EiNn++N5f/kaCw221hrpGsDmcpndVupkPzEc1Wuf3VgC0qby1BbHs7f5DVYjgtEU2LLh5bqeGfQ==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"define-properties": "^1.2.1",
"es-abstract": "^1.23.2",
"es-errors": "^1.3.0",
"es-object-atoms": "^1.0.0",
"es-shim-unscopables": "^1.0.2"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/array.prototype.flat": {
"version": "1.3.2",
"resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.2.tgz",
"integrity": "sha512-djYB+Zx2vLewY8RWlNCUdHjDXs2XOgm602S9E7P/UpHgfeHL00cRiIF+IN/G/aUJ7kGPb6yO/ErDI5V2s8iycA==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.2",
"define-properties": "^1.2.0",
"es-abstract": "^1.22.1",
"es-shim-unscopables": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/array.prototype.flatmap": {
"version": "1.3.2",
"resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.2.tgz",
"integrity": "sha512-Ewyx0c9PmpcsByhSW4r+9zDU7sGjFc86qf/kKtuSCRdhfbk0SNLLkaT5qvcHnRGgc5NP/ly/y+qkXkqONX54CQ==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.2",
"define-properties": "^1.2.0",
"es-abstract": "^1.22.1",
"es-shim-unscopables": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/array.prototype.tosorted": {
"version": "1.1.4",
"resolved": "https://registry.npmjs.org/array.prototype.tosorted/-/array.prototype.tosorted-1.1.4.tgz",
"integrity": "sha512-p6Fx8B7b7ZhL/gmUsAy0D15WhvDccw3mnGNbZpi3pmeJdxtWsj2jEaI4Y6oo3XiHfzuSgPwKc04MYt6KgvC/wA==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"define-properties": "^1.2.1",
"es-abstract": "^1.23.3",
"es-errors": "^1.3.0",
"es-shim-unscopables": "^1.0.2"
},
"engines": {
"node": ">= 0.4"
}
},
"node_modules/arraybuffer.prototype.slice": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.3.tgz",
"integrity": "sha512-bMxMKAjg13EBSVscxTaYA4mRc5t1UAXa2kXiGTNfZ079HIWXEkKmkgFrh/nJqamaLSrXO5H4WFFkPEaLJWbs3A==",
"dev": true,
"dependencies": {
"array-buffer-byte-length": "^1.0.1",
"call-bind": "^1.0.5",
"define-properties": "^1.2.1",
"es-abstract": "^1.22.3",
"es-errors": "^1.2.1",
"get-intrinsic": "^1.2.3",
"is-array-buffer": "^3.0.4",
"is-shared-array-buffer": "^1.0.2"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/ast-types-flow": {
"version": "0.0.8",
"resolved": "https://registry.npmjs.org/ast-types-flow/-/ast-types-flow-0.0.8.tgz",
"integrity": "sha512-OH/2E5Fg20h2aPrbe+QL8JZQFko0YZaF+j4mnQ7BGhfavO7OpSLa8a0y9sBwomHdSbkhTS8TQNayBfnW5DwbvQ==",
"dev": true
},
"node_modules/available-typed-arrays": {
"version": "1.0.7",
"resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",
"integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==",
"dev": true,
"dependencies": {
"possible-typed-array-names": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/axe-core": {
"version": "4.10.0",
"resolved": "https://registry.npmjs.org/axe-core/-/axe-core-4.10.0.tgz",
"integrity": "sha512-Mr2ZakwQ7XUAjp7pAwQWRhhK8mQQ6JAaNWSjmjxil0R8BPioMtQsTLOolGYkji1rcL++3dCqZA3zWqpT+9Ew6g==",
"dev": true,
"engines": {
"node": ">=4"
}
},
"node_modules/axobject-query": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-3.1.1.tgz",
"integrity": "sha512-goKlv8DZrK9hUh975fnHzhNIO4jUnFCfv/dszV5VwUGDFjI6vQ2VwoyjYjYNEbBE8AH87TduWP5uyDR1D+Iteg==",
"dev": true,
"dependencies": {
"deep-equal": "^2.0.5"
}
},
"node_modules/balanced-match": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
"integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
"dev": true
},
"node_modules/binary-extensions": {
"version": "2.3.0",
"resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
"integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
"dev": true,
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/brace-expansion": {
"version": "1.1.11",
"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
"integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
"dev": true,
"dependencies": {
"balanced-match": "^1.0.0",
"concat-map": "0.0.1"
}
},
"node_modules/braces": {
"version": "3.0.3",
"resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
"integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
"dev": true,
"dependencies": {
"fill-range": "^7.1.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/busboy": {
"version": "1.6.0",
"resolved": "https://registry.npmjs.org/busboy/-/busboy-1.6.0.tgz",
"integrity": "sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA==",
"dependencies": {
"streamsearch": "^1.1.0"
},
"engines": {
"node": ">=10.16.0"
}
},
"node_modules/call-bind": {
"version": "1.0.7",
"resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.7.tgz",
"integrity": "sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==",
"dev": true,
"dependencies": {
"es-define-property": "^1.0.0",
"es-errors": "^1.3.0",
"function-bind": "^1.1.2",
"get-intrinsic": "^1.2.4",
"set-function-length": "^1.2.1"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/callsites": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
"integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
"dev": true,
"engines": {
"node": ">=6"
}
},
"node_modules/camelcase-css": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz",
"integrity": "sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==",
"dev": true,
"engines": {
"node": ">= 6"
}
},
"node_modules/caniuse-lite": {
"version": "1.0.30001655",
"resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001655.tgz",
"integrity": "sha512-jRGVy3iSGO5Uutn2owlb5gR6qsGngTw9ZTb4ali9f3glshcNmJ2noam4Mo9zia5P9Dk3jNNydy7vQjuE5dQmfg==",
"funding": [
{
"type": "opencollective",
"url": "https://opencollective.com/browserslist"
},
{
"type": "tidelift",
"url": "https://tidelift.com/funding/github/npm/caniuse-lite"
},
{
"type": "github",
"url": "https://github.com/sponsors/ai"
}
]
},
"node_modules/chalk": {
"version": "4.1.2",
"resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
"integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
"dev": true,
"dependencies": {
"ansi-styles": "^4.1.0",
"supports-color": "^7.1.0"
},
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/chalk/chalk?sponsor=1"
}
},
"node_modules/chokidar": {
"version": "3.6.0",
"resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
"integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
"dev": true,
"dependencies": {
"anymatch": "~3.1.2",
"braces": "~3.0.2",
"glob-parent": "~5.1.2",
"is-binary-path": "~2.1.0",
"is-glob": "~4.0.1",
"normalize-path": "~3.0.0",
"readdirp": "~3.6.0"
},
"engines": {
"node": ">= 8.10.0"
},
"funding": {
"url": "https://paulmillr.com/funding/"
},
"optionalDependencies": {
"fsevents": "~2.3.2"
}
},
"node_modules/chokidar/node_modules/glob-parent": {
"version": "5.1.2",
"resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
"integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
"dev": true,
"dependencies": {
"is-glob": "^4.0.1"
},
"engines": {
"node": ">= 6"
}
},
"node_modules/client-only": {
"version": "0.0.1",
"resolved": "https://registry.npmjs.org/client-only/-/client-only-0.0.1.tgz",
"integrity": "sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA=="
},
"node_modules/color-convert": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
"integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
"dev": true,
"dependencies": {
"color-name": "~1.1.4"
},
"engines": {
"node": ">=7.0.0"
}
},
"node_modules/color-name": {
"version": "1.1.4",
"resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
"integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
"dev": true
},
"node_modules/commander": {
"version": "4.1.1",
"resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz",
"integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==",
"dev": true,
"engines": {
"node": ">= 6"
}
},
"node_modules/concat-map": {
"version": "0.0.1",
"resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
"integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
"dev": true
},
"node_modules/cross-spawn": {
"version": "7.0.3",
"resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz",
"integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==",
"dev": true,
"dependencies": {
"path-key": "^3.1.0",
"shebang-command": "^2.0.0",
"which": "^2.0.1"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/cssesc": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
"integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==",
"dev": true,
"bin": {
"cssesc": "bin/cssesc"
},
"engines": {
"node": ">=4"
}
},
"node_modules/csstype": {
"version": "3.1.3",
"resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
"integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==",
"dev": true
},
"node_modules/damerau-levenshtein": {
"version": "1.0.8",
"resolved": "https://registry.npmjs.org/damerau-levenshtein/-/damerau-levenshtein-1.0.8.tgz",
"integrity": "sha512-sdQSFB7+llfUcQHUQO3+B8ERRj0Oa4w9POWMI/puGtuf7gFywGmkaLCElnudfTiKZV+NvHqL0ifzdrI8Ro7ESA==",
"dev": true
},
"node_modules/data-view-buffer": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.1.tgz",
"integrity": "sha512-0lht7OugA5x3iJLOWFhWK/5ehONdprk0ISXqVFn/NFrDu+cuc8iADFrGQz5BnRK7LLU3JmkbXSxaqX+/mXYtUA==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.6",
"es-errors": "^1.3.0",
"is-data-view": "^1.0.1"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/data-view-byte-length": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/data-view-byte-length/-/data-view-byte-length-1.0.1.tgz",
"integrity": "sha512-4J7wRJD3ABAzr8wP+OcIcqq2dlUKp4DVflx++hs5h5ZKydWMI6/D/fAot+yh6g2tHh8fLFTvNOaVN357NvSrOQ==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"es-errors": "^1.3.0",
"is-data-view": "^1.0.1"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/data-view-byte-offset": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/data-view-byte-offset/-/data-view-byte-offset-1.0.0.tgz",
"integrity": "sha512-t/Ygsytq+R995EJ5PZlD4Cu56sWa8InXySaViRzw9apusqsOO2bQP+SbYzAhR0pFKoB+43lYy8rWban9JSuXnA==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.6",
"es-errors": "^1.3.0",
"is-data-view": "^1.0.1"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/debug": {
"version": "4.3.6",
"resolved": "https://registry.npmjs.org/debug/-/debug-4.3.6.tgz",
"integrity": "sha512-O/09Bd4Z1fBrU4VzkhFqVgpPzaGbw6Sm9FEkBT1A/YBXQFGuuSxa1dN2nxgxS34JmKXqYx8CZAwEVoJFImUXIg==",
"dev": true,
"dependencies": {
"ms": "2.1.2"
},
"engines": {
"node": ">=6.0"
},
"peerDependenciesMeta": {
"supports-color": {
"optional": true
}
}
},
"node_modules/deep-equal": {
"version": "2.2.3",
"resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-2.2.3.tgz",
"integrity": "sha512-ZIwpnevOurS8bpT4192sqAowWM76JDKSHYzMLty3BZGSswgq6pBaH3DhCSW5xVAZICZyKdOBPjwww5wfgT/6PA==",
"dev": true,
"dependencies": {
"array-buffer-byte-length": "^1.0.0",
"call-bind": "^1.0.5",
"es-get-iterator": "^1.1.3",
"get-intrinsic": "^1.2.2",
"is-arguments": "^1.1.1",
"is-array-buffer": "^3.0.2",
"is-date-object": "^1.0.5",
"is-regex": "^1.1.4",
"is-shared-array-buffer": "^1.0.2",
"isarray": "^2.0.5",
"object-is": "^1.1.5",
"object-keys": "^1.1.1",
"object.assign": "^4.1.4",
"regexp.prototype.flags": "^1.5.1",
"side-channel": "^1.0.4",
"which-boxed-primitive": "^1.0.2",
"which-collection": "^1.0.1",
"which-typed-array": "^1.1.13"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/deep-is": {
"version": "0.1.4",
"resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
"integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
"dev": true
},
"node_modules/define-data-property": {
"version": "1.1.4",
"resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
"integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
"dev": true,
"dependencies": {
"es-define-property": "^1.0.0",
"es-errors": "^1.3.0",
"gopd": "^1.0.1"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/define-properties": {
"version": "1.2.1",
"resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz",
"integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==",
"dev": true,
"dependencies": {
"define-data-property": "^1.0.1",
"has-property-descriptors": "^1.0.0",
"object-keys": "^1.1.1"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/didyoumean": {
"version": "1.2.2",
"resolved": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz",
"integrity": "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==",
"dev": true
},
"node_modules/dir-glob": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz",
"integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==",
"dev": true,
"dependencies": {
"path-type": "^4.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/dlv": {
"version": "1.1.3",
"resolved": "https://registry.npmjs.org/dlv/-/dlv-1.1.3.tgz",
"integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==",
"dev": true
},
"node_modules/doctrine": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz",
"integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==",
"dev": true,
"dependencies": {
"esutils": "^2.0.2"
},
"engines": {
"node": ">=6.0.0"
}
},
"node_modules/eastasianwidth": {
"version": "0.2.0",
"resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
"integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
"dev": true
},
"node_modules/emoji-regex": {
"version": "9.2.2",
"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
"integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
"dev": true
},
"node_modules/enhanced-resolve": {
"version": "5.17.1",
"resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.17.1.tgz",
"integrity": "sha512-LMHl3dXhTcfv8gM4kEzIUeTQ+7fpdA0l2tUf34BddXPkz2A5xJ5L/Pchd5BL6rdccM9QGvu0sWZzK1Z1t4wwyg==",
"dev": true,
"dependencies": {
"graceful-fs": "^4.2.4",
"tapable": "^2.2.0"
},
"engines": {
"node": ">=10.13.0"
}
},
"node_modules/es-abstract": {
"version": "1.23.3",
"resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.23.3.tgz",
"integrity": "sha512-e+HfNH61Bj1X9/jLc5v1owaLYuHdeHHSQlkhCBiTK8rBvKaULl/beGMxwrMXjpYrv4pz22BlY570vVePA2ho4A==",
"dev": true,
"dependencies": {
"array-buffer-byte-length": "^1.0.1",
"arraybuffer.prototype.slice": "^1.0.3",
"available-typed-arrays": "^1.0.7",
"call-bind": "^1.0.7",
"data-view-buffer": "^1.0.1",
"data-view-byte-length": "^1.0.1",
"data-view-byte-offset": "^1.0.0",
"es-define-property": "^1.0.0",
"es-errors": "^1.3.0",
"es-object-atoms": "^1.0.0",
"es-set-tostringtag": "^2.0.3",
"es-to-primitive": "^1.2.1",
"function.prototype.name": "^1.1.6",
"get-intrinsic": "^1.2.4",
"get-symbol-description": "^1.0.2",
"globalthis": "^1.0.3",
"gopd": "^1.0.1",
"has-property-descriptors": "^1.0.2",
"has-proto": "^1.0.3",
"has-symbols": "^1.0.3",
"hasown": "^2.0.2",
"internal-slot": "^1.0.7",
"is-array-buffer": "^3.0.4",
"is-callable": "^1.2.7",
"is-data-view": "^1.0.1",
"is-negative-zero": "^2.0.3",
"is-regex": "^1.1.4",
"is-shared-array-buffer": "^1.0.3",
"is-string": "^1.0.7",
"is-typed-array": "^1.1.13",
"is-weakref": "^1.0.2",
"object-inspect": "^1.13.1",
"object-keys": "^1.1.1",
"object.assign": "^4.1.5",
"regexp.prototype.flags": "^1.5.2",
"safe-array-concat": "^1.1.2",
"safe-regex-test": "^1.0.3",
"string.prototype.trim": "^1.2.9",
"string.prototype.trimend": "^1.0.8",
"string.prototype.trimstart": "^1.0.8",
"typed-array-buffer": "^1.0.2",
"typed-array-byte-length": "^1.0.1",
"typed-array-byte-offset": "^1.0.2",
"typed-array-length": "^1.0.6",
"unbox-primitive": "^1.0.2",
"which-typed-array": "^1.1.15"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/es-define-property": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.0.tgz",
"integrity": "sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==",
"dev": true,
"dependencies": {
"get-intrinsic": "^1.2.4"
},
"engines": {
"node": ">= 0.4"
}
},
"node_modules/es-errors": {
"version": "1.3.0",
"resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
"integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
"dev": true,
"engines": {
"node": ">= 0.4"
}
},
"node_modules/es-get-iterator": {
"version": "1.1.3",
"resolved": "https://registry.npmjs.org/es-get-iterator/-/es-get-iterator-1.1.3.tgz",
"integrity": "sha512-sPZmqHBe6JIiTfN5q2pEi//TwxmAFHwj/XEuYjTuse78i8KxaqMTTzxPoFKuzRpDpTJ+0NAbpfenkmH2rePtuw==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.2",
"get-intrinsic": "^1.1.3",
"has-symbols": "^1.0.3",
"is-arguments": "^1.1.1",
"is-map": "^2.0.2",
"is-set": "^2.0.2",
"is-string": "^1.0.7",
"isarray": "^2.0.5",
"stop-iteration-iterator": "^1.0.0"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/es-iterator-helpers": {
"version": "1.0.19",
"resolved": "https://registry.npmjs.org/es-iterator-helpers/-/es-iterator-helpers-1.0.19.tgz",
"integrity": "sha512-zoMwbCcH5hwUkKJkT8kDIBZSz9I6mVG//+lDCinLCGov4+r7NIy0ld8o03M0cJxl2spVf6ESYVS6/gpIfq1FFw==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"define-properties": "^1.2.1",
"es-abstract": "^1.23.3",
"es-errors": "^1.3.0",
"es-set-tostringtag": "^2.0.3",
"function-bind": "^1.1.2",
"get-intrinsic": "^1.2.4",
"globalthis": "^1.0.3",
"has-property-descriptors": "^1.0.2",
"has-proto": "^1.0.3",
"has-symbols": "^1.0.3",
"internal-slot": "^1.0.7",
"iterator.prototype": "^1.1.2",
"safe-array-concat": "^1.1.2"
},
"engines": {
"node": ">= 0.4"
}
},
"node_modules/es-object-atoms": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.0.0.tgz",
"integrity": "sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==",
"dev": true,
"dependencies": {
"es-errors": "^1.3.0"
},
"engines": {
"node": ">= 0.4"
}
},
"node_modules/es-set-tostringtag": {
"version": "2.0.3",
"resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.3.tgz",
"integrity": "sha512-3T8uNMC3OQTHkFUsFq8r/BwAXLHvU/9O9mE0fBc/MY5iq/8H7ncvO947LmYA6ldWw9Uh8Yhf25zu6n7nML5QWQ==",
"dev": true,
"dependencies": {
"get-intrinsic": "^1.2.4",
"has-tostringtag": "^1.0.2",
"hasown": "^2.0.1"
},
"engines": {
"node": ">= 0.4"
}
},
"node_modules/es-shim-unscopables": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.0.2.tgz",
"integrity": "sha512-J3yBRXCzDu4ULnQwxyToo/OjdMx6akgVC7K6few0a7F/0wLtmKKN7I73AH5T2836UuXRqN7Qg+IIUw/+YJksRw==",
"dev": true,
"dependencies": {
"hasown": "^2.0.0"
}
},
"node_modules/es-to-primitive": {
"version": "1.2.1",
"resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz",
"integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==",
"dev": true,
"dependencies": {
"is-callable": "^1.1.4",
"is-date-object": "^1.0.1",
"is-symbol": "^1.0.2"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/escape-string-regexp": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
"integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
"dev": true,
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/eslint": {
"version": "8.57.0",
"resolved": "https://registry.npmjs.org/eslint/-/eslint-8.57.0.tgz",
"integrity": "sha512-dZ6+mexnaTIbSBZWgou51U6OmzIhYM2VcNdtiTtI7qPNZm35Akpr0f6vtw3w1Kmn5PYo+tZVfh13WrhpS6oLqQ==",
"dev": true,
"dependencies": {
"@eslint-community/eslint-utils": "^4.2.0",
"@eslint-community/regexpp": "^4.6.1",
"@eslint/eslintrc": "^2.1.4",
"@eslint/js": "8.57.0",
"@humanwhocodes/config-array": "^0.11.14",
"@humanwhocodes/module-importer": "^1.0.1",
"@nodelib/fs.walk": "^1.2.8",
"@ungap/structured-clone": "^1.2.0",
"ajv": "^6.12.4",
"chalk": "^4.0.0",
"cross-spawn": "^7.0.2",
"debug": "^4.3.2",
"doctrine": "^3.0.0",
"escape-string-regexp": "^4.0.0",
"eslint-scope": "^7.2.2",
"eslint-visitor-keys": "^3.4.3",
"espree": "^9.6.1",
"esquery": "^1.4.2",
"esutils": "^2.0.2",
"fast-deep-equal": "^3.1.3",
"file-entry-cache": "^6.0.1",
"find-up": "^5.0.0",
"glob-parent": "^6.0.2",
"globals": "^13.19.0",
"graphemer": "^1.4.0",
"ignore": "^5.2.0",
"imurmurhash": "^0.1.4",
"is-glob": "^4.0.0",
"is-path-inside": "^3.0.3",
"js-yaml": "^4.1.0",
"json-stable-stringify-without-jsonify": "^1.0.1",
"levn": "^0.4.1",
"lodash.merge": "^4.6.2",
"minimatch": "^3.1.2",
"natural-compare": "^1.4.0",
"optionator": "^0.9.3",
"strip-ansi": "^6.0.1",
"text-table": "^0.2.0"
},
"bin": {
"eslint": "bin/eslint.js"
},
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
},
"funding": {
"url": "https://opencollective.com/eslint"
}
},
"node_modules/eslint-config-next": {
"version": "14.2.7",
"resolved": "https://registry.npmjs.org/eslint-config-next/-/eslint-config-next-14.2.7.tgz",
"integrity": "sha512-ppmy+QdQ7qkuCHGDlPjWaoSbJvjGpWSBD4zEW8f1eWlxYXYpZK7QzBOer1EcHKT3uKhlY1JjUus9g7Kvv712rw==",
"dev": true,
"dependencies": {
"@next/eslint-plugin-next": "14.2.7",
"@rushstack/eslint-patch": "^1.3.3",
"@typescript-eslint/parser": "^5.4.2 || ^6.0.0 || 7.0.0 - 7.2.0",
"eslint-import-resolver-node": "^0.3.6",
"eslint-import-resolver-typescript": "^3.5.2",
"eslint-plugin-import": "^2.28.1",
"eslint-plugin-jsx-a11y": "^6.7.1",
"eslint-plugin-react": "^7.33.2",
"eslint-plugin-react-hooks": "^4.5.0 || 5.0.0-canary-7118f5dd7-20230705"
},
"peerDependencies": {
"eslint": "^7.23.0 || ^8.0.0",
"typescript": ">=3.3.1"
},
"peerDependenciesMeta": {
"typescript": {
"optional": true
}
}
},
"node_modules/eslint-import-resolver-node": {
"version": "0.3.9",
"resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.9.tgz",
"integrity": "sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==",
"dev": true,
"dependencies": {
"debug": "^3.2.7",
"is-core-module": "^2.13.0",
"resolve": "^1.22.4"
}
},
"node_modules/eslint-import-resolver-node/node_modules/debug": {
"version": "3.2.7",
"resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
"integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
"dev": true,
"dependencies": {
"ms": "^2.1.1"
}
},
"node_modules/eslint-import-resolver-typescript": {
"version": "3.6.3",
"resolved": "https://registry.npmjs.org/eslint-import-resolver-typescript/-/eslint-import-resolver-typescript-3.6.3.tgz",
"integrity": "sha512-ud9aw4szY9cCT1EWWdGv1L1XR6hh2PaRWif0j2QjQ0pgTY/69iw+W0Z4qZv5wHahOl8isEr+k/JnyAqNQkLkIA==",
"dev": true,
"dependencies": {
"@nolyfill/is-core-module": "1.0.39",
"debug": "^4.3.5",
"enhanced-resolve": "^5.15.0",
"eslint-module-utils": "^2.8.1",
"fast-glob": "^3.3.2",
"get-tsconfig": "^4.7.5",
"is-bun-module": "^1.0.2",
"is-glob": "^4.0.3"
},
"engines": {
"node": "^14.18.0 || >=16.0.0"
},
"funding": {
"url": "https://opencollective.com/unts/projects/eslint-import-resolver-ts"
},
"peerDependencies": {
"eslint": "*",
"eslint-plugin-import": "*",
"eslint-plugin-import-x": "*"
},
"peerDependenciesMeta": {
"eslint-plugin-import": {
"optional": true
},
"eslint-plugin-import-x": {
"optional": true
}
}
},
"node_modules/eslint-module-utils": {
"version": "2.8.2",
"resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.8.2.tgz",
"integrity": "sha512-3XnC5fDyc8M4J2E8pt8pmSVRX2M+5yWMCfI/kDZwauQeFgzQOuhcRBFKjTeJagqgk4sFKxe1mvNVnaWwImx/Tg==",
"dev": true,
"dependencies": {
"debug": "^3.2.7"
},
"engines": {
"node": ">=4"
},
"peerDependenciesMeta": {
"eslint": {
"optional": true
}
}
},
"node_modules/eslint-module-utils/node_modules/debug": {
"version": "3.2.7",
"resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
"integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
"dev": true,
"dependencies": {
"ms": "^2.1.1"
}
},
"node_modules/eslint-plugin-import": {
"version": "2.29.1",
"resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.29.1.tgz",
"integrity": "sha512-BbPC0cuExzhiMo4Ff1BTVwHpjjv28C5R+btTOGaCRC7UEz801up0JadwkeSk5Ued6TG34uaczuVuH6qyy5YUxw==",
"dev": true,
"dependencies": {
"array-includes": "^3.1.7",
"array.prototype.findlastindex": "^1.2.3",
"array.prototype.flat": "^1.3.2",
"array.prototype.flatmap": "^1.3.2",
"debug": "^3.2.7",
"doctrine": "^2.1.0",
"eslint-import-resolver-node": "^0.3.9",
"eslint-module-utils": "^2.8.0",
"hasown": "^2.0.0",
"is-core-module": "^2.13.1",
"is-glob": "^4.0.3",
"minimatch": "^3.1.2",
"object.fromentries": "^2.0.7",
"object.groupby": "^1.0.1",
"object.values": "^1.1.7",
"semver": "^6.3.1",
"tsconfig-paths": "^3.15.0"
},
"engines": {
"node": ">=4"
},
"peerDependencies": {
"eslint": "^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8"
}
},
"node_modules/eslint-plugin-import/node_modules/debug": {
"version": "3.2.7",
"resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
"integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
"dev": true,
"dependencies": {
"ms": "^2.1.1"
}
},
"node_modules/eslint-plugin-import/node_modules/doctrine": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz",
"integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==",
"dev": true,
"dependencies": {
"esutils": "^2.0.2"
},
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/eslint-plugin-import/node_modules/semver": {
"version": "6.3.1",
"resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
"integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
"dev": true,
"bin": {
"semver": "bin/semver.js"
}
},
"node_modules/eslint-plugin-jsx-a11y": {
"version": "6.9.0",
"resolved": "https://registry.npmjs.org/eslint-plugin-jsx-a11y/-/eslint-plugin-jsx-a11y-6.9.0.tgz",
"integrity": "sha512-nOFOCaJG2pYqORjK19lqPqxMO/JpvdCZdPtNdxY3kvom3jTvkAbOvQvD8wuD0G8BYR0IGAGYDlzqWJOh/ybn2g==",
"dev": true,
"dependencies": {
"aria-query": "~5.1.3",
"array-includes": "^3.1.8",
"array.prototype.flatmap": "^1.3.2",
"ast-types-flow": "^0.0.8",
"axe-core": "^4.9.1",
"axobject-query": "~3.1.1",
"damerau-levenshtein": "^1.0.8",
"emoji-regex": "^9.2.2",
"es-iterator-helpers": "^1.0.19",
"hasown": "^2.0.2",
"jsx-ast-utils": "^3.3.5",
"language-tags": "^1.0.9",
"minimatch": "^3.1.2",
"object.fromentries": "^2.0.8",
"safe-regex-test": "^1.0.3",
"string.prototype.includes": "^2.0.0"
},
"engines": {
"node": ">=4.0"
},
"peerDependencies": {
"eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8"
}
},
"node_modules/eslint-plugin-react": {
"version": "7.35.0",
"resolved": "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.35.0.tgz",
"integrity": "sha512-v501SSMOWv8gerHkk+IIQBkcGRGrO2nfybfj5pLxuJNFTPxxA3PSryhXTK+9pNbtkggheDdsC0E9Q8CuPk6JKA==",
"dev": true,
"dependencies": {
"array-includes": "^3.1.8",
"array.prototype.findlast": "^1.2.5",
"array.prototype.flatmap": "^1.3.2",
"array.prototype.tosorted": "^1.1.4",
"doctrine": "^2.1.0",
"es-iterator-helpers": "^1.0.19",
"estraverse": "^5.3.0",
"hasown": "^2.0.2",
"jsx-ast-utils": "^2.4.1 || ^3.0.0",
"minimatch": "^3.1.2",
"object.entries": "^1.1.8",
"object.fromentries": "^2.0.8",
"object.values": "^1.2.0",
"prop-types": "^15.8.1",
"resolve": "^2.0.0-next.5",
"semver": "^6.3.1",
"string.prototype.matchall": "^4.0.11",
"string.prototype.repeat": "^1.0.0"
},
"engines": {
"node": ">=4"
},
"peerDependencies": {
"eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9.7"
}
},
"node_modules/eslint-plugin-react-hooks": {
"version": "4.6.2",
"resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-4.6.2.tgz",
"integrity": "sha512-QzliNJq4GinDBcD8gPB5v0wh6g8q3SUi6EFF0x8N/BL9PoVs0atuGc47ozMRyOWAKdwaZ5OnbOEa3WR+dSGKuQ==",
"dev": true,
"engines": {
"node": ">=10"
},
"peerDependencies": {
"eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0"
}
},
"node_modules/eslint-plugin-react/node_modules/doctrine": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz",
"integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==",
"dev": true,
"dependencies": {
"esutils": "^2.0.2"
},
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/eslint-plugin-react/node_modules/resolve": {
"version": "2.0.0-next.5",
"resolved": "https://registry.npmjs.org/resolve/-/resolve-2.0.0-next.5.tgz",
"integrity": "sha512-U7WjGVG9sH8tvjW5SmGbQuui75FiyjAX72HX15DwBBwF9dNiQZRQAg9nnPhYy+TUnE0+VcrttuvNI8oSxZcocA==",
"dev": true,
"dependencies": {
"is-core-module": "^2.13.0",
"path-parse": "^1.0.7",
"supports-preserve-symlinks-flag": "^1.0.0"
},
"bin": {
"resolve": "bin/resolve"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/eslint-plugin-react/node_modules/semver": {
"version": "6.3.1",
"resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
"integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
"dev": true,
"bin": {
"semver": "bin/semver.js"
}
},
"node_modules/eslint-scope": {
"version": "7.2.2",
"resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz",
"integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==",
"dev": true,
"dependencies": {
"esrecurse": "^4.3.0",
"estraverse": "^5.2.0"
},
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
},
"funding": {
"url": "https://opencollective.com/eslint"
}
},
"node_modules/eslint-visitor-keys": {
"version": "3.4.3",
"resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
"integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
"dev": true,
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
},
"funding": {
"url": "https://opencollective.com/eslint"
}
},
"node_modules/espree": {
"version": "9.6.1",
"resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz",
"integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==",
"dev": true,
"dependencies": {
"acorn": "^8.9.0",
"acorn-jsx": "^5.3.2",
"eslint-visitor-keys": "^3.4.1"
},
"engines": {
"node": "^12.22.0 || ^14.17.0 || >=16.0.0"
},
"funding": {
"url": "https://opencollective.com/eslint"
}
},
"node_modules/esquery": {
"version": "1.6.0",
"resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz",
"integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==",
"dev": true,
"dependencies": {
"estraverse": "^5.1.0"
},
"engines": {
"node": ">=0.10"
}
},
"node_modules/esrecurse": {
"version": "4.3.0",
"resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
"integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
"dev": true,
"dependencies": {
"estraverse": "^5.2.0"
},
"engines": {
"node": ">=4.0"
}
},
"node_modules/estraverse": {
"version": "5.3.0",
"resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
"integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
"dev": true,
"engines": {
"node": ">=4.0"
}
},
"node_modules/esutils": {
"version": "2.0.3",
"resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
"integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
"dev": true,
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/fast-deep-equal": {
"version": "3.1.3",
"resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
"integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
"dev": true
},
"node_modules/fast-glob": {
"version": "3.3.2",
"resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.2.tgz",
"integrity": "sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==",
"dev": true,
"dependencies": {
"@nodelib/fs.stat": "^2.0.2",
"@nodelib/fs.walk": "^1.2.3",
"glob-parent": "^5.1.2",
"merge2": "^1.3.0",
"micromatch": "^4.0.4"
},
"engines": {
"node": ">=8.6.0"
}
},
"node_modules/fast-glob/node_modules/glob-parent": {
"version": "5.1.2",
"resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
"integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
"dev": true,
"dependencies": {
"is-glob": "^4.0.1"
},
"engines": {
"node": ">= 6"
}
},
"node_modules/fast-json-stable-stringify": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
"integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
"dev": true
},
"node_modules/fast-levenshtein": {
"version": "2.0.6",
"resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
"integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
"dev": true
},
"node_modules/fastq": {
"version": "1.17.1",
"resolved": "https://registry.npmjs.org/fastq/-/fastq-1.17.1.tgz",
"integrity": "sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==",
"dev": true,
"dependencies": {
"reusify": "^1.0.4"
}
},
"node_modules/file-entry-cache": {
"version": "6.0.1",
"resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz",
"integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==",
"dev": true,
"dependencies": {
"flat-cache": "^3.0.4"
},
"engines": {
"node": "^10.12.0 || >=12.0.0"
}
},
"node_modules/fill-range": {
"version": "7.1.1",
"resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
"integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
"dev": true,
"dependencies": {
"to-regex-range": "^5.0.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/find-up": {
"version": "5.0.0",
"resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
"integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
"dev": true,
"dependencies": {
"locate-path": "^6.0.0",
"path-exists": "^4.0.0"
},
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/flat-cache": {
"version": "3.2.0",
"resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz",
"integrity": "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==",
"dev": true,
"dependencies": {
"flatted": "^3.2.9",
"keyv": "^4.5.3",
"rimraf": "^3.0.2"
},
"engines": {
"node": "^10.12.0 || >=12.0.0"
}
},
"node_modules/flatted": {
"version": "3.3.1",
"resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.1.tgz",
"integrity": "sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw==",
"dev": true
},
"node_modules/for-each": {
"version": "0.3.3",
"resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz",
"integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==",
"dev": true,
"dependencies": {
"is-callable": "^1.1.3"
}
},
"node_modules/foreground-child": {
"version": "3.3.0",
"resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.0.tgz",
"integrity": "sha512-Ld2g8rrAyMYFXBhEqMz8ZAHBi4J4uS1i/CxGMDnjyFWddMXLVcDp051DZfu+t7+ab7Wv6SMqpWmyFIj5UbfFvg==",
"dev": true,
"dependencies": {
"cross-spawn": "^7.0.0",
"signal-exit": "^4.0.1"
},
"engines": {
"node": ">=14"
},
"funding": {
"url": "https://github.com/sponsors/isaacs"
}
},
"node_modules/fs.realpath": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
"integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
"dev": true
},
"node_modules/fsevents": {
"version": "2.3.3",
"resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
"integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
"dev": true,
"hasInstallScript": true,
"optional": true,
"os": [
"darwin"
],
"engines": {
"node": "^8.16.0 || ^10.6.0 || >=11.0.0"
}
},
"node_modules/function-bind": {
"version": "1.1.2",
"resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
"integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
"dev": true,
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/function.prototype.name": {
"version": "1.1.6",
"resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.6.tgz",
"integrity": "sha512-Z5kx79swU5P27WEayXM1tBi5Ze/lbIyiNgU3qyXUOf9b2rgXYyF9Dy9Cx+IQv/Lc8WCG6L82zwUPpSS9hGehIg==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.2",
"define-properties": "^1.2.0",
"es-abstract": "^1.22.1",
"functions-have-names": "^1.2.3"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/functions-have-names": {
"version": "1.2.3",
"resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz",
"integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==",
"dev": true,
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/get-intrinsic": {
"version": "1.2.4",
"resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.4.tgz",
"integrity": "sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==",
"dev": true,
"dependencies": {
"es-errors": "^1.3.0",
"function-bind": "^1.1.2",
"has-proto": "^1.0.1",
"has-symbols": "^1.0.3",
"hasown": "^2.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/get-symbol-description": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.2.tgz",
"integrity": "sha512-g0QYk1dZBxGwk+Ngc+ltRH2IBp2f7zBkBMBJZCDerh6EhlhSR6+9irMCuT/09zD6qkarHUSn529sK/yL4S27mg==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.5",
"es-errors": "^1.3.0",
"get-intrinsic": "^1.2.4"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/get-tsconfig": {
"version": "4.8.0",
"resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.8.0.tgz",
"integrity": "sha512-Pgba6TExTZ0FJAn1qkJAjIeKoDJ3CsI2ChuLohJnZl/tTU8MVrq3b+2t5UOPfRa4RMsorClBjJALkJUMjG1PAw==",
"dev": true,
"dependencies": {
"resolve-pkg-maps": "^1.0.0"
},
"funding": {
"url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
}
},
"node_modules/glob": {
"version": "10.3.10",
"resolved": "https://registry.npmjs.org/glob/-/glob-10.3.10.tgz",
"integrity": "sha512-fa46+tv1Ak0UPK1TOy/pZrIybNNt4HCv7SDzwyfiOZkvZLEbjsZkJBPtDHVshZjbecAoAGSC20MjLDG/qr679g==",
"dev": true,
"dependencies": {
"foreground-child": "^3.1.0",
"jackspeak": "^2.3.5",
"minimatch": "^9.0.1",
"minipass": "^5.0.0 || ^6.0.2 || ^7.0.0",
"path-scurry": "^1.10.1"
},
"bin": {
"glob": "dist/esm/bin.mjs"
},
"engines": {
"node": ">=16 || 14 >=14.17"
},
"funding": {
"url": "https://github.com/sponsors/isaacs"
}
},
"node_modules/glob-parent": {
"version": "6.0.2",
"resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
"integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
"dev": true,
"dependencies": {
"is-glob": "^4.0.3"
},
"engines": {
"node": ">=10.13.0"
}
},
"node_modules/glob/node_modules/brace-expansion": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
"integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
"dev": true,
"dependencies": {
"balanced-match": "^1.0.0"
}
},
"node_modules/glob/node_modules/minimatch": {
"version": "9.0.5",
"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
"integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
"dev": true,
"dependencies": {
"brace-expansion": "^2.0.1"
},
"engines": {
"node": ">=16 || 14 >=14.17"
},
"funding": {
"url": "https://github.com/sponsors/isaacs"
}
},
"node_modules/globals": {
"version": "13.24.0",
"resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz",
"integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==",
"dev": true,
"dependencies": {
"type-fest": "^0.20.2"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/globalthis": {
"version": "1.0.4",
"resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz",
"integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==",
"dev": true,
"dependencies": {
"define-properties": "^1.2.1",
"gopd": "^1.0.1"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/globby": {
"version": "11.1.0",
"resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz",
"integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==",
"dev": true,
"dependencies": {
"array-union": "^2.1.0",
"dir-glob": "^3.0.1",
"fast-glob": "^3.2.9",
"ignore": "^5.2.0",
"merge2": "^1.4.1",
"slash": "^3.0.0"
},
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/gopd": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz",
"integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==",
"dev": true,
"dependencies": {
"get-intrinsic": "^1.1.3"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/graceful-fs": {
"version": "4.2.11",
"resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
"integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="
},
"node_modules/graphemer": {
"version": "1.4.0",
"resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz",
"integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==",
"dev": true
},
"node_modules/has-bigints": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.2.tgz",
"integrity": "sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==",
"dev": true,
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/has-flag": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
"integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/has-property-descriptors": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
"integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
"dev": true,
"dependencies": {
"es-define-property": "^1.0.0"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/has-proto": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.3.tgz",
"integrity": "sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q==",
"dev": true,
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/has-symbols": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
"integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==",
"dev": true,
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/has-tostringtag": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
"integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
"dev": true,
"dependencies": {
"has-symbols": "^1.0.3"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/hasown": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
"integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
"dev": true,
"dependencies": {
"function-bind": "^1.1.2"
},
"engines": {
"node": ">= 0.4"
}
},
"node_modules/ignore": {
"version": "5.3.2",
"resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
"integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
"dev": true,
"engines": {
"node": ">= 4"
}
},
"node_modules/import-fresh": {
"version": "3.3.0",
"resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz",
"integrity": "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==",
"dev": true,
"dependencies": {
"parent-module": "^1.0.0",
"resolve-from": "^4.0.0"
},
"engines": {
"node": ">=6"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/imurmurhash": {
"version": "0.1.4",
"resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
"integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
"dev": true,
"engines": {
"node": ">=0.8.19"
}
},
"node_modules/inflight": {
"version": "1.0.6",
"resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
"integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
"deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
"dev": true,
"dependencies": {
"once": "^1.3.0",
"wrappy": "1"
}
},
"node_modules/inherits": {
"version": "2.0.4",
"resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
"integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
"dev": true
},
"node_modules/internal-slot": {
"version": "1.0.7",
"resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.7.tgz",
"integrity": "sha512-NGnrKwXzSms2qUUih/ILZ5JBqNTSa1+ZmP6flaIp6KmSElgE9qdndzS3cqjrDovwFdmwsGsLdeFgB6suw+1e9g==",
"dev": true,
"dependencies": {
"es-errors": "^1.3.0",
"hasown": "^2.0.0",
"side-channel": "^1.0.4"
},
"engines": {
"node": ">= 0.4"
}
},
"node_modules/is-arguments": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/is-arguments/-/is-arguments-1.1.1.tgz",
"integrity": "sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.2",
"has-tostringtag": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-array-buffer": {
"version": "3.0.4",
"resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.4.tgz",
"integrity": "sha512-wcjaerHw0ydZwfhiKbXJWLDY8A7yV7KhjQOpb83hGgGfId/aQa4TOvwyzn2PuswW2gPCYEL/nEAiSVpdOj1lXw==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.2",
"get-intrinsic": "^1.2.1"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-async-function": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/is-async-function/-/is-async-function-2.0.0.tgz",
"integrity": "sha512-Y1JXKrfykRJGdlDwdKlLpLyMIiWqWvuSd17TvZk68PLAOGOoF4Xyav1z0Xhoi+gCYjZVeC5SI+hYFOfvXmGRCA==",
"dev": true,
"dependencies": {
"has-tostringtag": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-bigint": {
"version": "1.0.4",
"resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz",
"integrity": "sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==",
"dev": true,
"dependencies": {
"has-bigints": "^1.0.1"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-binary-path": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
"integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
"dev": true,
"dependencies": {
"binary-extensions": "^2.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/is-boolean-object": {
"version": "1.1.2",
"resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.2.tgz",
"integrity": "sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.2",
"has-tostringtag": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-bun-module": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/is-bun-module/-/is-bun-module-1.1.0.tgz",
"integrity": "sha512-4mTAVPlrXpaN3jtF0lsnPCMGnq4+qZjVIKq0HCpfcqf8OC1SM5oATCIAPM5V5FN05qp2NNnFndphmdZS9CV3hA==",
"dev": true,
"dependencies": {
"semver": "^7.6.3"
}
},
"node_modules/is-callable": {
"version": "1.2.7",
"resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz",
"integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==",
"dev": true,
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-core-module": {
"version": "2.15.1",
"resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.15.1.tgz",
"integrity": "sha512-z0vtXSwucUJtANQWldhbtbt7BnL0vxiFjIdDLAatwhDYty2bad6s+rijD6Ri4YuYJubLzIJLUidCh09e1djEVQ==",
"dev": true,
"dependencies": {
"hasown": "^2.0.2"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-data-view": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.1.tgz",
"integrity": "sha512-AHkaJrsUVW6wq6JS8y3JnM/GJF/9cf+k20+iDzlSaJrinEo5+7vRiteOSwBhHRiAyQATN1AmY4hwzxJKPmYf+w==",
"dev": true,
"dependencies": {
"is-typed-array": "^1.1.13"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-date-object": {
"version": "1.0.5",
"resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz",
"integrity": "sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==",
"dev": true,
"dependencies": {
"has-tostringtag": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-extglob": {
"version": "2.1.1",
"resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
"integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
"dev": true,
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/is-finalizationregistry": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.0.2.tgz",
"integrity": "sha512-0by5vtUJs8iFQb5TYUHHPudOR+qXYIMKtiUzvLIZITZUjknFmziyBJuLhVRc+Ds0dREFlskDNJKYIdIzu/9pfw==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.2"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-fullwidth-code-point": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
"integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/is-generator-function": {
"version": "1.0.10",
"resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.0.10.tgz",
"integrity": "sha512-jsEjy9l3yiXEQ+PsXdmBwEPcOxaXWLspKdplFUVI9vq1iZgIekeC0L167qeu86czQaxed3q/Uzuw0swL0irL8A==",
"dev": true,
"dependencies": {
"has-tostringtag": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-glob": {
"version": "4.0.3",
"resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
"integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
"dev": true,
"dependencies": {
"is-extglob": "^2.1.1"
},
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/is-map": {
"version": "2.0.3",
"resolved": "https://registry.npmjs.org/is-map/-/is-map-2.0.3.tgz",
"integrity": "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==",
"dev": true,
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-negative-zero": {
"version": "2.0.3",
"resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.3.tgz",
"integrity": "sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==",
"dev": true,
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-number": {
"version": "7.0.0",
"resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
"integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
"dev": true,
"engines": {
"node": ">=0.12.0"
}
},
"node_modules/is-number-object": {
"version": "1.0.7",
"resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.7.tgz",
"integrity": "sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==",
"dev": true,
"dependencies": {
"has-tostringtag": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-path-inside": {
"version": "3.0.3",
"resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz",
"integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/is-regex": {
"version": "1.1.4",
"resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz",
"integrity": "sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.2",
"has-tostringtag": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-set": {
"version": "2.0.3",
"resolved": "https://registry.npmjs.org/is-set/-/is-set-2.0.3.tgz",
"integrity": "sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==",
"dev": true,
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-shared-array-buffer": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.3.tgz",
"integrity": "sha512-nA2hv5XIhLR3uVzDDfCIknerhx8XUKnstuOERPNNIinXG7v9u+ohXF67vxm4TPTEPU6lm61ZkwP3c9PCB97rhg==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-string": {
"version": "1.0.7",
"resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz",
"integrity": "sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==",
"dev": true,
"dependencies": {
"has-tostringtag": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-symbol": {
"version": "1.0.4",
"resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz",
"integrity": "sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==",
"dev": true,
"dependencies": {
"has-symbols": "^1.0.2"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-typed-array": {
"version": "1.1.13",
"resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.13.tgz",
"integrity": "sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==",
"dev": true,
"dependencies": {
"which-typed-array": "^1.1.14"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-weakmap": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.2.tgz",
"integrity": "sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==",
"dev": true,
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-weakref": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz",
"integrity": "sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.2"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/is-weakset": {
"version": "2.0.3",
"resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.3.tgz",
"integrity": "sha512-LvIm3/KWzS9oRFHugab7d+M/GcBXuXX5xZkzPmN+NxihdQlZUQ4dWuSV1xR/sq6upL1TJEDrfBgRepHFdBtSNQ==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"get-intrinsic": "^1.2.4"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/isarray": {
"version": "2.0.5",
"resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
"integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
"dev": true
},
"node_modules/isexe": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
"integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
"dev": true
},
"node_modules/iterator.prototype": {
"version": "1.1.2",
"resolved": "https://registry.npmjs.org/iterator.prototype/-/iterator.prototype-1.1.2.tgz",
"integrity": "sha512-DR33HMMr8EzwuRL8Y9D3u2BMj8+RqSE850jfGu59kS7tbmPLzGkZmVSfyCFSDxuZiEY6Rzt3T2NA/qU+NwVj1w==",
"dev": true,
"dependencies": {
"define-properties": "^1.2.1",
"get-intrinsic": "^1.2.1",
"has-symbols": "^1.0.3",
"reflect.getprototypeof": "^1.0.4",
"set-function-name": "^2.0.1"
}
},
"node_modules/jackspeak": {
"version": "2.3.6",
"resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-2.3.6.tgz",
"integrity": "sha512-N3yCS/NegsOBokc8GAdM8UcmfsKiSS8cipheD/nivzr700H+nsMOxJjQnvwOcRYVuFkdH0wGUvW2WbXGmrZGbQ==",
"dev": true,
"dependencies": {
"@isaacs/cliui": "^8.0.2"
},
"engines": {
"node": ">=14"
},
"funding": {
"url": "https://github.com/sponsors/isaacs"
},
"optionalDependencies": {
"@pkgjs/parseargs": "^0.11.0"
}
},
"node_modules/jiti": {
"version": "1.21.6",
"resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.6.tgz",
"integrity": "sha512-2yTgeWTWzMWkHu6Jp9NKgePDaYHbntiwvYuuJLbbN9vl7DC9DvXKOB2BC3ZZ92D3cvV/aflH0osDfwpHepQ53w==",
"dev": true,
"bin": {
"jiti": "bin/jiti.js"
}
},
"node_modules/js-tokens": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
"integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="
},
"node_modules/js-yaml": {
"version": "4.1.0",
"resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
"integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
"dev": true,
"dependencies": {
"argparse": "^2.0.1"
},
"bin": {
"js-yaml": "bin/js-yaml.js"
}
},
"node_modules/json-buffer": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
"integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
"dev": true
},
"node_modules/json-schema-traverse": {
"version": "0.4.1",
"resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
"integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
"dev": true
},
"node_modules/json-stable-stringify-without-jsonify": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
"integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
"dev": true
},
"node_modules/json5": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz",
"integrity": "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==",
"dev": true,
"dependencies": {
"minimist": "^1.2.0"
},
"bin": {
"json5": "lib/cli.js"
}
},
"node_modules/jsx-ast-utils": {
"version": "3.3.5",
"resolved": "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-3.3.5.tgz",
"integrity": "sha512-ZZow9HBI5O6EPgSJLUb8n2NKgmVWTwCvHGwFuJlMjvLFqlGG6pjirPhtdsseaLZjSibD8eegzmYpUZwoIlj2cQ==",
"dev": true,
"dependencies": {
"array-includes": "^3.1.6",
"array.prototype.flat": "^1.3.1",
"object.assign": "^4.1.4",
"object.values": "^1.1.6"
},
"engines": {
"node": ">=4.0"
}
},
"node_modules/keyv": {
"version": "4.5.4",
"resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
"integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
"dev": true,
"dependencies": {
"json-buffer": "3.0.1"
}
},
"node_modules/language-subtag-registry": {
"version": "0.3.23",
"resolved": "https://registry.npmjs.org/language-subtag-registry/-/language-subtag-registry-0.3.23.tgz",
"integrity": "sha512-0K65Lea881pHotoGEa5gDlMxt3pctLi2RplBb7Ezh4rRdLEOtgi7n4EwK9lamnUCkKBqaeKRVebTq6BAxSkpXQ==",
"dev": true
},
"node_modules/language-tags": {
"version": "1.0.9",
"resolved": "https://registry.npmjs.org/language-tags/-/language-tags-1.0.9.tgz",
"integrity": "sha512-MbjN408fEndfiQXbFQ1vnd+1NoLDsnQW41410oQBXiyXDMYH5z505juWa4KUE1LqxRC7DgOgZDbKLxHIwm27hA==",
"dev": true,
"dependencies": {
"language-subtag-registry": "^0.3.20"
},
"engines": {
"node": ">=0.10"
}
},
"node_modules/levn": {
"version": "0.4.1",
"resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
"integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
"dev": true,
"dependencies": {
"prelude-ls": "^1.2.1",
"type-check": "~0.4.0"
},
"engines": {
"node": ">= 0.8.0"
}
},
"node_modules/lilconfig": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz",
"integrity": "sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==",
"dev": true,
"engines": {
"node": ">=10"
}
},
"node_modules/lines-and-columns": {
"version": "1.2.4",
"resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
"integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
"dev": true
},
"node_modules/locate-path": {
"version": "6.0.0",
"resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
"integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
"dev": true,
"dependencies": {
"p-locate": "^5.0.0"
},
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/lodash.merge": {
"version": "4.6.2",
"resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
"integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
"dev": true
},
"node_modules/loose-envify": {
"version": "1.4.0",
"resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
"integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
"dependencies": {
"js-tokens": "^3.0.0 || ^4.0.0"
},
"bin": {
"loose-envify": "cli.js"
}
},
"node_modules/lru-cache": {
"version": "10.4.3",
"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
"integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
"dev": true
},
"node_modules/merge2": {
"version": "1.4.1",
"resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
"integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
"dev": true,
"engines": {
"node": ">= 8"
}
},
"node_modules/micromatch": {
"version": "4.0.8",
"resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
"integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
"dev": true,
"dependencies": {
"braces": "^3.0.3",
"picomatch": "^2.3.1"
},
"engines": {
"node": ">=8.6"
}
},
"node_modules/minimatch": {
"version": "3.1.2",
"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
"integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
"dev": true,
"dependencies": {
"brace-expansion": "^1.1.7"
},
"engines": {
"node": "*"
}
},
"node_modules/minimist": {
"version": "1.2.8",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
"integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
"dev": true,
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/minipass": {
"version": "7.1.2",
"resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
"integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
"dev": true,
"engines": {
"node": ">=16 || 14 >=14.17"
}
},
"node_modules/ms": {
"version": "2.1.2",
"resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
"integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
"dev": true
},
"node_modules/mz": {
"version": "2.7.0",
"resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz",
"integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==",
"dev": true,
"dependencies": {
"any-promise": "^1.0.0",
"object-assign": "^4.0.1",
"thenify-all": "^1.0.0"
}
},
"node_modules/nanoid": {
"version": "3.3.7",
"resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.7.tgz",
"integrity": "sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g==",
"funding": [
{
"type": "github",
"url": "https://github.com/sponsors/ai"
}
],
"bin": {
"nanoid": "bin/nanoid.cjs"
},
"engines": {
"node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
}
},
"node_modules/natural-compare": {
"version": "1.4.0",
"resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
"integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
"dev": true
},
"node_modules/next": {
"version": "14.2.7",
"resolved": "https://registry.npmjs.org/next/-/next-14.2.7.tgz",
"integrity": "sha512-4Qy2aK0LwH4eQiSvQWyKuC7JXE13bIopEQesWE0c/P3uuNRnZCQanI0vsrMLmUQJLAto+A+/8+sve2hd+BQuOQ==",
"dependencies": {
"@next/env": "14.2.7",
"@swc/helpers": "0.5.5",
"busboy": "1.6.0",
"caniuse-lite": "^1.0.30001579",
"graceful-fs": "^4.2.11",
"postcss": "8.4.31",
"styled-jsx": "5.1.1"
},
"bin": {
"next": "dist/bin/next"
},
"engines": {
"node": ">=18.17.0"
},
"optionalDependencies": {
"@next/swc-darwin-arm64": "14.2.7",
"@next/swc-darwin-x64": "14.2.7",
"@next/swc-linux-arm64-gnu": "14.2.7",
"@next/swc-linux-arm64-musl": "14.2.7",
"@next/swc-linux-x64-gnu": "14.2.7",
"@next/swc-linux-x64-musl": "14.2.7",
"@next/swc-win32-arm64-msvc": "14.2.7",
"@next/swc-win32-ia32-msvc": "14.2.7",
"@next/swc-win32-x64-msvc": "14.2.7"
},
"peerDependencies": {
"@opentelemetry/api": "^1.1.0",
"@playwright/test": "^1.41.2",
"react": "^18.2.0",
"react-dom": "^18.2.0",
"sass": "^1.3.0"
},
"peerDependenciesMeta": {
"@opentelemetry/api": {
"optional": true
},
"@playwright/test": {
"optional": true
},
"sass": {
"optional": true
}
}
},
"node_modules/next/node_modules/postcss": {
"version": "8.4.31",
"resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.31.tgz",
"integrity": "sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ==",
"funding": [
{
"type": "opencollective",
"url": "https://opencollective.com/postcss/"
},
{
"type": "tidelift",
"url": "https://tidelift.com/funding/github/npm/postcss"
},
{
"type": "github",
"url": "https://github.com/sponsors/ai"
}
],
"dependencies": {
"nanoid": "^3.3.6",
"picocolors": "^1.0.0",
"source-map-js": "^1.0.2"
},
"engines": {
"node": "^10 || ^12 || >=14"
}
},
"node_modules/normalize-path": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
"integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
"dev": true,
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/object-assign": {
"version": "4.1.1",
"resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
"integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
"dev": true,
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/object-hash": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz",
"integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==",
"dev": true,
"engines": {
"node": ">= 6"
}
},
"node_modules/object-inspect": {
"version": "1.13.2",
"resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.2.tgz",
"integrity": "sha512-IRZSRuzJiynemAXPYtPe5BoI/RESNYR7TYm50MC5Mqbd3Jmw5y790sErYw3V6SryFJD64b74qQQs9wn5Bg/k3g==",
"dev": true,
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/object-is": {
"version": "1.1.6",
"resolved": "https://registry.npmjs.org/object-is/-/object-is-1.1.6.tgz",
"integrity": "sha512-F8cZ+KfGlSGi09lJT7/Nd6KJZ9ygtvYC0/UYYLI9nmQKLMnydpB9yvbv9K1uSkEu7FU9vYPmVwLg328tX+ot3Q==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"define-properties": "^1.2.1"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/object-keys": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
"integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
"dev": true,
"engines": {
"node": ">= 0.4"
}
},
"node_modules/object.assign": {
"version": "4.1.5",
"resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.5.tgz",
"integrity": "sha512-byy+U7gp+FVwmyzKPYhW2h5l3crpmGsxl7X2s8y43IgxvG4g3QZ6CffDtsNQy1WsmZpQbO+ybo0AlW7TY6DcBQ==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.5",
"define-properties": "^1.2.1",
"has-symbols": "^1.0.3",
"object-keys": "^1.1.1"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/object.entries": {
"version": "1.1.8",
"resolved": "https://registry.npmjs.org/object.entries/-/object.entries-1.1.8.tgz",
"integrity": "sha512-cmopxi8VwRIAw/fkijJohSfpef5PdN0pMQJN6VC/ZKvn0LIknWD8KtgY6KlQdEc4tIjcQ3HxSMmnvtzIscdaYQ==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"define-properties": "^1.2.1",
"es-object-atoms": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
}
},
"node_modules/object.fromentries": {
"version": "2.0.8",
"resolved": "https://registry.npmjs.org/object.fromentries/-/object.fromentries-2.0.8.tgz",
"integrity": "sha512-k6E21FzySsSK5a21KRADBd/NGneRegFO5pLHfdQLpRDETUNJueLXs3WCzyQ3tFRDYgbq3KHGXfTbi2bs8WQ6rQ==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"define-properties": "^1.2.1",
"es-abstract": "^1.23.2",
"es-object-atoms": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/object.groupby": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/object.groupby/-/object.groupby-1.0.3.tgz",
"integrity": "sha512-+Lhy3TQTuzXI5hevh8sBGqbmurHbbIjAi0Z4S63nthVLmLxfbj4T54a4CfZrXIrt9iP4mVAPYMo/v99taj3wjQ==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"define-properties": "^1.2.1",
"es-abstract": "^1.23.2"
},
"engines": {
"node": ">= 0.4"
}
},
"node_modules/object.values": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/object.values/-/object.values-1.2.0.tgz",
"integrity": "sha512-yBYjY9QX2hnRmZHAjG/f13MzmBzxzYgQhFrke06TTyKY5zSTEqkOeukBzIdVA3j3ulu8Qa3MbVFShV7T2RmGtQ==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"define-properties": "^1.2.1",
"es-object-atoms": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/once": {
"version": "1.4.0",
"resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
"integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
"dev": true,
"dependencies": {
"wrappy": "1"
}
},
"node_modules/optionator": {
"version": "0.9.4",
"resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
"integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
"dev": true,
"dependencies": {
"deep-is": "^0.1.3",
"fast-levenshtein": "^2.0.6",
"levn": "^0.4.1",
"prelude-ls": "^1.2.1",
"type-check": "^0.4.0",
"word-wrap": "^1.2.5"
},
"engines": {
"node": ">= 0.8.0"
}
},
"node_modules/p-limit": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
"integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
"dev": true,
"dependencies": {
"yocto-queue": "^0.1.0"
},
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/p-locate": {
"version": "5.0.0",
"resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
"integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
"dev": true,
"dependencies": {
"p-limit": "^3.0.2"
},
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/parent-module": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
"integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
"dev": true,
"dependencies": {
"callsites": "^3.0.0"
},
"engines": {
"node": ">=6"
}
},
"node_modules/path-exists": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
"integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/path-is-absolute": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
"integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
"dev": true,
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/path-key": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
"integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/path-parse": {
"version": "1.0.7",
"resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
"integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
"dev": true
},
"node_modules/path-scurry": {
"version": "1.11.1",
"resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz",
"integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==",
"dev": true,
"dependencies": {
"lru-cache": "^10.2.0",
"minipass": "^5.0.0 || ^6.0.2 || ^7.0.0"
},
"engines": {
"node": ">=16 || 14 >=14.18"
},
"funding": {
"url": "https://github.com/sponsors/isaacs"
}
},
"node_modules/path-type": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
"integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/picocolors": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.1.tgz",
"integrity": "sha512-anP1Z8qwhkbmu7MFP5iTt+wQKXgwzf7zTyGlcdzabySa9vd0Xt392U0rVmz9poOaBj0uHJKyyo9/upk0HrEQew=="
},
"node_modules/picomatch": {
"version": "2.3.1",
"resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
"integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
"dev": true,
"engines": {
"node": ">=8.6"
},
"funding": {
"url": "https://github.com/sponsors/jonschlinkert"
}
},
"node_modules/pify": {
"version": "2.3.0",
"resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz",
"integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==",
"dev": true,
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/pirates": {
"version": "4.0.6",
"resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.6.tgz",
"integrity": "sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg==",
"dev": true,
"engines": {
"node": ">= 6"
}
},
"node_modules/possible-typed-array-names": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.0.0.tgz",
"integrity": "sha512-d7Uw+eZoloe0EHDIYoe+bQ5WXnGMOpmiZFTuMWCwpjzzkL2nTjcKiAk4hh8TjnGye2TwWOk3UXucZ+3rbmBa8Q==",
"dev": true,
"engines": {
"node": ">= 0.4"
}
},
"node_modules/postcss": {
"version": "8.4.44",
"resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.44.tgz",
"integrity": "sha512-Aweb9unOEpQ3ezu4Q00DPvvM2ZTUitJdNKeP/+uQgr1IBIqu574IaZoURId7BKtWMREwzKa9OgzPzezWGPWFQw==",
"dev": true,
"funding": [
{
"type": "opencollective",
"url": "https://opencollective.com/postcss/"
},
{
"type": "tidelift",
"url": "https://tidelift.com/funding/github/npm/postcss"
},
{
"type": "github",
"url": "https://github.com/sponsors/ai"
}
],
"dependencies": {
"nanoid": "^3.3.7",
"picocolors": "^1.0.1",
"source-map-js": "^1.2.0"
},
"engines": {
"node": "^10 || ^12 || >=14"
}
},
"node_modules/postcss-import": {
"version": "15.1.0",
"resolved": "https://registry.npmjs.org/postcss-import/-/postcss-import-15.1.0.tgz",
"integrity": "sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==",
"dev": true,
"dependencies": {
"postcss-value-parser": "^4.0.0",
"read-cache": "^1.0.0",
"resolve": "^1.1.7"
},
"engines": {
"node": ">=14.0.0"
},
"peerDependencies": {
"postcss": "^8.0.0"
}
},
"node_modules/postcss-js": {
"version": "4.0.1",
"resolved": "https://registry.npmjs.org/postcss-js/-/postcss-js-4.0.1.tgz",
"integrity": "sha512-dDLF8pEO191hJMtlHFPRa8xsizHaM82MLfNkUHdUtVEV3tgTp5oj+8qbEqYM57SLfc74KSbw//4SeJma2LRVIw==",
"dev": true,
"dependencies": {
"camelcase-css": "^2.0.1"
},
"engines": {
"node": "^12 || ^14 || >= 16"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/postcss/"
},
"peerDependencies": {
"postcss": "^8.4.21"
}
},
"node_modules/postcss-load-config": {
"version": "4.0.2",
"resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-4.0.2.tgz",
"integrity": "sha512-bSVhyJGL00wMVoPUzAVAnbEoWyqRxkjv64tUl427SKnPrENtq6hJwUojroMz2VB+Q1edmi4IfrAPpami5VVgMQ==",
"dev": true,
"funding": [
{
"type": "opencollective",
"url": "https://opencollective.com/postcss/"
},
{
"type": "github",
"url": "https://github.com/sponsors/ai"
}
],
"dependencies": {
"lilconfig": "^3.0.0",
"yaml": "^2.3.4"
},
"engines": {
"node": ">= 14"
},
"peerDependencies": {
"postcss": ">=8.0.9",
"ts-node": ">=9.0.0"
},
"peerDependenciesMeta": {
"postcss": {
"optional": true
},
"ts-node": {
"optional": true
}
}
},
"node_modules/postcss-load-config/node_modules/lilconfig": {
"version": "3.1.2",
"resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.2.tgz",
"integrity": "sha512-eop+wDAvpItUys0FWkHIKeC9ybYrTGbU41U5K7+bttZZeohvnY7M9dZ5kB21GNWiFT2q1OoPTvncPCgSOVO5ow==",
"dev": true,
"engines": {
"node": ">=14"
},
"funding": {
"url": "https://github.com/sponsors/antonk52"
}
},
"node_modules/postcss-nested": {
"version": "6.2.0",
"resolved": "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.2.0.tgz",
"integrity": "sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==",
"dev": true,
"funding": [
{
"type": "opencollective",
"url": "https://opencollective.com/postcss/"
},
{
"type": "github",
"url": "https://github.com/sponsors/ai"
}
],
"dependencies": {
"postcss-selector-parser": "^6.1.1"
},
"engines": {
"node": ">=12.0"
},
"peerDependencies": {
"postcss": "^8.2.14"
}
},
"node_modules/postcss-selector-parser": {
"version": "6.1.2",
"resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
"integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
"dev": true,
"dependencies": {
"cssesc": "^3.0.0",
"util-deprecate": "^1.0.2"
},
"engines": {
"node": ">=4"
}
},
"node_modules/postcss-value-parser": {
"version": "4.2.0",
"resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
"integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==",
"dev": true
},
"node_modules/prelude-ls": {
"version": "1.2.1",
"resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
"integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
"dev": true,
"engines": {
"node": ">= 0.8.0"
}
},
"node_modules/prop-types": {
"version": "15.8.1",
"resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
"integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==",
"dev": true,
"dependencies": {
"loose-envify": "^1.4.0",
"object-assign": "^4.1.1",
"react-is": "^16.13.1"
}
},
"node_modules/punycode": {
"version": "2.3.1",
"resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
"integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
"dev": true,
"engines": {
"node": ">=6"
}
},
"node_modules/queue-microtask": {
"version": "1.2.3",
"resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
"integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
"dev": true,
"funding": [
{
"type": "github",
"url": "https://github.com/sponsors/feross"
},
{
"type": "patreon",
"url": "https://www.patreon.com/feross"
},
{
"type": "consulting",
"url": "https://feross.org/support"
}
]
},
"node_modules/react": {
"version": "18.3.1",
"resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
"integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
"dependencies": {
"loose-envify": "^1.1.0"
},
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/react-dom": {
"version": "18.3.1",
"resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
"integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
"dependencies": {
"loose-envify": "^1.1.0",
"scheduler": "^0.23.2"
},
"peerDependencies": {
"react": "^18.3.1"
}
},
"node_modules/react-is": {
"version": "16.13.1",
"resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
"integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
"dev": true
},
"node_modules/read-cache": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz",
"integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==",
"dev": true,
"dependencies": {
"pify": "^2.3.0"
}
},
"node_modules/readdirp": {
"version": "3.6.0",
"resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
"integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
"dev": true,
"dependencies": {
"picomatch": "^2.2.1"
},
"engines": {
"node": ">=8.10.0"
}
},
"node_modules/reflect.getprototypeof": {
"version": "1.0.6",
"resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.6.tgz",
"integrity": "sha512-fmfw4XgoDke3kdI6h4xcUz1dG8uaiv5q9gcEwLS4Pnth2kxT+GZ7YehS1JTMGBQmtV7Y4GFGbs2re2NqhdozUg==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"define-properties": "^1.2.1",
"es-abstract": "^1.23.1",
"es-errors": "^1.3.0",
"get-intrinsic": "^1.2.4",
"globalthis": "^1.0.3",
"which-builtin-type": "^1.1.3"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/regexp.prototype.flags": {
"version": "1.5.2",
"resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.2.tgz",
"integrity": "sha512-NcDiDkTLuPR+++OCKB0nWafEmhg/Da8aUPLPMQbK+bxKKCm1/S5he+AqYa4PlMCVBalb4/yxIRub6qkEx5yJbw==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.6",
"define-properties": "^1.2.1",
"es-errors": "^1.3.0",
"set-function-name": "^2.0.1"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/resolve": {
"version": "1.22.8",
"resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.8.tgz",
"integrity": "sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==",
"dev": true,
"dependencies": {
"is-core-module": "^2.13.0",
"path-parse": "^1.0.7",
"supports-preserve-symlinks-flag": "^1.0.0"
},
"bin": {
"resolve": "bin/resolve"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/resolve-from": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
"integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
"dev": true,
"engines": {
"node": ">=4"
}
},
"node_modules/resolve-pkg-maps": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz",
"integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==",
"dev": true,
"funding": {
"url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
}
},
"node_modules/reusify": {
"version": "1.0.4",
"resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz",
"integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==",
"dev": true,
"engines": {
"iojs": ">=1.0.0",
"node": ">=0.10.0"
}
},
"node_modules/rimraf": {
"version": "3.0.2",
"resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
"integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
"deprecated": "Rimraf versions prior to v4 are no longer supported",
"dev": true,
"dependencies": {
"glob": "^7.1.3"
},
"bin": {
"rimraf": "bin.js"
},
"funding": {
"url": "https://github.com/sponsors/isaacs"
}
},
"node_modules/rimraf/node_modules/glob": {
"version": "7.2.3",
"resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
"integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
"deprecated": "Glob versions prior to v9 are no longer supported",
"dev": true,
"dependencies": {
"fs.realpath": "^1.0.0",
"inflight": "^1.0.4",
"inherits": "2",
"minimatch": "^3.1.1",
"once": "^1.3.0",
"path-is-absolute": "^1.0.0"
},
"engines": {
"node": "*"
},
"funding": {
"url": "https://github.com/sponsors/isaacs"
}
},
"node_modules/run-parallel": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
"integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
"dev": true,
"funding": [
{
"type": "github",
"url": "https://github.com/sponsors/feross"
},
{
"type": "patreon",
"url": "https://www.patreon.com/feross"
},
{
"type": "consulting",
"url": "https://feross.org/support"
}
],
"dependencies": {
"queue-microtask": "^1.2.2"
}
},
"node_modules/safe-array-concat": {
"version": "1.1.2",
"resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.2.tgz",
"integrity": "sha512-vj6RsCsWBCf19jIeHEfkRMw8DPiBb+DMXklQ/1SGDHOMlHdPUkZXFQ2YdplS23zESTijAcurb1aSgJA3AgMu1Q==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"get-intrinsic": "^1.2.4",
"has-symbols": "^1.0.3",
"isarray": "^2.0.5"
},
"engines": {
"node": ">=0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/safe-regex-test": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.3.tgz",
"integrity": "sha512-CdASjNJPvRa7roO6Ra/gLYBTzYzzPyyBXxIMdGW3USQLyjWEls2RgW5UBTXaQVp+OrpeCK3bLem8smtmheoRuw==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.6",
"es-errors": "^1.3.0",
"is-regex": "^1.1.4"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/scheduler": {
"version": "0.23.2",
"resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
"integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
"dependencies": {
"loose-envify": "^1.1.0"
}
},
"node_modules/semver": {
"version": "7.6.3",
"resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz",
"integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==",
"dev": true,
"bin": {
"semver": "bin/semver.js"
},
"engines": {
"node": ">=10"
}
},
"node_modules/set-function-length": {
"version": "1.2.2",
"resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
"integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
"dev": true,
"dependencies": {
"define-data-property": "^1.1.4",
"es-errors": "^1.3.0",
"function-bind": "^1.1.2",
"get-intrinsic": "^1.2.4",
"gopd": "^1.0.1",
"has-property-descriptors": "^1.0.2"
},
"engines": {
"node": ">= 0.4"
}
},
"node_modules/set-function-name": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/set-function-name/-/set-function-name-2.0.2.tgz",
"integrity": "sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==",
"dev": true,
"dependencies": {
"define-data-property": "^1.1.4",
"es-errors": "^1.3.0",
"functions-have-names": "^1.2.3",
"has-property-descriptors": "^1.0.2"
},
"engines": {
"node": ">= 0.4"
}
},
"node_modules/shebang-command": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
"integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
"dev": true,
"dependencies": {
"shebang-regex": "^3.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/shebang-regex": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
"integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/side-channel": {
"version": "1.0.6",
"resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.6.tgz",
"integrity": "sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"es-errors": "^1.3.0",
"get-intrinsic": "^1.2.4",
"object-inspect": "^1.13.1"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/signal-exit": {
"version": "4.1.0",
"resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
"integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
"dev": true,
"engines": {
"node": ">=14"
},
"funding": {
"url": "https://github.com/sponsors/isaacs"
}
},
"node_modules/slash": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz",
"integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/source-map-js": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.0.tgz",
"integrity": "sha512-itJW8lvSA0TXEphiRoawsCksnlf8SyvmFzIhltqAHluXd88pkCd+cXJVHTDwdCr0IzwptSm035IHQktUu1QUMg==",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/stop-iteration-iterator": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.0.0.tgz",
"integrity": "sha512-iCGQj+0l0HOdZ2AEeBADlsRC+vsnDsZsbdSiH1yNSjcfKM7fdpCMfqAL/dwF5BLiw/XhRft/Wax6zQbhq2BcjQ==",
"dev": true,
"dependencies": {
"internal-slot": "^1.0.4"
},
"engines": {
"node": ">= 0.4"
}
},
"node_modules/streamsearch": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/streamsearch/-/streamsearch-1.1.0.tgz",
"integrity": "sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==",
"engines": {
"node": ">=10.0.0"
}
},
"node_modules/string-width": {
"version": "5.1.2",
"resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
"integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
"dev": true,
"dependencies": {
"eastasianwidth": "^0.2.0",
"emoji-regex": "^9.2.2",
"strip-ansi": "^7.0.1"
},
"engines": {
"node": ">=12"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/string-width-cjs": {
"name": "string-width",
"version": "4.2.3",
"resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
"integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
"dev": true,
"dependencies": {
"emoji-regex": "^8.0.0",
"is-fullwidth-code-point": "^3.0.0",
"strip-ansi": "^6.0.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/string-width-cjs/node_modules/emoji-regex": {
"version": "8.0.0",
"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
"integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
"dev": true
},
"node_modules/string-width/node_modules/ansi-regex": {
"version": "6.0.1",
"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz",
"integrity": "sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==",
"dev": true,
"engines": {
"node": ">=12"
},
"funding": {
"url": "https://github.com/chalk/ansi-regex?sponsor=1"
}
},
"node_modules/string-width/node_modules/strip-ansi": {
"version": "7.1.0",
"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
"integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
"dev": true,
"dependencies": {
"ansi-regex": "^6.0.1"
},
"engines": {
"node": ">=12"
},
"funding": {
"url": "https://github.com/chalk/strip-ansi?sponsor=1"
}
},
"node_modules/string.prototype.includes": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/string.prototype.includes/-/string.prototype.includes-2.0.0.tgz",
"integrity": "sha512-E34CkBgyeqNDcrbU76cDjL5JLcVrtSdYq0MEh/B10r17pRP4ciHLwTgnuLV8Ay6cgEMLkcBkFCKyFZ43YldYzg==",
"dev": true,
"dependencies": {
"define-properties": "^1.1.3",
"es-abstract": "^1.17.5"
}
},
"node_modules/string.prototype.matchall": {
"version": "4.0.11",
"resolved": "https://registry.npmjs.org/string.prototype.matchall/-/string.prototype.matchall-4.0.11.tgz",
"integrity": "sha512-NUdh0aDavY2og7IbBPenWqR9exH+E26Sv8e0/eTe1tltDGZL+GtBkDAnnyBtmekfK6/Dq3MkcGtzXFEd1LQrtg==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"define-properties": "^1.2.1",
"es-abstract": "^1.23.2",
"es-errors": "^1.3.0",
"es-object-atoms": "^1.0.0",
"get-intrinsic": "^1.2.4",
"gopd": "^1.0.1",
"has-symbols": "^1.0.3",
"internal-slot": "^1.0.7",
"regexp.prototype.flags": "^1.5.2",
"set-function-name": "^2.0.2",
"side-channel": "^1.0.6"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/string.prototype.repeat": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/string.prototype.repeat/-/string.prototype.repeat-1.0.0.tgz",
"integrity": "sha512-0u/TldDbKD8bFCQ/4f5+mNRrXwZ8hg2w7ZR8wa16e8z9XpePWl3eGEcUD0OXpEH/VJH/2G3gjUtR3ZOiBe2S/w==",
"dev": true,
"dependencies": {
"define-properties": "^1.1.3",
"es-abstract": "^1.17.5"
}
},
"node_modules/string.prototype.trim": {
"version": "1.2.9",
"resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.9.tgz",
"integrity": "sha512-klHuCNxiMZ8MlsOihJhJEBJAiMVqU3Z2nEXWfWnIqjN0gEFS9J9+IxKozWWtQGcgoa1WUZzLjKPTr4ZHNFTFxw==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"define-properties": "^1.2.1",
"es-abstract": "^1.23.0",
"es-object-atoms": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/string.prototype.trimend": {
"version": "1.0.8",
"resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.8.tgz",
"integrity": "sha512-p73uL5VCHCO2BZZ6krwwQE3kCzM7NKmis8S//xEC6fQonchbum4eP6kR4DLEjQFO3Wnj3Fuo8NM0kOSjVdHjZQ==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"define-properties": "^1.2.1",
"es-object-atoms": "^1.0.0"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/string.prototype.trimstart": {
"version": "1.0.8",
"resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz",
"integrity": "sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"define-properties": "^1.2.1",
"es-object-atoms": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/strip-ansi": {
"version": "6.0.1",
"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
"integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
"dev": true,
"dependencies": {
"ansi-regex": "^5.0.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/strip-ansi-cjs": {
"name": "strip-ansi",
"version": "6.0.1",
"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
"integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
"dev": true,
"dependencies": {
"ansi-regex": "^5.0.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/strip-bom": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz",
"integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==",
"dev": true,
"engines": {
"node": ">=4"
}
},
"node_modules/strip-json-comments": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
"integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
"dev": true,
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/styled-jsx": {
"version": "5.1.1",
"resolved": "https://registry.npmjs.org/styled-jsx/-/styled-jsx-5.1.1.tgz",
"integrity": "sha512-pW7uC1l4mBZ8ugbiZrcIsiIvVx1UmTfw7UkC3Um2tmfUq9Bhk8IiyEIPl6F8agHgjzku6j0xQEZbfA5uSgSaCw==",
"dependencies": {
"client-only": "0.0.1"
},
"engines": {
"node": ">= 12.0.0"
},
"peerDependencies": {
"react": ">= 16.8.0 || 17.x.x || ^18.0.0-0"
},
"peerDependenciesMeta": {
"@babel/core": {
"optional": true
},
"babel-plugin-macros": {
"optional": true
}
}
},
"node_modules/sucrase": {
"version": "3.35.0",
"resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.0.tgz",
"integrity": "sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==",
"dev": true,
"dependencies": {
"@jridgewell/gen-mapping": "^0.3.2",
"commander": "^4.0.0",
"glob": "^10.3.10",
"lines-and-columns": "^1.1.6",
"mz": "^2.7.0",
"pirates": "^4.0.1",
"ts-interface-checker": "^0.1.9"
},
"bin": {
"sucrase": "bin/sucrase",
"sucrase-node": "bin/sucrase-node"
},
"engines": {
"node": ">=16 || 14 >=14.17"
}
},
"node_modules/supports-color": {
"version": "7.2.0",
"resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
"integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
"dev": true,
"dependencies": {
"has-flag": "^4.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/supports-preserve-symlinks-flag": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
"integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
"dev": true,
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/tailwindcss": {
"version": "3.4.10",
"resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.10.tgz",
"integrity": "sha512-KWZkVPm7yJRhdu4SRSl9d4AK2wM3a50UsvgHZO7xY77NQr2V+fIrEuoDGQcbvswWvFGbS2f6e+jC/6WJm1Dl0w==",
"dev": true,
"dependencies": {
"@alloc/quick-lru": "^5.2.0",
"arg": "^5.0.2",
"chokidar": "^3.5.3",
"didyoumean": "^1.2.2",
"dlv": "^1.1.3",
"fast-glob": "^3.3.0",
"glob-parent": "^6.0.2",
"is-glob": "^4.0.3",
"jiti": "^1.21.0",
"lilconfig": "^2.1.0",
"micromatch": "^4.0.5",
"normalize-path": "^3.0.0",
"object-hash": "^3.0.0",
"picocolors": "^1.0.0",
"postcss": "^8.4.23",
"postcss-import": "^15.1.0",
"postcss-js": "^4.0.1",
"postcss-load-config": "^4.0.1",
"postcss-nested": "^6.0.1",
"postcss-selector-parser": "^6.0.11",
"resolve": "^1.22.2",
"sucrase": "^3.32.0"
},
"bin": {
"tailwind": "lib/cli.js",
"tailwindcss": "lib/cli.js"
},
"engines": {
"node": ">=14.0.0"
}
},
"node_modules/tapable": {
"version": "2.2.1",
"resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz",
"integrity": "sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==",
"dev": true,
"engines": {
"node": ">=6"
}
},
"node_modules/text-table": {
"version": "0.2.0",
"resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
"integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==",
"dev": true
},
"node_modules/thenify": {
"version": "3.3.1",
"resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz",
"integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==",
"dev": true,
"dependencies": {
"any-promise": "^1.0.0"
}
},
"node_modules/thenify-all": {
"version": "1.6.0",
"resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz",
"integrity": "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==",
"dev": true,
"dependencies": {
"thenify": ">= 3.1.0 < 4"
},
"engines": {
"node": ">=0.8"
}
},
"node_modules/to-regex-range": {
"version": "5.0.1",
"resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
"integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
"dev": true,
"dependencies": {
"is-number": "^7.0.0"
},
"engines": {
"node": ">=8.0"
}
},
"node_modules/ts-api-utils": {
"version": "1.3.0",
"resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-1.3.0.tgz",
"integrity": "sha512-UQMIo7pb8WRomKR1/+MFVLTroIvDVtMX3K6OUir8ynLyzB8Jeriont2bTAtmNPa1ekAgN7YPDyf6V+ygrdU+eQ==",
"dev": true,
"engines": {
"node": ">=16"
},
"peerDependencies": {
"typescript": ">=4.2.0"
}
},
"node_modules/ts-interface-checker": {
"version": "0.1.13",
"resolved": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz",
"integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==",
"dev": true
},
"node_modules/tsconfig-paths": {
"version": "3.15.0",
"resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.15.0.tgz",
"integrity": "sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg==",
"dev": true,
"dependencies": {
"@types/json5": "^0.0.29",
"json5": "^1.0.2",
"minimist": "^1.2.6",
"strip-bom": "^3.0.0"
}
},
"node_modules/tslib": {
"version": "2.7.0",
"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.7.0.tgz",
"integrity": "sha512-gLXCKdN1/j47AiHiOkJN69hJmcbGTHI0ImLmbYLHykhgeN0jVGola9yVjFgzCUklsZQMW55o+dW7IXv3RCXDzA=="
},
"node_modules/type-check": {
"version": "0.4.0",
"resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
"integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
"dev": true,
"dependencies": {
"prelude-ls": "^1.2.1"
},
"engines": {
"node": ">= 0.8.0"
}
},
"node_modules/type-fest": {
"version": "0.20.2",
"resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
"integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
"dev": true,
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/typed-array-buffer": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.2.tgz",
"integrity": "sha512-gEymJYKZtKXzzBzM4jqa9w6Q1Jjm7x2d+sh19AdsD4wqnMPDYyvwpsIc2Q/835kHuo3BEQ7CjelGhfTsoBb2MQ==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"es-errors": "^1.3.0",
"is-typed-array": "^1.1.13"
},
"engines": {
"node": ">= 0.4"
}
},
"node_modules/typed-array-byte-length": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.1.tgz",
"integrity": "sha512-3iMJ9q0ao7WE9tWcaYKIptkNBuOIcZCCT0d4MRvuuH88fEoEH62IuQe0OtraD3ebQEoTRk8XCBoknUNc1Y67pw==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"for-each": "^0.3.3",
"gopd": "^1.0.1",
"has-proto": "^1.0.3",
"is-typed-array": "^1.1.13"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/typed-array-byte-offset": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.2.tgz",
"integrity": "sha512-Ous0vodHa56FviZucS2E63zkgtgrACj7omjwd/8lTEMEPFFyjfixMZ1ZXenpgCFBBt4EC1J2XsyVS2gkG0eTFA==",
"dev": true,
"dependencies": {
"available-typed-arrays": "^1.0.7",
"call-bind": "^1.0.7",
"for-each": "^0.3.3",
"gopd": "^1.0.1",
"has-proto": "^1.0.3",
"is-typed-array": "^1.1.13"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/typed-array-length": {
"version": "1.0.6",
"resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.6.tgz",
"integrity": "sha512-/OxDN6OtAk5KBpGb28T+HZc2M+ADtvRxXrKKbUwtsLgdoxgX13hyy7ek6bFRl5+aBs2yZzB0c4CnQfAtVypW/g==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.7",
"for-each": "^0.3.3",
"gopd": "^1.0.1",
"has-proto": "^1.0.3",
"is-typed-array": "^1.1.13",
"possible-typed-array-names": "^1.0.0"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/typescript": {
"version": "5.5.4",
"resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.4.tgz",
"integrity": "sha512-Mtq29sKDAEYP7aljRgtPOpTvOfbwRWlS6dPRzwjdE+C0R4brX/GUyhHSecbHMFLNBLcJIPt9nl9yG5TZ1weH+Q==",
"dev": true,
"bin": {
"tsc": "bin/tsc",
"tsserver": "bin/tsserver"
},
"engines": {
"node": ">=14.17"
}
},
"node_modules/unbox-primitive": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz",
"integrity": "sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==",
"dev": true,
"dependencies": {
"call-bind": "^1.0.2",
"has-bigints": "^1.0.2",
"has-symbols": "^1.0.3",
"which-boxed-primitive": "^1.0.2"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/undici-types": {
"version": "6.19.8",
"resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.19.8.tgz",
"integrity": "sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==",
"dev": true
},
"node_modules/uri-js": {
"version": "4.4.1",
"resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
"integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
"dev": true,
"dependencies": {
"punycode": "^2.1.0"
}
},
"node_modules/util-deprecate": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
"integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
"dev": true
},
"node_modules/which": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
"integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
"dev": true,
"dependencies": {
"isexe": "^2.0.0"
},
"bin": {
"node-which": "bin/node-which"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/which-boxed-primitive": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz",
"integrity": "sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==",
"dev": true,
"dependencies": {
"is-bigint": "^1.0.1",
"is-boolean-object": "^1.1.0",
"is-number-object": "^1.0.4",
"is-string": "^1.0.5",
"is-symbol": "^1.0.3"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/which-builtin-type": {
"version": "1.1.4",
"resolved": "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.1.4.tgz",
"integrity": "sha512-bppkmBSsHFmIMSl8BO9TbsyzsvGjVoppt8xUiGzwiu/bhDCGxnpOKCxgqj6GuyHE0mINMDecBFPlOm2hzY084w==",
"dev": true,
"dependencies": {
"function.prototype.name": "^1.1.6",
"has-tostringtag": "^1.0.2",
"is-async-function": "^2.0.0",
"is-date-object": "^1.0.5",
"is-finalizationregistry": "^1.0.2",
"is-generator-function": "^1.0.10",
"is-regex": "^1.1.4",
"is-weakref": "^1.0.2",
"isarray": "^2.0.5",
"which-boxed-primitive": "^1.0.2",
"which-collection": "^1.0.2",
"which-typed-array": "^1.1.15"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/which-collection": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/which-collection/-/which-collection-1.0.2.tgz",
"integrity": "sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==",
"dev": true,
"dependencies": {
"is-map": "^2.0.3",
"is-set": "^2.0.3",
"is-weakmap": "^2.0.2",
"is-weakset": "^2.0.3"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/which-typed-array": {
"version": "1.1.15",
"resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.15.tgz",
"integrity": "sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA==",
"dev": true,
"dependencies": {
"available-typed-arrays": "^1.0.7",
"call-bind": "^1.0.7",
"for-each": "^0.3.3",
"gopd": "^1.0.1",
"has-tostringtag": "^1.0.2"
},
"engines": {
"node": ">= 0.4"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/word-wrap": {
"version": "1.2.5",
"resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
"integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
"dev": true,
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/wrap-ansi": {
"version": "8.1.0",
"resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
"integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
"dev": true,
"dependencies": {
"ansi-styles": "^6.1.0",
"string-width": "^5.0.1",
"strip-ansi": "^7.0.1"
},
"engines": {
"node": ">=12"
},
"funding": {
"url": "https://github.com/chalk/wrap-ansi?sponsor=1"
}
},
"node_modules/wrap-ansi-cjs": {
"name": "wrap-ansi",
"version": "7.0.0",
"resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
"integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
"dev": true,
"dependencies": {
"ansi-styles": "^4.0.0",
"string-width": "^4.1.0",
"strip-ansi": "^6.0.0"
},
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/chalk/wrap-ansi?sponsor=1"
}
},
"node_modules/wrap-ansi-cjs/node_modules/emoji-regex": {
"version": "8.0.0",
"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
"integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
"dev": true
},
"node_modules/wrap-ansi-cjs/node_modules/string-width": {
"version": "4.2.3",
"resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
"integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
"dev": true,
"dependencies": {
"emoji-regex": "^8.0.0",
"is-fullwidth-code-point": "^3.0.0",
"strip-ansi": "^6.0.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/wrap-ansi/node_modules/ansi-regex": {
"version": "6.0.1",
"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz",
"integrity": "sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==",
"dev": true,
"engines": {
"node": ">=12"
},
"funding": {
"url": "https://github.com/chalk/ansi-regex?sponsor=1"
}
},
"node_modules/wrap-ansi/node_modules/ansi-styles": {
"version": "6.2.1",
"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz",
"integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==",
"dev": true,
"engines": {
"node": ">=12"
},
"funding": {
"url": "https://github.com/chalk/ansi-styles?sponsor=1"
}
},
"node_modules/wrap-ansi/node_modules/strip-ansi": {
"version": "7.1.0",
"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
"integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
"dev": true,
"dependencies": {
"ansi-regex": "^6.0.1"
},
"engines": {
"node": ">=12"
},
"funding": {
"url": "https://github.com/chalk/strip-ansi?sponsor=1"
}
},
"node_modules/wrappy": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
"integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
"dev": true
},
"node_modules/yaml": {
"version": "2.5.0",
"resolved": "https://registry.npmjs.org/yaml/-/yaml-2.5.0.tgz",
"integrity": "sha512-2wWLbGbYDiSqqIKoPjar3MPgB94ErzCtrNE1FdqGuaO0pi2JGjmE8aW8TDZwzU7vuxcGRdL/4gPQwQ7hD5AMSw==",
"dev": true,
"bin": {
"yaml": "bin.mjs"
},
"engines": {
"node": ">= 14"
}
},
"node_modules/yocto-queue": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
"integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
"dev": true,
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
}
}
}
|
0 | repos | repos/bitcoinzig.org/tailwind.config.ts | import type { Config } from "tailwindcss";
const config: Config = {
content: [
"./src/pages/**/*.{js,ts,jsx,tsx,mdx}",
"./src/components/**/*.{js,ts,jsx,tsx,mdx}",
"./src/app/**/*.{js,ts,jsx,tsx,mdx}",
],
theme: {
extend: {
backgroundImage: {
"gradient-radial": "radial-gradient(var(--tw-gradient-stops))",
"gradient-conic":
"conic-gradient(from 180deg at 50% 50%, var(--tw-gradient-stops))",
},
},
},
plugins: [],
};
export default config;
|
0 | repos | repos/bitcoinzig.org/tsconfig.json | {
"compilerOptions": {
"lib": ["dom", "dom.iterable", "esnext"],
"allowJs": true,
"skipLibCheck": true,
"strict": true,
"noEmit": true,
"esModuleInterop": true,
"module": "esnext",
"moduleResolution": "bundler",
"resolveJsonModule": true,
"isolatedModules": true,
"jsx": "preserve",
"incremental": true,
"plugins": [
{
"name": "next"
}
],
"paths": {
"@/*": ["./src/*"]
}
},
"include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
"exclude": ["node_modules"]
}
|
0 | repos | repos/bitcoinzig.org/README.md | This is a [Next.js](https://nextjs.org/) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app).
## Getting Started
First, run the development server:
```bash
npm run dev
# or
yarn dev
# or
pnpm dev
# or
bun dev
```
Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.
This project uses [`next/font`](https://nextjs.org/docs/basic-features/font-optimization) to automatically optimize and load Inter, a custom Google Font.
## Learn More
To learn more about Next.js, take a look at the following resources:
- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js/) - your feedback and contributions are welcome!
## Deploy on Vercel
The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
Check out our [Next.js deployment documentation](https://nextjs.org/docs/deployment) for more details.
|
0 | repos/bitcoinzig.org/src | repos/bitcoinzig.org/src/components/Hero.tsx | import Link from "next/link";
export default function Hero() {
return (
<div className="bg-gradient-to-r from-yellow-400 to-orange-500 text-white py-20">
<div className="container mx-auto px-4 text-center">
<h1 className="text-4xl md:text-6xl font-bold mb-4">
Bitcoin Development, Powered by Zig
</h1>
<p className="text-xl md:text-2xl mb-8">
Building robust, efficient, and educational Bitcoin libraries and
tools
</p>
<Link
href="https://github.com/zig-bitcoin"
className="bg-white text-orange-500 px-6 py-3 rounded-full font-semibold text-lg hover:bg-gray-100 transition duration-300"
>
Explore on GitHub
</Link>
</div>
</div>
);
}
|
0 | repos/bitcoinzig.org/src | repos/bitcoinzig.org/src/components/Footer.tsx | import Link from "next/link";
export default function Footer() {
return (
<footer className="bg-gray-800 text-white py-8">
<div className="container mx-auto px-4">
<div className="flex flex-col md:flex-row justify-between items-center">
<div className="mb-4 md:mb-0">
<p>© 2023 Zig Bitcoin. All rights reserved.</p>
</div>
<div className="flex space-x-4">
<Link
href="https://github.com/zig-bitcoin"
className="hover:text-yellow-400"
>
GitHub
</Link>
<Link href="https://ziglang.org/" className="hover:text-yellow-400">
Zig Language
</Link>
<Link href="https://bitcoin.org/" className="hover:text-yellow-400">
Bitcoin
</Link>
</div>
</div>
</div>
</footer>
);
}
|
0 | repos/bitcoinzig.org/src | repos/bitcoinzig.org/src/components/Header.tsx | import Link from "next/link";
import Image from "next/image";
export default function Header() {
return (
<header className="bg-white shadow-sm">
<nav className="container mx-auto px-4 py-3 flex justify-between items-center">
<Link href="/" className="flex items-center space-x-2">
<Image src="/images/logo.png" alt="Zig Logo" width={32} height={32} />
<span className="text-xl font-bold text-gray-800">Zig Bitcoin</span>
</Link>
<div className="space-x-4">
<Link
href="https://github.com/zig-bitcoin"
className="text-gray-600 hover:text-gray-900"
>
GitHub
</Link>
<Link href="#why-zig" className="text-gray-600 hover:text-gray-900">
Why Zig?
</Link>
</div>
</nav>
</header>
);
}
|
0 | repos/bitcoinzig.org/src | repos/bitcoinzig.org/src/components/WhyZig.tsx | export default function WhyZig() {
const reasons = [
"Idiomatic by default, perfect for open-source collaboration",
"Enhances ecosystem diversity and accessibility",
"Excellent educational resource for Bitcoin development",
"Precise communication of intent",
"Focus on code readability and maintainability",
"Compile-time safety with runtime performance",
];
return (
<section id="why-zig" className="py-16 bg-white">
<div className="container mx-auto px-4">
<h2 className="text-3xl font-bold text-center mb-8">
Why Zig for Bitcoin?
</h2>
<div className="grid md:grid-cols-2 gap-8">
{reasons.map((reason, index) => (
<div key={index} className="bg-gray-100 p-6 rounded-lg">
<p className="text-lg">{reason}</p>
</div>
))}
</div>
</div>
</section>
);
}
|
0 | repos/bitcoinzig.org/src | repos/bitcoinzig.org/src/app/page.tsx | import Header from "../components/Header";
import Hero from "../components/Hero";
import WhyZig from "../components/WhyZig";
import Footer from "../components/Footer";
export default function Home() {
return (
<main className="min-h-screen bg-gray-100">
<Header />
<Hero />
<WhyZig />
<Footer />
</main>
);
}
|
0 | repos/bitcoinzig.org/src | repos/bitcoinzig.org/src/app/layout.tsx | import { Inter } from "next/font/google";
import "./globals.css";
const inter = Inter({ subsets: ["latin"] });
export const metadata = {
title: "Zig Bitcoin",
description: "Bitcoin libraries, primitives, and tooling written in Zig",
};
export default function RootLayout({
children,
}: {
children: React.ReactNode;
}) {
return (
<html lang="en">
<body className={inter.className}>{children}</body>
</html>
);
}
|
0 | repos/bitcoinzig.org/src | repos/bitcoinzig.org/src/app/globals.css | @tailwind base;
@tailwind components;
@tailwind utilities;
:root {
--foreground-rgb: 0, 0, 0;
--background-start-rgb: 214, 219, 220;
--background-end-rgb: 255, 255, 255;
}
body {
color: rgb(var(--foreground-rgb));
background: linear-gradient(
to bottom,
transparent,
rgb(var(--background-end-rgb))
)
rgb(var(--background-start-rgb));
}
|
0 | repos | repos/scoop-zig/README.md | # :zap: scoop-zig :zap:
[](https://ci.appveyor.com/project/enndubyu/scoop-zig)
A scoop bucket for the zig compiler and related tools. Updated bihourly. Feel free to create an issue requesting any useful zig tools that are missing from the bucket.
To install zig:
```sh
# add scoop bucket
scoop bucket add scoop-zig https://github.com/enndubyu/scoop-zig
# install zig
scoop install zig
```
## Tools in the bucket:
- **zig** - *[zig](https://ziglang.org/) compiler*
- **zig-dev**[^1] - *zig compiler (development version)*
- **zig-mach**[^2] - *zig compiler ([mach](https://machengine.org/) project's latest [nominated](https://machengine.org/about/nominated-zig/) zig version)*
- **zls** - *language server for zig*
[^1]: `zig-dev` is aliased as both `zig` and `zig-dev` unless zig stable is also installed (in which case `zig` will execute zig stable)
[^2]: `zig-mach` is aliased as both `zig` and `zig-mach` unless zig stable is also installed (in which case `zig` will execute zig stable)
|
0 | repos/scoop-zig | repos/scoop-zig/bucket/zls.json | {
"version": "0.13.0",
"description": "Language server for zig.",
"homepage": "https://github.com/zigtools/zls",
"license": "MIT",
"suggest": {
"zig": [
"scoop-zig/zig",
"scoop-zig/zig-dev"
]
},
"architecture": {
"64bit": {
"url": "https://github.com/zigtools/zls/releases/download/0.13.0/zls-x86_64-windows.zip",
"hash": "d87ed0834df3c30feae976843f0c6640acd31af1f31c0917907f7bfebae5bd14"
},
"32bit": {
"url": "https://github.com/zigtools/zls/releases/download/0.13.0/zls-x86-windows.zip",
"hash": "8d71f0fde1238082ee3b7fb5d9e361411183fad2d7a55a78b403ed7cd4fc2d13"
}
},
"bin": "zls.exe",
"checkver": "github",
"autoupdate": {
"architecture": {
"64bit": {
"url": "https://github.com/zigtools/zls/releases/download/$version/zls-x86_64-windows.zip"
},
"32bit": {
"url": "https://github.com/zigtools/zls/releases/download/$version/zls-x86-windows.zip"
}
}
}
}
|
0 | repos/scoop-zig | repos/scoop-zig/bucket/zig-dev.json | {
"version": "0.14.0-dev.1457+7e3180487",
"description": "General-purpose programming language designed for robustness, optimality, and maintainability.",
"homepage": "https://ziglang.org/",
"license": "MIT",
"suggest": {
"vcredist": "extras/vcredist2022"
},
"architecture": {
"64bit": {
"url": "https://ziglang.org/builds/zig-windows-x86_64-0.14.0-dev.1457+7e3180487.zip",
"hash": "1d8cf44d58b3353ef995834b7b31f6ec4ddf89f4616c8dd602e8217babeae736",
"extract_dir": "zig-windows-x86_64-0.14.0-dev.1457+7e3180487"
}
},
"bin": [
"zig.exe",
[
"zig.exe",
"zig-dev",
""
]
],
"checkver": {
"url": "https://ziglang.org/download/index.json",
"jp": "$.master.version"
},
"autoupdate": {
"architecture": {
"64bit": {
"hash": {
"mode": "json",
"url": "https://ziglang.org/download/index.json",
"jp": "$.master.x86_64-windows.shasum"
},
"url": "https://ziglang.org/builds/zig-windows-x86_64-$version.zip",
"extract_dir": "zig-windows-x86_64-$version"
}
}
},
"post_install": "if (Test-Path \"$(appdir zig)\\current\\zig.exe\") { scoop reset zig }"
}
|
0 | repos/scoop-zig | repos/scoop-zig/bucket/zig.json | {
"version": "0.13.0",
"description": "General-purpose programming language designed for robustness, optimality, and maintainability.",
"homepage": "https://ziglang.org/",
"license": "MIT",
"suggest": {
"vcredist": "extras/vcredist2022"
},
"architecture": {
"64bit": {
"url": "https://ziglang.org/download/0.13.0/zig-windows-x86_64-0.13.0.zip",
"hash": "d859994725ef9402381e557c60bb57497215682e355204d754ee3df75ee3c158",
"extract_dir": "zig-windows-x86_64-0.13.0"
}
},
"bin": "zig.exe",
"checkver": {
"url": "https://ziglang.org/download/",
"regex": ">([\\d.]+)</h"
},
"autoupdate": {
"architecture": {
"64bit": {
"url": "https://ziglang.org/download/$version/zig-windows-x86_64-$version.zip",
"extract_dir": "zig-windows-x86_64-$version"
}
},
"hash": {
"url": "https://ziglang.org/download/",
"regex": "(?sm)$basename.*?$sha256"
}
}
}
|
0 | repos/scoop-zig | repos/scoop-zig/bucket/zig-mach.json | {
"version": "0.13.0-dev.351+64ef45eb0",
"description": "Latest nominated zig version for mach project.",
"homepage": "https://machengine.org/about/nominated-zig",
"license": "MIT",
"suggest": {
"vcredist": "extras/vcredist2022"
},
"architecture": {
"64bit": {
"url": "https://pkg.machengine.org/zig/zig-windows-x86_64-0.13.0-dev.351+64ef45eb0.zip",
"hash": "7be394a9fa1e131ecd948cd0137a72fcde18afdca7c4420333057974dfee5b7d",
"extract_dir": "zig-windows-x86_64-0.13.0-dev.351+64ef45eb0"
},
"32bit": {
"url": "https://pkg.machengine.org/zig/zig-windows-x86-0.13.0-dev.351+64ef45eb0.zip",
"hash": "f63946af192ddc40ec9ea7af8a7ed56119d19afc42d0106715e994a37d1cd96c",
"extract_dir": "zig-windows-x86-0.13.0-dev.351+64ef45eb0"
},
"arm64": {
"url": "https://pkg.machengine.org/zig/zig-windows-aarch64-0.13.0-dev.351+64ef45eb0.zip",
"hash": "d2b2d5a61258222467e0de8615675e2e66e184dc36c142adcf628246c97636a4",
"extract_dir": "zig-windows-aarch64-0.13.0-dev.351+64ef45eb0"
}
},
"bin": [
"zig.exe",
[
"zig.exe",
"zig-mach",
""
]
],
"checkver": {
"url": "https://machengine.org/zig/index.json",
"jsonpath": "$.mach-latest.version"
},
"autoupdate": {
"architecture": {
"64bit": {
"hash": {
"mode": "json",
"url": "https://machengine.org/zig/index.json",
"jp": "$.mach-latest.x86_64-windows.shasum"
},
"url": "https://pkg.machengine.org/zig/zig-windows-x86_64-$version.zip",
"extract_dir": "zig-windows-x86_64-$version"
},
"32bit": {
"hash": {
"mode": "json",
"url": "https://machengine.org/zig/index.json",
"jp": "$.mach-latest.x86-windows.shasum"
},
"url": "https://pkg.machengine.org/zig/zig-windows-x86-$version.zip",
"extract_dir": "zig-windows-x86-$version"
},
"arm64": {
"hash": {
"mode": "json",
"url": "https://machengine.org/zig/index.json",
"jp": "$.mach-latest.aarch64-windows.shasum"
},
"url": "https://pkg.machengine.org/zig/zig-windows-aarch64-$version.zip",
"extract_dir": "zig-windows-aarch64-$version"
}
}
},
"post_install": "if (Test-Path \"$(appdir zig)\\current\\zig.exe\") { scoop reset zig }"
}
|
0 | repos/scoop-zig | repos/scoop-zig/bin/auto-pr.ps1 | param(
# overwrite upstream param
[String]$upstream = "lukesampson/scoop-extras:master"
)
if(!$env:SCOOP_HOME) { $env:SCOOP_HOME = resolve-path (split-path (split-path (scoop which scoop))) }
$autopr = "$env:SCOOP_HOME/bin/auto-pr.ps1"
$dir = "$psscriptroot/../bucket" # checks the parent dir
Invoke-Expression -command "& '$autopr' -dir '$dir' -upstream $upstream $($args | ForEach-Object { "$_ " })"
|
0 | repos/scoop-zig | repos/scoop-zig/bin/checkver.ps1 | if(!$env:SCOOP_HOME) { $env:SCOOP_HOME = resolve-path (split-path (split-path (scoop which scoop))) }
$checkver = "$env:SCOOP_HOME/bin/checkver.ps1"
$dir = "$psscriptroot/../bucket" # checks the parent dir
Invoke-Expression -command "& '$checkver' -dir '$dir' $($args | ForEach-Object { "$_ " })"
|
0 | repos | repos/any-pointer/tests.zig | const std = @import("std");
const lib = @import("any-pointer.zig");
const builtin = @import("builtin");
const AnyPointer = lib.AnyPointer;
const SafePointer = lib.SafePointer;
const UnsafePointer = lib.UnsafePointer;
test "basic safe pointer" {
var i: u32 = 0;
const erased = SafePointer.make(*u32, &i);
const ptr = erased.cast(*u32);
try std.testing.expectEqual(@as(*u32, &i), ptr);
ptr.* = 42;
std.debug.assert(i == 42);
}
test "basic unsafe pointer" {
var i: u32 = 0;
const erased = UnsafePointer.make(*u32, &i);
const ptr = erased.cast(*u32);
try std.testing.expectEqual(@as(*u32, &i), ptr);
ptr.* = 42;
std.debug.assert(i == 42);
}
test "safe pointer try cast" {
var i: u32 = 0;
const erased = SafePointer.make(*u32, &i);
try std.testing.expectEqual(@as(?*u32, &i), erased.tryCast(*u32));
try std.testing.expectEqual(@as(?*f32, null), erased.tryCast(*f32));
}
test "optional pointer" {
var i: u32 = 0;
const erased = AnyPointer.make(?*u32, &i);
const ptr = erased.cast(?*u32);
try std.testing.expectEqual(@as(?*u32, &i), ptr);
ptr.?.* = 42;
std.debug.assert(i == 42);
}
test "tryCast optional pointer" {
var i: u32 = 0;
const erased = SafePointer.make(?*u32, &i);
try std.testing.expectEqual(@as(??*u32, &i), erased.tryCast(?*u32));
try std.testing.expectEqual(@as(??*f32, null), erased.tryCast(?*f32));
}
test "unsafe null pointer" {
const erased = UnsafePointer.null_pointer;
try std.testing.expectEqual(true, erased.isNull());
}
test "safe null pointer" {
const erased = SafePointer.null_pointer;
try std.testing.expectEqual(true, erased.isNull());
}
test "unsafe address equality" {
var i: u32 = 0;
var j: u32 = 0;
const erased = UnsafePointer.make(*u32, &i);
const erased_same = UnsafePointer.make(*u32, &i);
const erased_other = UnsafePointer.make(*u32, &j);
const erased_null = UnsafePointer.null_pointer;
try std.testing.expectEqual(true, erased.eql(erased_same));
try std.testing.expectEqual(false, erased.eql(erased_other));
try std.testing.expectEqual(true, erased_null.eql(UnsafePointer.null_pointer));
try std.testing.expectEqual(false, erased.eql(UnsafePointer.null_pointer));
}
test "safe address equality" {
var i: u32 = 0;
var j: u32 = 0;
const erased = SafePointer.make(*u32, &i);
const erased_same = SafePointer.make(*u32, &i);
const erased_other = SafePointer.make(*u32, &j);
const erased_null = SafePointer.null_pointer;
try std.testing.expectEqual(true, erased.eql(erased_same));
try std.testing.expectEqual(false, erased.eql(erased_other));
try std.testing.expectEqual(true, erased_null.eql(SafePointer.null_pointer));
try std.testing.expectEqual(false, erased.eql(SafePointer.null_pointer));
}
fn failingTest() void {
var i: u32 = 0;
const erased = SafePointer.make(*u32, &i);
const ptr = erased.cast(*f32);
ptr.* = 42;
std.debug.assert(i == 42);
}
test "failing test: type mismatch" {
if (builtin.os.tag == .windows) {
return error.ZigSkipTest;
} else {
const pid = try std.posix.fork();
if (pid == 0) {
std.posix.close(std.posix.STDOUT_FILENO);
std.posix.close(std.posix.STDERR_FILENO);
failingTest();
std.process.exit(0);
}
const res = std.posix.waitpid(pid, 0);
try std.testing.expectEqual(pid, res.pid);
try std.testing.expect(res.status != 0);
}
}
|
0 | repos | repos/any-pointer/README.md | # any-pointer type erasure
This package provides a single file `any-pointer.zig` that implements a type-erased pointer for Zig.
This pointer type supports three functions `make`, `cast` and `isNull` and exports the symbol `null_pointer`.
```zig
const AnyPointer = @import("any-pointer").AnyPointer;
var i: u32 = 0;
const erased = AnyPointer.make(*u32, &i);
const ptr = erased.cast(*u32);
ptr.* = 42;
std.debug.assert(!ptr.isNull());
std.debug.assert(i == 42);
```
In safe modes (`Debug` and `ReleaseSafe`) `cast` will type-check the pointer and might `@panic` when a type confusion would happen.
## Usage
Just add a package pointing to `any-pointer.zig` to your project.
The package will export three types:
- `SafePointer`, which will provide type checking and panics in safe modes.
- `UnsafePointer`, which will not provide type checking and will only have the size of a single pointer.
- `AnyPointer`, which will be `SafePointer` in safe modes and `UnsafePointer` in unsafe modes.
In addition to `make`, `cast` and `isNull`, `SafePointer` also has the function `tryCast` which works like `cast`, but will return an optional.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.