aboutsummaryrefslogtreecommitdiff
path: root/vendor/libghostty-vt/pkg/oniguruma
diff options
context:
space:
mode:
authorCan Celik <ogulcancelik@gmail.com>2026-04-04 19:22:04 +0300
committerCan Celik <ogulcancelik@gmail.com>2026-04-05 01:23:06 +0300
commit41dd733ca7123c9ac4bfc6c781697a660e95b052 (patch)
tree3fc91815ca139ef2e0b281bba0abda4ef15175f4 /vendor/libghostty-vt/pkg/oniguruma
parent55c138263e190a1e79d4b997bfb9397306c0ec1f (diff)
feat: finish ghostty pane backend integration
Diffstat (limited to 'vendor/libghostty-vt/pkg/oniguruma')
-rw-r--r--vendor/libghostty-vt/pkg/oniguruma/build.zig171
-rw-r--r--vendor/libghostty-vt/pkg/oniguruma/build.zig.zon16
-rw-r--r--vendor/libghostty-vt/pkg/oniguruma/c.zig3
-rw-r--r--vendor/libghostty-vt/pkg/oniguruma/errors.zig201
-rw-r--r--vendor/libghostty-vt/pkg/oniguruma/init.zig16
-rw-r--r--vendor/libghostty-vt/pkg/oniguruma/main.zig21
-rw-r--r--vendor/libghostty-vt/pkg/oniguruma/match_param.zig23
-rw-r--r--vendor/libghostty-vt/pkg/oniguruma/regex.zig152
-rw-r--r--vendor/libghostty-vt/pkg/oniguruma/region.zig51
-rw-r--r--vendor/libghostty-vt/pkg/oniguruma/testing.zig15
-rw-r--r--vendor/libghostty-vt/pkg/oniguruma/types.zig96
11 files changed, 765 insertions, 0 deletions
diff --git a/vendor/libghostty-vt/pkg/oniguruma/build.zig b/vendor/libghostty-vt/pkg/oniguruma/build.zig
new file mode 100644
index 00000000..efc013b4
--- /dev/null
+++ b/vendor/libghostty-vt/pkg/oniguruma/build.zig
@@ -0,0 +1,171 @@
+const std = @import("std");
+const NativeTargetInfo = std.zig.system.NativeTargetInfo;
+
+pub fn build(b: *std.Build) !void {
+ const target = b.standardTargetOptions(.{});
+ const optimize = b.standardOptimizeOption(.{});
+
+ const module = b.addModule("oniguruma", .{
+ .root_source_file = b.path("main.zig"),
+ .target = target,
+ .optimize = optimize,
+ });
+
+ // For dynamic linking, we prefer dynamic linking and to search by
+ // mode first. Mode first will search all paths for a dynamic library
+ // before falling back to static.
+ const dynamic_link_opts: std.Build.Module.LinkSystemLibraryOptions = .{
+ .preferred_link_mode = .dynamic,
+ .search_strategy = .mode_first,
+ };
+
+ var test_exe: ?*std.Build.Step.Compile = null;
+ if (target.query.isNative()) {
+ test_exe = b.addTest(.{
+ .name = "test",
+ .root_module = b.createModule(.{
+ .root_source_file = b.path("main.zig"),
+ .target = target,
+ .optimize = optimize,
+ }),
+ });
+ const tests_run = b.addRunArtifact(test_exe.?);
+ const test_step = b.step("test", "Run tests");
+ test_step.dependOn(&tests_run.step);
+
+ // Uncomment this if we're debugging tests
+ b.installArtifact(test_exe.?);
+ }
+
+ if (b.systemIntegrationOption("oniguruma", .{})) {
+ module.linkSystemLibrary("oniguruma", dynamic_link_opts);
+
+ if (test_exe) |exe| {
+ exe.linkSystemLibrary2("oniguruma", dynamic_link_opts);
+ }
+ } else {
+ const lib = try buildLib(b, module, .{
+ .target = target,
+ .optimize = optimize,
+ });
+
+ if (test_exe) |exe| {
+ exe.linkLibrary(lib);
+ }
+ }
+}
+
+fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Build.Step.Compile {
+ const target = options.target;
+ const optimize = options.optimize;
+
+ const lib = b.addLibrary(.{
+ .name = "oniguruma",
+ .root_module = b.createModule(.{
+ .target = target,
+ .optimize = optimize,
+ }),
+ .linkage = .static,
+ });
+ const t = target.result;
+ const is_windows = t.os.tag == .windows;
+ lib.linkLibC();
+
+ if (target.result.os.tag.isDarwin()) {
+ const apple_sdk = @import("apple_sdk");
+ try apple_sdk.addPaths(b, lib);
+ }
+
+ if (b.lazyDependency("oniguruma", .{})) |upstream| {
+ lib.addIncludePath(upstream.path("src"));
+ module.addIncludePath(upstream.path("src"));
+
+ lib.addConfigHeader(b.addConfigHeader(.{
+ .style = .{ .cmake = upstream.path("src/config.h.cmake.in") },
+ }, .{
+ .PACKAGE = "oniguruma",
+ .PACKAGE_VERSION = "6.9.9",
+ .VERSION = "6.9.9",
+ .HAVE_ALLOCA = true,
+ .HAVE_ALLOCA_H = !is_windows,
+ .USE_CRNL_AS_LINE_TERMINATOR = is_windows,
+ .HAVE_STDINT_H = true,
+ .HAVE_SYS_TIMES_H = !is_windows,
+ .HAVE_SYS_TIME_H = !is_windows,
+ .HAVE_SYS_TYPES_H = true,
+ .HAVE_UNISTD_H = !is_windows,
+ .HAVE_INTTYPES_H = true,
+ .SIZEOF_INT = t.cTypeByteSize(.int),
+ .SIZEOF_LONG = t.cTypeByteSize(.long),
+ .SIZEOF_LONG_LONG = t.cTypeByteSize(.longlong),
+ .SIZEOF_VOIDP = t.ptrBitWidth() / t.cTypeBitSize(.char),
+ }));
+
+ var flags: std.ArrayList([]const u8) = .empty;
+ defer flags.deinit(b.allocator);
+ lib.addCSourceFiles(.{
+ .root = upstream.path(""),
+ .flags = flags.items,
+ .files = &.{
+ "src/regerror.c",
+ "src/regparse.c",
+ "src/regext.c",
+ "src/regcomp.c",
+ "src/regexec.c",
+ "src/reggnu.c",
+ "src/regenc.c",
+ "src/regsyntax.c",
+ "src/regtrav.c",
+ "src/regversion.c",
+ "src/st.c",
+ "src/onig_init.c",
+ "src/unicode.c",
+ "src/ascii.c",
+ "src/utf8.c",
+ "src/utf16_be.c",
+ "src/utf16_le.c",
+ "src/utf32_be.c",
+ "src/utf32_le.c",
+ "src/euc_jp.c",
+ "src/sjis.c",
+ "src/iso8859_1.c",
+ "src/iso8859_2.c",
+ "src/iso8859_3.c",
+ "src/iso8859_4.c",
+ "src/iso8859_5.c",
+ "src/iso8859_6.c",
+ "src/iso8859_7.c",
+ "src/iso8859_8.c",
+ "src/iso8859_9.c",
+ "src/iso8859_10.c",
+ "src/iso8859_11.c",
+ "src/iso8859_13.c",
+ "src/iso8859_14.c",
+ "src/iso8859_15.c",
+ "src/iso8859_16.c",
+ "src/euc_tw.c",
+ "src/euc_kr.c",
+ "src/big5.c",
+ "src/gb18030.c",
+ "src/koi8_r.c",
+ "src/cp1251.c",
+ "src/euc_jp_prop.c",
+ "src/sjis_prop.c",
+ "src/unicode_unfold_key.c",
+ "src/unicode_fold1_key.c",
+ "src/unicode_fold2_key.c",
+ "src/unicode_fold3_key.c",
+ },
+ });
+
+ lib.installHeadersDirectory(
+ upstream.path("src"),
+ "",
+ .{ .include_extensions = &.{".h"} },
+ );
+ }
+
+ b.installArtifact(lib);
+
+ return lib;
+}
diff --git a/vendor/libghostty-vt/pkg/oniguruma/build.zig.zon b/vendor/libghostty-vt/pkg/oniguruma/build.zig.zon
new file mode 100644
index 00000000..10ec786c
--- /dev/null
+++ b/vendor/libghostty-vt/pkg/oniguruma/build.zig.zon
@@ -0,0 +1,16 @@
+.{
+ .name = .oniguruma,
+ .version = "6.9.9",
+ .fingerprint = 0xe3b537b18c5785a8,
+ .paths = .{""},
+ .dependencies = .{
+ // kkos/oniguruma
+ .oniguruma = .{
+ .url = "https://deps.files.ghostty.org/oniguruma-1220c15e72eadd0d9085a8af134904d9a0f5dfcbed5f606ad60edc60ebeccd9706bb.tar.gz",
+ .hash = "N-V-__8AAHjwMQDBXnLq3Q2QhaivE0kE2aD138vtX2Bq1g7c",
+ .lazy = true,
+ },
+
+ .apple_sdk = .{ .path = "../apple-sdk" },
+ },
+}
diff --git a/vendor/libghostty-vt/pkg/oniguruma/c.zig b/vendor/libghostty-vt/pkg/oniguruma/c.zig
new file mode 100644
index 00000000..73732f90
--- /dev/null
+++ b/vendor/libghostty-vt/pkg/oniguruma/c.zig
@@ -0,0 +1,3 @@
+pub const c = @cImport({
+ @cInclude("oniguruma.h");
+});
diff --git a/vendor/libghostty-vt/pkg/oniguruma/errors.zig b/vendor/libghostty-vt/pkg/oniguruma/errors.zig
new file mode 100644
index 00000000..d63a481b
--- /dev/null
+++ b/vendor/libghostty-vt/pkg/oniguruma/errors.zig
@@ -0,0 +1,201 @@
+const c = @import("c.zig").c;
+const Encoding = @import("types.zig").Encoding;
+
+/// Maximum error message length.
+pub const MAX_ERROR_LEN = c.ONIG_MAX_ERROR_MESSAGE_LEN;
+
+/// Convert an Oniguruma error to an error.
+pub fn convertError(code: c_int) !c_int {
+ if (code >= 0) return code;
+ inline for (error_code_map) |m| {
+ if (m[1] == code) return m[0];
+ }
+
+ return Error.Unknown;
+}
+
+/// Convert an error code to a string. buf must be at least
+/// MAX_ERROR_LEN bytes long.
+pub fn errorString(buf: []u8, code: c_int) ![]u8 {
+ const len = c.onig_error_code_to_str(buf.ptr, code);
+ return buf[0..@intCast(len)];
+}
+
+/// The Oniguruma error info type, matching the C type exactly.
+pub const ErrorInfo = extern struct {
+ encoding: *Encoding,
+ par: [*]u8,
+ par_end: [*]u8,
+};
+
+/// All possible Oniguruma errors.
+pub const Error = error{
+ Mismatch,
+ NoSupportConfig,
+ Abort,
+ Memory,
+ TypeBug,
+ ParserBug,
+ StackBug,
+ UndefinedBytecode,
+ UnexpectedBytecode,
+ MatchStackLimitOver,
+ ParseDepthLimitOver,
+ RetryLimitInMatchOver,
+ RetryLimitInSearchOver,
+ SubexpCallLimitInSearchOver,
+ DefaultEncodingIsNotSet,
+ SpecifiedEncodingCantConvertToWideChar,
+ FailToInitialize,
+ InvalidArgument,
+ EndPatternAtLeftBrace,
+ EndPatternAtLeftBracket,
+ EmptyCharClass,
+ PrematureEndOfCharClass,
+ EndPatternAtEscape,
+ EndPatternAtMeta,
+ EndPatternAtControl,
+ MetaCodeSyntax,
+ ControlCodeSyntax,
+ CharClassValueAtEndOfRange,
+ CharClassValueAtStartOfRange,
+ UnmatchedRangeSpecifierInCharClass,
+ TargetOfRepeatOperatorNotSpecified,
+ TargetOfRepeatOperatorInvalid,
+ NestedRepeatOperator,
+ UnmatchedCloseParenthesis,
+ EndPatternWithUnmatchedParenthesis,
+ EndPatternInGroup,
+ UndefinedGroupOption,
+ InvalidGroupOption,
+ InvalidPosixBracketType,
+ InvalidLookBehindPattern,
+ InvalidRepeatRangePattern,
+ TooBigNumber,
+ TooBigNumberForRepeatRange,
+ UpperSmallerThanLowerInRepeatRange,
+ EmptyRangeInCharClass,
+ MismatchCodeLengthInClassRange,
+ TooManyMultiByteRanges,
+ TooShortMultiByteString,
+ TooBigBackrefNumber,
+ InvalidBackref,
+ NumberedBackrefOrCallNotAllowed,
+ TooManyCaptures,
+ TooLongWideCharValue,
+ UndefinedOperator,
+ EmptyGroupName,
+ InvalidGroupName,
+ InvalidCharInGroupName,
+ UndefinedNameReference,
+ UndefinedGroupReference,
+ MultiplexDefinedName,
+ MultiplexDefinitionNameCall,
+ NeverEndingRecursion,
+ GroupNumberOverForCaptureHistory,
+ InvalidCharPropertyName,
+ InvalidIfElseSyntax,
+ InvalidAbsentGroupPattern,
+ InvalidAbsentGroupGeneratorPattern,
+ InvalidCalloutPattern,
+ InvalidCalloutName,
+ UndefinedCalloutName,
+ InvalidCalloutBody,
+ InvalidCalloutTagName,
+ InvalidCalloutArg,
+ InvalidCodePointValue,
+ InvalidWideCharValue,
+ TooBigWideCharValue,
+ NotSupportedEncodingCombination,
+ InvalidCombinationOfOptions,
+ TooManyUserDefinedObjects,
+ TooLongPropertyName,
+ VeryInefficientPattern,
+ LibraryIsNotInitialized,
+ Unknown,
+};
+
+const error_code_map: []const struct { Error, c_int } = &.{
+ .{ Error.Mismatch, c.ONIG_MISMATCH },
+ .{ Error.NoSupportConfig, c.ONIG_NO_SUPPORT_CONFIG },
+ .{ Error.Abort, c.ONIG_ABORT },
+ .{ Error.Memory, c.ONIGERR_MEMORY },
+ .{ Error.TypeBug, c.ONIGERR_TYPE_BUG },
+ .{ Error.ParserBug, c.ONIGERR_PARSER_BUG },
+ .{ Error.StackBug, c.ONIGERR_STACK_BUG },
+ .{ Error.UndefinedBytecode, c.ONIGERR_UNDEFINED_BYTECODE },
+ .{ Error.UnexpectedBytecode, c.ONIGERR_UNEXPECTED_BYTECODE },
+ .{ Error.MatchStackLimitOver, c.ONIGERR_MATCH_STACK_LIMIT_OVER },
+ .{ Error.ParseDepthLimitOver, c.ONIGERR_PARSE_DEPTH_LIMIT_OVER },
+ .{ Error.RetryLimitInMatchOver, c.ONIGERR_RETRY_LIMIT_IN_MATCH_OVER },
+ .{ Error.RetryLimitInSearchOver, c.ONIGERR_RETRY_LIMIT_IN_SEARCH_OVER },
+ .{ Error.SubexpCallLimitInSearchOver, c.ONIGERR_SUBEXP_CALL_LIMIT_IN_SEARCH_OVER },
+ .{ Error.DefaultEncodingIsNotSet, c.ONIGERR_DEFAULT_ENCODING_IS_NOT_SET },
+ .{ Error.SpecifiedEncodingCantConvertToWideChar, c.ONIGERR_SPECIFIED_ENCODING_CANT_CONVERT_TO_WIDE_CHAR },
+ .{ Error.FailToInitialize, c.ONIGERR_FAIL_TO_INITIALIZE },
+ .{ Error.InvalidArgument, c.ONIGERR_INVALID_ARGUMENT },
+ .{ Error.EndPatternAtLeftBrace, c.ONIGERR_END_PATTERN_AT_LEFT_BRACE },
+ .{ Error.EndPatternAtLeftBracket, c.ONIGERR_END_PATTERN_AT_LEFT_BRACKET },
+ .{ Error.EmptyCharClass, c.ONIGERR_EMPTY_CHAR_CLASS },
+ .{ Error.PrematureEndOfCharClass, c.ONIGERR_PREMATURE_END_OF_CHAR_CLASS },
+ .{ Error.EndPatternAtEscape, c.ONIGERR_END_PATTERN_AT_ESCAPE },
+ .{ Error.EndPatternAtMeta, c.ONIGERR_END_PATTERN_AT_META },
+ .{ Error.EndPatternAtControl, c.ONIGERR_END_PATTERN_AT_CONTROL },
+ .{ Error.MetaCodeSyntax, c.ONIGERR_META_CODE_SYNTAX },
+ .{ Error.ControlCodeSyntax, c.ONIGERR_CONTROL_CODE_SYNTAX },
+ .{ Error.CharClassValueAtEndOfRange, c.ONIGERR_CHAR_CLASS_VALUE_AT_END_OF_RANGE },
+ .{ Error.CharClassValueAtStartOfRange, c.ONIGERR_CHAR_CLASS_VALUE_AT_START_OF_RANGE },
+ .{ Error.UnmatchedRangeSpecifierInCharClass, c.ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS },
+ .{ Error.TargetOfRepeatOperatorNotSpecified, c.ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED },
+ .{ Error.TargetOfRepeatOperatorInvalid, c.ONIGERR_TARGET_OF_REPEAT_OPERATOR_INVALID },
+ .{ Error.NestedRepeatOperator, c.ONIGERR_NESTED_REPEAT_OPERATOR },
+ .{ Error.UnmatchedCloseParenthesis, c.ONIGERR_UNMATCHED_CLOSE_PARENTHESIS },
+ .{ Error.EndPatternWithUnmatchedParenthesis, c.ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS },
+ .{ Error.EndPatternInGroup, c.ONIGERR_END_PATTERN_IN_GROUP },
+ .{ Error.UndefinedGroupOption, c.ONIGERR_UNDEFINED_GROUP_OPTION },
+ .{ Error.InvalidGroupOption, c.ONIGERR_INVALID_GROUP_OPTION },
+ .{ Error.InvalidPosixBracketType, c.ONIGERR_INVALID_POSIX_BRACKET_TYPE },
+ .{ Error.InvalidLookBehindPattern, c.ONIGERR_INVALID_LOOK_BEHIND_PATTERN },
+ .{ Error.InvalidRepeatRangePattern, c.ONIGERR_INVALID_REPEAT_RANGE_PATTERN },
+ .{ Error.TooBigNumber, c.ONIGERR_TOO_BIG_NUMBER },
+ .{ Error.TooBigNumberForRepeatRange, c.ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE },
+ .{ Error.UpperSmallerThanLowerInRepeatRange, c.ONIGERR_UPPER_SMALLER_THAN_LOWER_IN_REPEAT_RANGE },
+ .{ Error.EmptyRangeInCharClass, c.ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS },
+ .{ Error.MismatchCodeLengthInClassRange, c.ONIGERR_MISMATCH_CODE_LENGTH_IN_CLASS_RANGE },
+ .{ Error.TooManyMultiByteRanges, c.ONIGERR_TOO_MANY_MULTI_BYTE_RANGES },
+ .{ Error.TooShortMultiByteString, c.ONIGERR_TOO_SHORT_MULTI_BYTE_STRING },
+ .{ Error.TooBigBackrefNumber, c.ONIGERR_TOO_BIG_BACKREF_NUMBER },
+ .{ Error.InvalidBackref, c.ONIGERR_INVALID_BACKREF },
+ .{ Error.NumberedBackrefOrCallNotAllowed, c.ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED },
+ .{ Error.TooManyCaptures, c.ONIGERR_TOO_MANY_CAPTURES },
+ .{ Error.TooLongWideCharValue, c.ONIGERR_TOO_LONG_WIDE_CHAR_VALUE },
+ .{ Error.UndefinedOperator, c.ONIGERR_UNDEFINED_OPERATOR },
+ .{ Error.EmptyGroupName, c.ONIGERR_EMPTY_GROUP_NAME },
+ .{ Error.InvalidGroupName, c.ONIGERR_INVALID_GROUP_NAME },
+ .{ Error.InvalidCharInGroupName, c.ONIGERR_INVALID_CHAR_IN_GROUP_NAME },
+ .{ Error.UndefinedNameReference, c.ONIGERR_UNDEFINED_NAME_REFERENCE },
+ .{ Error.UndefinedGroupReference, c.ONIGERR_UNDEFINED_GROUP_REFERENCE },
+ .{ Error.MultiplexDefinedName, c.ONIGERR_MULTIPLEX_DEFINED_NAME },
+ .{ Error.MultiplexDefinitionNameCall, c.ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL },
+ .{ Error.NeverEndingRecursion, c.ONIGERR_NEVER_ENDING_RECURSION },
+ .{ Error.GroupNumberOverForCaptureHistory, c.ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY },
+ .{ Error.InvalidCharPropertyName, c.ONIGERR_INVALID_CHAR_PROPERTY_NAME },
+ .{ Error.InvalidIfElseSyntax, c.ONIGERR_INVALID_IF_ELSE_SYNTAX },
+ .{ Error.InvalidAbsentGroupPattern, c.ONIGERR_INVALID_ABSENT_GROUP_PATTERN },
+ .{ Error.InvalidAbsentGroupGeneratorPattern, c.ONIGERR_INVALID_ABSENT_GROUP_GENERATOR_PATTERN },
+ .{ Error.InvalidCalloutPattern, c.ONIGERR_INVALID_CALLOUT_PATTERN },
+ .{ Error.InvalidCalloutName, c.ONIGERR_INVALID_CALLOUT_NAME },
+ .{ Error.UndefinedCalloutName, c.ONIGERR_UNDEFINED_CALLOUT_NAME },
+ .{ Error.InvalidCalloutBody, c.ONIGERR_INVALID_CALLOUT_BODY },
+ .{ Error.InvalidCalloutTagName, c.ONIGERR_INVALID_CALLOUT_TAG_NAME },
+ .{ Error.InvalidCalloutArg, c.ONIGERR_INVALID_CALLOUT_ARG },
+ .{ Error.InvalidCodePointValue, c.ONIGERR_INVALID_CODE_POINT_VALUE },
+ .{ Error.InvalidWideCharValue, c.ONIGERR_INVALID_WIDE_CHAR_VALUE },
+ .{ Error.TooBigWideCharValue, c.ONIGERR_TOO_BIG_WIDE_CHAR_VALUE },
+ .{ Error.NotSupportedEncodingCombination, c.ONIGERR_NOT_SUPPORTED_ENCODING_COMBINATION },
+ .{ Error.InvalidCombinationOfOptions, c.ONIGERR_INVALID_COMBINATION_OF_OPTIONS },
+ .{ Error.TooManyUserDefinedObjects, c.ONIGERR_TOO_MANY_USER_DEFINED_OBJECTS },
+ .{ Error.TooLongPropertyName, c.ONIGERR_TOO_LONG_PROPERTY_NAME },
+ .{ Error.VeryInefficientPattern, c.ONIGERR_VERY_INEFFICIENT_PATTERN },
+ .{ Error.LibraryIsNotInitialized, c.ONIGERR_LIBRARY_IS_NOT_INITIALIZED },
+};
diff --git a/vendor/libghostty-vt/pkg/oniguruma/init.zig b/vendor/libghostty-vt/pkg/oniguruma/init.zig
new file mode 100644
index 00000000..ea64724c
--- /dev/null
+++ b/vendor/libghostty-vt/pkg/oniguruma/init.zig
@@ -0,0 +1,16 @@
+const c = @import("c.zig").c;
+const Encoding = @import("types.zig").Encoding;
+const errors = @import("errors.zig");
+
+/// Call once per process to initialize Oniguruma. This should be given
+/// the encodings that the program will use.
+pub fn init(encs: []const *Encoding) !void {
+ _ = try errors.convertError(c.onig_initialize(
+ @ptrCast(@alignCast(@constCast(encs.ptr))),
+ @intCast(encs.len),
+ ));
+}
+
+pub fn deinit() void {
+ _ = c.onig_end();
+}
diff --git a/vendor/libghostty-vt/pkg/oniguruma/main.zig b/vendor/libghostty-vt/pkg/oniguruma/main.zig
new file mode 100644
index 00000000..2541cc35
--- /dev/null
+++ b/vendor/libghostty-vt/pkg/oniguruma/main.zig
@@ -0,0 +1,21 @@
+const initpkg = @import("init.zig");
+const match_param = @import("match_param.zig");
+const regex = @import("regex.zig");
+const region = @import("region.zig");
+const types = @import("types.zig");
+
+pub const c = @import("c.zig");
+pub const testing = @import("testing.zig");
+pub const errors = @import("errors.zig");
+
+pub const init = initpkg.init;
+pub const deinit = initpkg.deinit;
+pub const Encoding = types.Encoding;
+pub const MatchParam = match_param.MatchParam;
+pub const Regex = regex.Regex;
+pub const Region = region.Region;
+pub const Syntax = types.Syntax;
+
+test {
+ @import("std").testing.refAllDecls(@This());
+}
diff --git a/vendor/libghostty-vt/pkg/oniguruma/match_param.zig b/vendor/libghostty-vt/pkg/oniguruma/match_param.zig
new file mode 100644
index 00000000..b28258ff
--- /dev/null
+++ b/vendor/libghostty-vt/pkg/oniguruma/match_param.zig
@@ -0,0 +1,23 @@
+const c = @import("c.zig").c;
+const errors = @import("errors.zig");
+const Error = errors.Error;
+
+pub const MatchParam = struct {
+ value: *c.OnigMatchParam,
+
+ pub fn init() !MatchParam {
+ const value = c.onig_new_match_param() orelse return Error.Memory;
+ return .{ .value = value };
+ }
+
+ pub fn deinit(self: *MatchParam) void {
+ c.onig_free_match_param(self.value);
+ }
+
+ pub fn setRetryLimitInSearch(self: *MatchParam, limit: usize) !void {
+ _ = try errors.convertError(c.onig_set_retry_limit_in_search_of_match_param(
+ self.value,
+ @intCast(limit),
+ ));
+ }
+};
diff --git a/vendor/libghostty-vt/pkg/oniguruma/regex.zig b/vendor/libghostty-vt/pkg/oniguruma/regex.zig
new file mode 100644
index 00000000..fd920e01
--- /dev/null
+++ b/vendor/libghostty-vt/pkg/oniguruma/regex.zig
@@ -0,0 +1,152 @@
+const std = @import("std");
+const c = @import("c.zig").c;
+const types = @import("types.zig");
+const errors = @import("errors.zig");
+const testEnsureInit = @import("testing.zig").ensureInit;
+const MatchParam = @import("match_param.zig").MatchParam;
+const Region = @import("region.zig").Region;
+const Error = errors.Error;
+const ErrorInfo = errors.ErrorInfo;
+const Encoding = types.Encoding;
+const Option = types.Option;
+const Syntax = types.Syntax;
+
+pub const Regex = struct {
+ value: c.OnigRegex,
+
+ pub fn init(
+ pattern: []const u8,
+ options: Option,
+ enc: *Encoding,
+ syntax: *Syntax,
+ err: ?*ErrorInfo,
+ ) !Regex {
+ var self: Regex = undefined;
+ _ = try errors.convertError(c.onig_new(
+ &self.value,
+ pattern.ptr,
+ pattern.ptr + pattern.len,
+ options.int(),
+ @ptrCast(@alignCast(enc)),
+ @ptrCast(@alignCast(syntax)),
+ @ptrCast(err),
+ ));
+ return self;
+ }
+
+ pub fn deinit(self: *Regex) void {
+ c.onig_free(self.value);
+ }
+
+ /// Search an entire string for matches. This always returns a region
+ /// which may heap allocate (C allocator).
+ pub fn search(
+ self: *Regex,
+ str: []const u8,
+ options: Option,
+ ) !Region {
+ return self.searchWithParam(str, options, null);
+ }
+
+ /// Search an entire string for matches. This always returns a region
+ /// which may heap allocate (C allocator).
+ pub fn searchWithParam(
+ self: *Regex,
+ str: []const u8,
+ options: Option,
+ match_param: ?*MatchParam,
+ ) !Region {
+ var region: Region = .{};
+
+ // As part of the searchAdvanced API call below, onig may allocate
+ // memory even if we fail to match. We need to deinit if there are
+ // any errors to free that memory.
+ errdefer region.deinit();
+
+ _ = try self.searchAdvancedWithParam(
+ str,
+ 0,
+ str.len,
+ &region,
+ options,
+ match_param,
+ );
+ return region;
+ }
+
+ /// onig_search directly
+ pub fn searchAdvanced(
+ self: *Regex,
+ str: []const u8,
+ start: usize,
+ end: usize,
+ region: *Region,
+ options: Option,
+ ) !usize {
+ return self.searchAdvancedWithParam(
+ str,
+ start,
+ end,
+ region,
+ options,
+ null,
+ );
+ }
+
+ /// onig_search_with_param directly
+ pub fn searchAdvancedWithParam(
+ self: *Regex,
+ str: []const u8,
+ start: usize,
+ end: usize,
+ region: *Region,
+ options: Option,
+ match_param: ?*MatchParam,
+ ) !usize {
+ const pos = try errors.convertError(if (match_param) |param|
+ c.onig_search_with_param(
+ self.value,
+ str.ptr,
+ str.ptr + str.len,
+ str.ptr + start,
+ str.ptr + end,
+ @ptrCast(region),
+ options.int(),
+ param.value,
+ )
+ else
+ c.onig_search(
+ self.value,
+ str.ptr,
+ str.ptr + str.len,
+ str.ptr + start,
+ str.ptr + end,
+ @ptrCast(region),
+ options.int(),
+ ));
+
+ return @intCast(pos);
+ }
+};
+
+test {
+ const testing = std.testing;
+
+ try testEnsureInit();
+ var re = try Regex.init("foo", .{}, Encoding.utf8, Syntax.default, null);
+ defer re.deinit();
+
+ var reg = try re.search("hello foo bar", .{});
+ defer reg.deinit();
+ try testing.expectEqual(@as(usize, 1), reg.count());
+
+ try testing.expectError(Error.Mismatch, re.search("hello", .{}));
+
+ var match_param = try MatchParam.init();
+ defer match_param.deinit();
+ try match_param.setRetryLimitInSearch(1000);
+
+ var reg_param = try re.searchWithParam("hello foo bar", .{}, &match_param);
+ defer reg_param.deinit();
+ try testing.expectEqual(@as(usize, 1), reg_param.count());
+}
diff --git a/vendor/libghostty-vt/pkg/oniguruma/region.zig b/vendor/libghostty-vt/pkg/oniguruma/region.zig
new file mode 100644
index 00000000..8c5c7a52
--- /dev/null
+++ b/vendor/libghostty-vt/pkg/oniguruma/region.zig
@@ -0,0 +1,51 @@
+const std = @import("std");
+const c = @import("c.zig").c;
+
+pub const Region = extern struct {
+ allocated: c_int = 0,
+ num_regs: c_int = 0,
+ beg: ?[*]c_int = null,
+ end: ?[*]c_int = null,
+ history_root: ?*c.OnigCaptureTreeNode = null, // TODO: convert to Zig
+
+ pub fn deinit(self: *Region) void {
+ // We never free ourself because allocation of Region in the Zig
+ // bindings is handled by the Zig program.
+ c.onig_region_free(@ptrCast(self), 0);
+ }
+
+ /// Count the number of matches
+ pub fn count(self: *const Region) usize {
+ return @intCast(self.num_regs);
+ }
+
+ /// Iterate over the matched ranges.
+ pub fn iterator(self: *const Region) Iterator {
+ return .{ .region = self };
+ }
+
+ pub fn starts(self: *const Region) []const c_int {
+ if (self.num_regs == 0) return &.{};
+ return self.beg.?[0..@intCast(self.num_regs)];
+ }
+
+ pub fn ends(self: *const Region) []const c_int {
+ if (self.num_regs == 0) return &.{};
+ return self.end.?[0..@intCast(self.num_regs)];
+ }
+
+ pub const Iterator = struct {
+ region: *const Region,
+ i: usize = 0,
+
+ /// The next range
+ pub fn next(self: *Iterator) ?[2]usize {
+ if (self.i >= self.region.num_regs) return null;
+ defer self.i += 1;
+ return .{
+ @intCast(self.region.beg.?[self.i]),
+ @intCast(self.region.end.?[self.i]),
+ };
+ }
+ };
+};
diff --git a/vendor/libghostty-vt/pkg/oniguruma/testing.zig b/vendor/libghostty-vt/pkg/oniguruma/testing.zig
new file mode 100644
index 00000000..234b5e75
--- /dev/null
+++ b/vendor/libghostty-vt/pkg/oniguruma/testing.zig
@@ -0,0 +1,15 @@
+const init = @import("init.zig");
+const Encoding = @import("types.zig").Encoding;
+
+var initialized: bool = false;
+
+/// Call this function before any other tests in this package to ensure that
+/// the oni library is initialized. This should only be used for tests
+/// and only when you're sure this is the ONLY way that oni is being
+/// initialized.
+///
+/// This always only initializes the encodings the tests use.
+pub fn ensureInit() !void {
+ if (initialized) return;
+ try init.init(&.{Encoding.utf8});
+}
diff --git a/vendor/libghostty-vt/pkg/oniguruma/types.zig b/vendor/libghostty-vt/pkg/oniguruma/types.zig
new file mode 100644
index 00000000..84a0a7c9
--- /dev/null
+++ b/vendor/libghostty-vt/pkg/oniguruma/types.zig
@@ -0,0 +1,96 @@
+const std = @import("std");
+const c = @import("c.zig").c;
+
+pub const Encoding = opaque {
+ pub const ascii: *Encoding = @ptrCast(c.ONIG_ENCODING_ASCII());
+ pub const iso_8859_1: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_1());
+ pub const iso_8859_2: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_2());
+ pub const iso_8859_3: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_3());
+ pub const iso_8859_4: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_4());
+ pub const iso_8859_5: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_5());
+ pub const iso_8859_6: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_6());
+ pub const iso_8859_7: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_7());
+ pub const iso_8859_8: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_8());
+ pub const iso_8859_9: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_9());
+ pub const iso_8859_10: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_10());
+ pub const iso_8859_11: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_11());
+ pub const iso_8859_13: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_13());
+ pub const iso_8859_14: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_14());
+ pub const iso_8859_15: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_15());
+ pub const iso_8859_16: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_16());
+ pub const utf8: *Encoding = @ptrCast(c.ONIG_ENCODING_UTF8());
+ pub const utf16_be: *Encoding = @ptrCast(c.ONIG_ENCODING_UTF16_BE());
+ pub const utf16_le: *Encoding = @ptrCast(c.ONIG_ENCODING_UTF16_LE());
+ pub const utf32_be: *Encoding = @ptrCast(c.ONIG_ENCODING_UTF32_BE());
+ pub const utf32_le: *Encoding = @ptrCast(c.ONIG_ENCODING_UTF32_LE());
+ pub const euc_jp: *Encoding = @ptrCast(c.ONIG_ENCODING_EUC_JP());
+ pub const euc_tw: *Encoding = @ptrCast(c.ONIG_ENCODING_EUC_TW());
+ pub const euc_kr: *Encoding = @ptrCast(c.ONIG_ENCODING_EUC_KR());
+ pub const euc_cn: *Encoding = @ptrCast(c.ONIG_ENCODING_EUC_CN());
+ pub const sjis: *Encoding = @ptrCast(c.ONIG_ENCODING_SJIS());
+ pub const koi8: *Encoding = @ptrCast(c.ONIG_ENCODING_KOI8());
+ pub const koi8_r: *Encoding = @ptrCast(c.ONIG_ENCODING_KOI8_R());
+ pub const cp1251: *Encoding = @ptrCast(c.ONIG_ENCODING_CP1251());
+ pub const big5: *Encoding = @ptrCast(c.ONIG_ENCODING_BIG5());
+ pub const gb18030: *Encoding = @ptrCast(c.ONIG_ENCODING_GB18030());
+};
+
+pub const Syntax = opaque {
+ pub const default: *Syntax = @ptrCast(c.ONIG_SYNTAX_ONIGURUMA());
+ pub const asis: *Syntax = @ptrCast(c.ONIG_SYNTAX_ASIS());
+ pub const posix_basic: *Syntax = @ptrCast(c.ONIG_SYNTAX_POSIX_BASIC());
+ pub const posix_extended: *Syntax = @ptrCast(c.ONIG_SYNTAX_POSIX_EXTENDED());
+ pub const emacs: *Syntax = @ptrCast(c.ONIG_SYNTAX_EMACS());
+ pub const grep: *Syntax = @ptrCast(c.ONIG_SYNTAX_GREP());
+ pub const gnu_regex: *Syntax = @ptrCast(c.ONIG_SYNTAX_GNU_REGEX());
+ pub const java: *Syntax = @ptrCast(c.ONIG_SYNTAX_JAVA());
+ pub const perl: *Syntax = @ptrCast(c.ONIG_SYNTAX_PERL());
+ pub const perl_ng: *Syntax = @ptrCast(c.ONIG_SYNTAX_PERL_NG());
+ pub const ruby: *Syntax = @ptrCast(c.ONIG_SYNTAX_RUBY());
+ pub const oniguruma: *Syntax = @ptrCast(c.ONIG_SYNTAX_ONIGURUMA());
+};
+
+pub const Option = packed struct(c_uint) {
+ ignorecase: bool = false,
+ extend: bool = false,
+ multiline: bool = false,
+ singleline: bool = false,
+ find_longest: bool = false,
+ find_not_empty: bool = false,
+ negate_singleline: bool = false,
+ dont_capture_group: bool = false,
+ capture_group: bool = false,
+ // search time
+ notbol: bool = false,
+ noteol: bool = false,
+ posix_region: bool = false,
+ check_validity_of_string: bool = false,
+ // compile time
+ ignorecase_is_ascii: bool = false,
+ word_is_ascii: bool = false,
+ digit_is_ascii: bool = false,
+ space_is_ascii: bool = false,
+ posix_is_ascii: bool = false,
+ text_segment_extended_grapheme_cluster: bool = false,
+ text_segment_word: bool = false,
+ // search time
+ not_begin_string: bool = false,
+ not_end_string: bool = false,
+ not_begin_position: bool = false,
+ callback_each_match: bool = false,
+ match_whole_string: bool = false,
+
+ _padding: u7 = 0,
+
+ pub fn int(self: Option) c_uint {
+ return @bitCast(self);
+ }
+
+ test "order" {
+ const testing = std.testing;
+ const opt: Option = .{ .extend = true };
+ try testing.expectEqual(c.ONIG_OPTION_EXTEND, opt.int());
+ }
+};
+
+test {}