19 files changed, 615 insertions, 62 deletions

diff --git a/build.zig b/build.zig
index 0d002ad..58c3f21 100644
--- a/build.zig
+++ b/build.zig
@@ -137,6 +137,15 @@ pub fn build(b: *std.Build) void {
     const run_lower_gen_exe = b.addRunArtifact(lower_gen_exe);
     const lower_gen_out = run_lower_gen_exe.addOutputFileArg("lower.bin.z");
 
+    const scripts_gen_exe = b.addExecutable(.{
+        .name = "scripts",
+        .root_source_file = .{ .path = "codegen/scripts.zig" },
+        .target = b.host,
+        .optimize = .Debug,
+    });
+    const run_scripts_gen_exe = b.addRunArtifact(scripts_gen_exe);
+    const scripts_gen_out = run_scripts_gen_exe.addOutputFileArg("scripts.bin.z");
+
     // Modules we provide
     // Code points
     const code_point = b.addModule("code_point", .{
@@ -287,14 +296,22 @@ pub fn build(b: *std.Build) void {
     case_data.addAnonymousImport("upper", .{ .root_source_file = upper_gen_out });
     case_data.addAnonymousImport("lower", .{ .root_source_file = lower_gen_out });
 
+    // Scripts
+    const scripts_data = b.addModule("ScriptsData", .{
+        .root_source_file = .{ .path = "src/ScriptsData.zig" },
+        .target = target,
+        .optimize = optimize,
+    });
+    scripts_data.addAnonymousImport("scripts", .{ .root_source_file = scripts_gen_out });
+
     // Tests
     const exe_unit_tests = b.addTest(.{
-        .root_source_file = .{ .path = "src/CaseData.zig" },
+        .root_source_file = .{ .path = "src/ScriptsData.zig" },
         .target = target,
         .optimize = optimize,
     });
     // exe_unit_tests.root_module.addImport("ascii", ascii);
-    exe_unit_tests.root_module.addImport("code_point", code_point);
+    // exe_unit_tests.root_module.addImport("code_point", code_point);
     // exe_unit_tests.root_module.addImport("GraphemeData", grapheme_data);
     // exe_unit_tests.root_module.addImport("grapheme", grapheme);
     // exe_unit_tests.root_module.addImport("ziglyph", ziglyph.module("ziglyph"));
@@ -304,9 +321,10 @@ pub fn build(b: *std.Build) void {
     // exe_unit_tests.root_module.addImport("Normalize", norm);
     // exe_unit_tests.root_module.addImport("FoldData", fold_data);
     // exe_unit_tests.root_module.addAnonymousImport("numeric", .{ .root_source_file = num_gen_out });
-    exe_unit_tests.root_module.addAnonymousImport("case_prop", .{ .root_source_file = case_prop_gen_out });
-    exe_unit_tests.root_module.addAnonymousImport("upper", .{ .root_source_file = upper_gen_out });
-    exe_unit_tests.root_module.addAnonymousImport("lower", .{ .root_source_file = lower_gen_out });
+    // exe_unit_tests.root_module.addAnonymousImport("case_prop", .{ .root_source_file = case_prop_gen_out });
+    // exe_unit_tests.root_module.addAnonymousImport("upper", .{ .root_source_file = upper_gen_out });
+    // exe_unit_tests.root_module.addAnonymousImport("lower", .{ .root_source_file = lower_gen_out });
+    exe_unit_tests.root_module.addAnonymousImport("scripts", .{ .root_source_file = scripts_gen_out });
     // exe_unit_tests.filter = "nfd !ASCII";
 
     const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
diff --git a/codegen/scripts.zig b/codegen/scripts.zig
new file mode 100644
index 0000000..e985c1e
--- /dev/null
+++ b/codegen/scripts.zig
@@ -0,0 +1,309 @@
+const std = @import("std");
+const builtin = @import("builtin");
+
+const Script = enum {
+    none,
+    Adlam,
+    Ahom,
+    Anatolian_Hieroglyphs,
+    Arabic,
+    Armenian,
+    Avestan,
+    Balinese,
+    Bamum,
+    Bassa_Vah,
+    Batak,
+    Bengali,
+    Bhaiksuki,
+    Bopomofo,
+    Brahmi,
+    Braille,
+    Buginese,
+    Buhid,
+    Canadian_Aboriginal,
+    Carian,
+    Caucasian_Albanian,
+    Chakma,
+    Cham,
+    Cherokee,
+    Chorasmian,
+    Common,
+    Coptic,
+    Cuneiform,
+    Cypriot,
+    Cypro_Minoan,
+    Cyrillic,
+    Deseret,
+    Devanagari,
+    Dives_Akuru,
+    Dogra,
+    Duployan,
+    Egyptian_Hieroglyphs,
+    Elbasan,
+    Elymaic,
+    Ethiopic,
+    Georgian,
+    Glagolitic,
+    Gothic,
+    Grantha,
+    Greek,
+    Gujarati,
+    Gunjala_Gondi,
+    Gurmukhi,
+    Han,
+    Hangul,
+    Hanifi_Rohingya,
+    Hanunoo,
+    Hatran,
+    Hebrew,
+    Hiragana,
+    Imperial_Aramaic,
+    Inherited,
+    Inscriptional_Pahlavi,
+    Inscriptional_Parthian,
+    Javanese,
+    Kaithi,
+    Kannada,
+    Katakana,
+    Kawi,
+    Kayah_Li,
+    Kharoshthi,
+    Khitan_Small_Script,
+    Khmer,
+    Khojki,
+    Khudawadi,
+    Lao,
+    Latin,
+    Lepcha,
+    Limbu,
+    Linear_A,
+    Linear_B,
+    Lisu,
+    Lycian,
+    Lydian,
+    Mahajani,
+    Makasar,
+    Malayalam,
+    Mandaic,
+    Manichaean,
+    Marchen,
+    Masaram_Gondi,
+    Medefaidrin,
+    Meetei_Mayek,
+    Mende_Kikakui,
+    Meroitic_Cursive,
+    Meroitic_Hieroglyphs,
+    Miao,
+    Modi,
+    Mongolian,
+    Mro,
+    Multani,
+    Myanmar,
+    Nabataean,
+    Nag_Mundari,
+    Nandinagari,
+    New_Tai_Lue,
+    Newa,
+    Nko,
+    Nushu,
+    Nyiakeng_Puachue_Hmong,
+    Ogham,
+    Ol_Chiki,
+    Old_Hungarian,
+    Old_Italic,
+    Old_North_Arabian,
+    Old_Permic,
+    Old_Persian,
+    Old_Sogdian,
+    Old_South_Arabian,
+    Old_Turkic,
+    Old_Uyghur,
+    Oriya,
+    Osage,
+    Osmanya,
+    Pahawh_Hmong,
+    Palmyrene,
+    Pau_Cin_Hau,
+    Phags_Pa,
+    Phoenician,
+    Psalter_Pahlavi,
+    Rejang,
+    Runic,
+    Samaritan,
+    Saurashtra,
+    Sharada,
+    Shavian,
+    Siddham,
+    SignWriting,
+    Sinhala,
+    Sogdian,
+    Sora_Sompeng,
+    Soyombo,
+    Sundanese,
+    Syloti_Nagri,
+    Syriac,
+    Tagalog,
+    Tagbanwa,
+    Tai_Le,
+    Tai_Tham,
+    Tai_Viet,
+    Takri,
+    Tamil,
+    Tangsa,
+    Tangut,
+    Telugu,
+    Thaana,
+    Thai,
+    Tibetan,
+    Tifinagh,
+    Tirhuta,
+    Toto,
+    Ugaritic,
+    Vai,
+    Vithkuqi,
+    Wancho,
+    Warang_Citi,
+    Yezidi,
+    Yi,
+    Zanabazar_Square,
+};
+
+const block_size = 256;
+const Block = [block_size]u8;
+
+const BlockMap = std.HashMap(
+    Block,
+    u16,
+    struct {
+        pub fn hash(_: @This(), k: Block) u64 {
+            var hasher = std.hash.Wyhash.init(0);
+            std.hash.autoHashStrat(&hasher, k, .DeepRecursive);
+            return hasher.final();
+        }
+
+        pub fn eql(_: @This(), a: Block, b: Block) bool {
+            return std.mem.eql(u8, &a, &b);
+        }
+    },
+    std.hash_map.default_max_load_percentage,
+);
+
+pub fn main() !void {
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    var flat_map = std.AutoHashMap(u21, u8).init(allocator);
+    defer flat_map.deinit();
+
+    var line_buf: [4096]u8 = undefined;
+
+    // Process DerivedGeneralCategory.txt
+    var in_file = try std.fs.cwd().openFile("data/unicode/Scripts.txt", .{});
+    defer in_file.close();
+    var in_buf = std.io.bufferedReader(in_file.reader());
+    const in_reader = in_buf.reader();
+
+    while (try in_reader.readUntilDelimiterOrEof(&line_buf, '\n')) |line| {
+        if (line.len == 0 or line[0] == '#') continue;
+
+        const no_comment = if (std.mem.indexOfScalar(u8, line, '#')) |octo| line[0..octo] else line;
+
+        var field_iter = std.mem.tokenizeAny(u8, no_comment, "; ");
+        var current_code: [2]u21 = undefined;
+
+        var i: usize = 0;
+        while (field_iter.next()) |field| : (i += 1) {
+            switch (i) {
+                0 => {
+                    // Code point(s)
+                    if (std.mem.indexOf(u8, field, "..")) |dots| {
+                        current_code = .{
+                            try std.fmt.parseInt(u21, field[0..dots], 16),
+                            try std.fmt.parseInt(u21, field[dots + 2 ..], 16),
+                        };
+                    } else {
+                        const code = try std.fmt.parseInt(u21, field, 16);
+                        current_code = .{ code, code };
+                    }
+                },
+                1 => {
+                    // Script
+                    const script = std.meta.stringToEnum(Script, field) orelse {
+                        std.debug.print("Unknown script: {s}\n", .{field});
+                        return error.UnknownScript;
+                    };
+                    for (current_code[0]..current_code[1] + 1) |cp| try flat_map.put(@intCast(cp), @intFromEnum(script));
+                },
+                else => {},
+            }
+        }
+    }
+
+    var blocks_map = BlockMap.init(allocator);
+    defer blocks_map.deinit();
+
+    var stage1 = std.ArrayList(u16).init(allocator);
+    defer stage1.deinit();
+
+    var stage2 = std.ArrayList(u8).init(allocator);
+    defer stage2.deinit();
+
+    var stage3 = std.ArrayList(u8).init(allocator);
+    defer stage3.deinit();
+
+    var block: Block = [_]u8{0} ** block_size;
+    var block_len: u16 = 0;
+
+    for (0..0x110000) |i| {
+        const cp: u21 = @intCast(i);
+        const script = flat_map.get(cp) orelse 0;
+
+        const stage3_idx = blk: {
+            for (stage3.items, 0..) |script_i, j| {
+                if (script == script_i) break :blk j;
+            }
+            try stage3.append(script);
+            break :blk stage3.items.len - 1;
+        };
+
+        // Process block
+        block[block_len] = @intCast(stage3_idx);
+        block_len += 1;
+
+        if (block_len < block_size and cp != 0x10ffff) continue;
+
+        const gop = try blocks_map.getOrPut(block);
+        if (!gop.found_existing) {
+            gop.value_ptr.* = @intCast(stage2.items.len);
+            try stage2.appendSlice(&block);
+        }
+
+        try stage1.append(gop.value_ptr.*);
+        block_len = 0;
+    }
+
+    var args_iter = try std.process.argsWithAllocator(allocator);
+    defer args_iter.deinit();
+    _ = args_iter.skip();
+    const output_path = args_iter.next() orelse @panic("No output file arg!");
+
+    const compressor = std.compress.deflate.compressor;
+    var out_file = try std.fs.cwd().createFile(output_path, .{});
+    defer out_file.close();
+    var out_comp = try compressor(allocator, out_file.writer(), .{ .level = .best_compression });
+    defer out_comp.deinit();
+    const writer = out_comp.writer();
+
+    const endian = builtin.cpu.arch.endian();
+    try writer.writeInt(u16, @intCast(stage1.items.len), endian);
+    for (stage1.items) |i| try writer.writeInt(u16, i, endian);
+
+    try writer.writeInt(u16, @intCast(stage2.items.len), endian);
+    for (stage2.items) |i| try writer.writeInt(u8, i, endian);
+
+    try writer.writeInt(u8, @intCast(stage3.items.len), endian);
+    for (stage3.items) |i| try writer.writeInt(u8, i, endian);
+
+    try out_comp.flush();
+}
diff --git a/src/CanonData.zig b/src/CanonData.zig
index 36895ff..9f1deb8 100644
--- a/src/CanonData.zig
+++ b/src/CanonData.zig
@@ -42,7 +42,7 @@ pub fn init(allocator: mem.Allocator) !Self {
     return self;
 }
 
-pub fn deinit(self: *Self) void {
+pub fn deinit(self: *const Self) void {
     self.nfc.deinit();
     for (self.nfd) |slice| self.allocator.free(slice);
     self.allocator.free(self.nfd);
diff --git a/src/CaseData.zig b/src/CaseData.zig
index 4f06636..c9ccc1e 100644
--- a/src/CaseData.zig
+++ b/src/CaseData.zig
@@ -77,7 +77,7 @@ pub fn init(allocator: mem.Allocator) !Self {
     return self;
 }
 
-pub fn deinit(self: *Self) void {
+pub fn deinit(self: *const Self) void {
     self.allocator.free(self.case_map);
     self.allocator.free(self.prop_s1);
     self.allocator.free(self.prop_s2);
@@ -103,7 +103,7 @@ pub fn isUpperStr(self: Self, str: []const u8) bool {
 }
 
 test "isUpperStr" {
-    var cd = try init(testing.allocator);
+    const cd = try init(testing.allocator);
     defer cd.deinit();
 
     try testing.expect(cd.isUpperStr("HELLO, WORLD 2112!"));
@@ -138,7 +138,7 @@ pub fn toUpperStr(
 }
 
 test "toUpperStr" {
-    var cd = try init(testing.allocator);
+    const cd = try init(testing.allocator);
     defer cd.deinit();
 
     const uppered = try cd.toUpperStr(testing.allocator, "Hello, World 2112!");
@@ -161,7 +161,7 @@ pub fn isLowerStr(self: Self, str: []const u8) bool {
 }
 
 test "isLowerStr" {
-    var cd = try init(testing.allocator);
+    const cd = try init(testing.allocator);
     defer cd.deinit();
 
     try testing.expect(cd.isLowerStr("hello, world 2112!"));
@@ -196,7 +196,7 @@ pub fn toLowerStr(
 }
 
 test "toLowerStr" {
-    var cd = try init(testing.allocator);
+    const cd = try init(testing.allocator);
     defer cd.deinit();
 
     const lowered = try cd.toLowerStr(testing.allocator, "Hello, World 2112!");
diff --git a/src/CaseFold.zig b/src/CaseFold.zig
index e00d03b..9b10e16 100644
--- a/src/CaseFold.zig
+++ b/src/CaseFold.zig
@@ -90,11 +90,11 @@ pub fn compatCaselessMatch(
 test "compatCaselessMatch" {
     const allocator = testing.allocator;
 
-    var norm_data = try Normalize.NormData.init(allocator);
+    const norm_data = try Normalize.NormData.init(allocator);
     defer norm_data.deinit();
     const n = Normalize{ .norm_data = &norm_data };
 
-    var fold_data = try FoldData.init(allocator);
+    const fold_data = try FoldData.init(allocator);
     defer fold_data.deinit();
     const caser = Self{ .fold_data = &fold_data };
 
@@ -163,11 +163,11 @@ pub fn canonCaselessMatch(
 test "canonCaselessMatch" {
     const allocator = testing.allocator;
 
-    var norm_data = try Normalize.NormData.init(allocator);
+    const norm_data = try Normalize.NormData.init(allocator);
     defer norm_data.deinit();
     const n = Normalize{ .norm_data = &norm_data };
 
-    var fold_data = try FoldData.init(allocator);
+    const fold_data = try FoldData.init(allocator);
     defer fold_data.deinit();
     const caser = Self{ .fold_data = &fold_data };
 
diff --git a/src/CombiningData.zig b/src/CombiningData.zig
index 95c947d..c67638c 100644
--- a/src/CombiningData.zig
+++ b/src/CombiningData.zig
@@ -32,7 +32,7 @@ pub fn init(allocator: mem.Allocator) !Self {
     return self;
 }
 
-pub fn deinit(self: *Self) void {
+pub fn deinit(self: *const Self) void {
     self.allocator.free(self.s1);
     self.allocator.free(self.s2);
 }
diff --git a/src/CompatData.zig b/src/CompatData.zig
index fd7f678..67c43e6 100644
--- a/src/CompatData.zig
+++ b/src/CompatData.zig
@@ -37,7 +37,7 @@ pub fn init(allocator: mem.Allocator) !Self {
     return self;
 }
 
-pub fn deinit(self: *Self) void {
+pub fn deinit(self: *const Self) void {
     for (self.nfkd) |slice| {
         if (slice.len != 0) self.allocator.free(slice);
     }
diff --git a/src/DisplayWidth.zig b/src/DisplayWidth.zig
index 8d5eb0f..e547adf 100644
--- a/src/DisplayWidth.zig
+++ b/src/DisplayWidth.zig
@@ -56,7 +56,7 @@ pub fn strWidth(self: Self, str: []const u8) usize {
 }
 
 test "strWidth" {
-    var data = try DisplayWidthData.init(testing.allocator);
+    const data = try DisplayWidthData.init(testing.allocator);
     defer data.deinit();
     const self = Self{ .data = &data };
 
@@ -157,7 +157,7 @@ pub fn center(
 
 test "center" {
     const allocator = testing.allocator;
-    var data = try DisplayWidthData.init(allocator);
+    const data = try DisplayWidthData.init(allocator);
     defer data.deinit();
     const self = Self{ .data = &data };
 
@@ -236,7 +236,7 @@ pub fn padLeft(
 
 test "padLeft" {
     const allocator = testing.allocator;
-    var data = try DisplayWidthData.init(allocator);
+    const data = try DisplayWidthData.init(allocator);
     defer data.deinit();
     const self = Self{ .data = &data };
 
@@ -286,7 +286,7 @@ pub fn padRight(
 
 test "padRight" {
     const allocator = testing.allocator;
-    var data = try DisplayWidthData.init(allocator);
+    const data = try DisplayWidthData.init(allocator);
     defer data.deinit();
     const self = Self{ .data = &data };
 
@@ -339,7 +339,7 @@ pub fn wrap(
 
 test "wrap" {
     const allocator = testing.allocator;
-    var data = try DisplayWidthData.init(allocator);
+    const data = try DisplayWidthData.init(allocator);
     defer data.deinit();
     const self = Self{ .data = &data };
 
diff --git a/src/FoldData.zig b/src/FoldData.zig
index 2a9a1f5..e387447 100644
--- a/src/FoldData.zig
+++ b/src/FoldData.zig
@@ -41,7 +41,7 @@ pub fn init(allocator: mem.Allocator) !Self {
     return self;
 }
 
-pub fn deinit(self: *Self) void {
+pub fn deinit(self: *const Self) void {
     for (self.fold) |slice| self.allocator.free(slice);
     self.allocator.free(self.fold);
     self.allocator.free(self.cwcf);
diff --git a/src/GenCatData.zig b/src/GenCatData.zig
index b45135b..37ae037 100644
--- a/src/GenCatData.zig
+++ b/src/GenCatData.zig
@@ -71,7 +71,7 @@ pub fn init(allocator: mem.Allocator) !Self {
     return self;
 }
 
-pub fn deinit(self: *Self) void {
+pub fn deinit(self: *const Self) void {
     self.allocator.free(self.s1);
     self.allocator.free(self.s2);
     self.allocator.free(self.s3);
diff --git a/src/GraphemeData.zig b/src/GraphemeData.zig
index e418dea..971929a 100644
--- a/src/GraphemeData.zig
+++ b/src/GraphemeData.zig
@@ -64,7 +64,7 @@ pub fn init(allocator: mem.Allocator) !Self {
     return self;
 }
 
-pub fn deinit(self: *Self) void {
+pub fn deinit(self: *const Self) void {
     self.allocator.free(self.s1);
     self.allocator.free(self.s2);
     self.allocator.free(self.s3);
diff --git a/src/HangulData.zig b/src/HangulData.zig
index b97424c..ec360e9 100644
--- a/src/HangulData.zig
+++ b/src/HangulData.zig
@@ -41,7 +41,7 @@ pub fn init(allocator: mem.Allocator) !Self {
     return self;
 }
 
-pub fn deinit(self: *Self) void {
+pub fn deinit(self: *const Self) void {
     self.allocator.free(self.s1);
     self.allocator.free(self.s2);
 }
diff --git a/src/NormData.zig b/src/NormData.zig
index 8a7fa49..413619a 100644
--- a/src/NormData.zig
+++ b/src/NormData.zig
@@ -26,7 +26,7 @@ pub fn init(allocator: std.mem.Allocator) !Self {
     };
 }
 
-pub fn deinit(self: *Self) void {
+pub fn deinit(self: *const Self) void {
     self.canon_data.deinit();
     self.ccc_data.deinit();
     self.compat_data.deinit();
diff --git a/src/NormPropsData.zig b/src/NormPropsData.zig
index 3c49712..893a8d0 100644
--- a/src/NormPropsData.zig
+++ b/src/NormPropsData.zig
@@ -32,7 +32,7 @@ pub fn init(allocator: mem.Allocator) !Self {
     return self;
 }
 
-pub fn deinit(self: *Self) void {
+pub fn deinit(self: *const Self) void {
     self.allocator.free(self.s1);
     self.allocator.free(self.s2);
 }
diff --git a/src/Normalize.zig b/src/Normalize.zig
index 6ef7c90..daf774d 100644
--- a/src/Normalize.zig
+++ b/src/Normalize.zig
@@ -177,7 +177,7 @@ fn decompose(
 
 test "decompose" {
     const allocator = testing.allocator;
-    var data = try NormData.init(allocator);
+    const data = try NormData.init(allocator);
     defer data.deinit();
     var n = Self{ .norm_data = &data };
 
@@ -225,7 +225,7 @@ pub const Result = struct {
     allocator: ?mem.Allocator = null,
     slice: []const u8,
 
-    pub fn deinit(self: *Result) void {
+    pub fn deinit(self: *const Result) void {
         if (self.allocator) |allocator| allocator.free(self.slice);
     }
 };
@@ -297,11 +297,11 @@ fn nfxd(self: Self, allocator: mem.Allocator, str: []const u8, form: Form) !Resu
 
 test "nfd ASCII / no-alloc" {
     const allocator = testing.allocator;
-    var data = try NormData.init(allocator);
+    const data = try NormData.init(allocator);
     defer data.deinit();
-    var n = Self{ .norm_data = &data };
+    const n = Self{ .norm_data = &data };
 
-    var result = try n.nfd(allocator, "Hello World!");
+    const result = try n.nfd(allocator, "Hello World!");
     defer result.deinit();
 
     try testing.expectEqualStrings("Hello World!", result.slice);
@@ -309,11 +309,11 @@ test "nfd ASCII / no-alloc" {
 
 test "nfd !ASCII / alloc" {
     const allocator = testing.allocator;
-    var data = try NormData.init(allocator);
+    const data = try NormData.init(allocator);
     defer data.deinit();
-    var n = Self{ .norm_data = &data };
+    const n = Self{ .norm_data = &data };
 
-    var result = try n.nfd(allocator, "Héllo World! \u{3d3}");
+    const result = try n.nfd(allocator, "Héllo World! \u{3d3}");
     defer result.deinit();
 
     try testing.expectEqualStrings("He\u{301}llo World! \u{3d2}\u{301}", result.slice);
@@ -321,11 +321,11 @@ test "nfd !ASCII / alloc" {
 
 test "nfkd ASCII / no-alloc" {
     const allocator = testing.allocator;
-    var data = try NormData.init(allocator);
+    const data = try NormData.init(allocator);
     defer data.deinit();
-    var n = Self{ .norm_data = &data };
+    const n = Self{ .norm_data = &data };
 
-    var result = try n.nfkd(allocator, "Hello World!");
+    const result = try n.nfkd(allocator, "Hello World!");
     defer result.deinit();
 
     try testing.expectEqualStrings("Hello World!", result.slice);
@@ -333,11 +333,11 @@ test "nfkd ASCII / no-alloc" {
 
 test "nfkd !ASCII / alloc" {
     const allocator = testing.allocator;
-    var data = try NormData.init(allocator);
+    const data = try NormData.init(allocator);
     defer data.deinit();
-    var n = Self{ .norm_data = &data };
+    const n = Self{ .norm_data = &data };
 
-    var result = try n.nfkd(allocator, "Héllo World! \u{3d3}");
+    const result = try n.nfkd(allocator, "Héllo World! \u{3d3}");
     defer result.deinit();
 
     try testing.expectEqualStrings("He\u{301}llo World! \u{3a5}\u{301}", result.slice);
@@ -532,11 +532,11 @@ fn nfxc(self: Self, allocator: mem.Allocator, str: []const u8, form: Form) !Resu
 
 test "nfc" {
     const allocator = testing.allocator;
-    var data = try NormData.init(allocator);
+    const data = try NormData.init(allocator);
     defer data.deinit();
-    var n = Self{ .norm_data = &data };
+    const n = Self{ .norm_data = &data };
 
-    var result = try n.nfc(allocator, "Complex char: \u{3D2}\u{301}");
+    const result = try n.nfc(allocator, "Complex char: \u{3D2}\u{301}");
     defer result.deinit();
 
     try testing.expectEqualStrings("Complex char: \u{3D3}", result.slice);
@@ -544,11 +544,11 @@ test "nfc" {
 
 test "nfkc" {
     const allocator = testing.allocator;
-    var data = try NormData.init(allocator);
+    const data = try NormData.init(allocator);
     defer data.deinit();
-    var n = Self{ .norm_data = &data };
+    const n = Self{ .norm_data = &data };
 
-    var result = try n.nfkc(allocator, "Complex char: \u{03A5}\u{0301}");
+    const result = try n.nfkc(allocator, "Complex char: \u{03A5}\u{0301}");
     defer result.deinit();
 
     try testing.expectEqualStrings("Complex char: \u{038E}", result.slice);
@@ -556,9 +556,9 @@ test "nfkc" {
 
 /// Tests for equality of `a` and `b` after normalizing to NFC.
 pub fn eql(self: Self, allocator: mem.Allocator, a: []const u8, b: []const u8) !bool {
-    var norm_result_a = try self.nfc(allocator, a);
+    const norm_result_a = try self.nfc(allocator, a);
     defer norm_result_a.deinit();
-    var norm_result_b = try self.nfc(allocator, b);
+    const norm_result_b = try self.nfc(allocator, b);
     defer norm_result_b.deinit();
 
     return mem.eql(u8, norm_result_a.slice, norm_result_b.slice);
@@ -566,9 +566,9 @@ pub fn eql(self: Self, allocator: mem.Allocator, a: []const u8, b: []const u8) !
 
 test "eql" {
     const allocator = testing.allocator;
-    var data = try NormData.init(allocator);
+    const data = try NormData.init(allocator);
     defer data.deinit();
-    var n = Self{ .norm_data = &data };
+    const n = Self{ .norm_data = &data };
 
     try testing.expect(try n.eql(allocator, "foé", "foe\u{0301}"));
     try testing.expect(try n.eql(allocator, "foϓ", "fo\u{03D2}\u{0301}"));
@@ -601,9 +601,9 @@ fn isFcd(self: Self, str: []const u8) bool {
 
 test "isFcd" {
     const allocator = testing.allocator;
-    var data = try NormData.init(allocator);
+    const data = try NormData.init(allocator);
     defer data.deinit();
-    var n = Self{ .norm_data = &data };
+    const n = Self{ .norm_data = &data };
 
     const is_nfc = "José \u{3D3}";
     try testing.expect(n.isFcd(is_nfc));
@@ -620,9 +620,9 @@ test "Unicode normalization tests" {
     defer arena.deinit();
     var allocator = arena.allocator();
 
-    var data = try NormData.init(allocator);
+    const data = try NormData.init(allocator);
     defer data.deinit();
-    var n = Self{ .norm_data = &data };
+    const n = Self{ .norm_data = &data };
 
     var file = try fs.cwd().openFile("data/unicode/NormalizationTest.txt", .{});
     defer file.close();
@@ -721,7 +721,7 @@ test "Unicode normalization tests" {
                 }
 
                 const want = w_buf.items;
-                var got = try n.nfkd(allocator, input);
+                const got = try n.nfkd(allocator, input);
                 defer got.deinit();
 
                 try testing.expectEqualStrings(want, got.slice);
diff --git a/src/NumericData.zig b/src/NumericData.zig
index baf8f11..210d623 100644
--- a/src/NumericData.zig
+++ b/src/NumericData.zig
@@ -33,7 +33,7 @@ pub fn init(allocator: mem.Allocator) !Self {
     return self;
 }
 
-pub fn deinit(self: *Self) void {
+pub fn deinit(self: *const Self) void {
     self.allocator.free(self.s1);
     self.allocator.free(self.s2);
 }
@@ -59,7 +59,7 @@ pub inline fn isDecimal(self: Self, cp: u21) bool {
 }
 
 test "isDecimal" {
-    var self = try init(testing.allocator);
+    const self = try init(testing.allocator);
     defer self.deinit();
 
     try testing.expect(self.isNumber('\u{277f}'));
diff --git a/src/ScriptsData.zig b/src/ScriptsData.zig
new file mode 100644
index 0000000..ac1c46a
--- /dev/null
+++ b/src/ScriptsData.zig
@@ -0,0 +1,226 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const compress = std.compress;
+const mem = std.mem;
+const testing = std.testing;
+
+/// Script
+pub const Script = enum {
+    none,
+    Adlam,
+    Ahom,
+    Anatolian_Hieroglyphs,
+    Arabic,
+    Armenian,
+    Avestan,
+    Balinese,
+    Bamum,
+    Bassa_Vah,
+    Batak,
+    Bengali,
+    Bhaiksuki,
+    Bopomofo,
+    Brahmi,
+    Braille,
+    Buginese,
+    Buhid,
+    Canadian_Aboriginal,
+    Carian,
+    Caucasian_Albanian,
+    Chakma,
+    Cham,
+    Cherokee,
+    Chorasmian,
+    Common,
+    Coptic,
+    Cuneiform,
+    Cypriot,
+    Cypro_Minoan,
+    Cyrillic,
+    Deseret,
+    Devanagari,
+    Dives_Akuru,
+    Dogra,
+    Duployan,
+    Egyptian_Hieroglyphs,
+    Elbasan,
+    Elymaic,
+    Ethiopic,
+    Georgian,
+    Glagolitic,
+    Gothic,
+    Grantha,
+    Greek,
+    Gujarati,
+    Gunjala_Gondi,
+    Gurmukhi,
+    Han,
+    Hangul,
+    Hanifi_Rohingya,
+    Hanunoo,
+    Hatran,
+    Hebrew,
+    Hiragana,
+    Imperial_Aramaic,
+    Inherited,
+    Inscriptional_Pahlavi,
+    Inscriptional_Parthian,
+    Javanese,
+    Kaithi,
+    Kannada,
+    Katakana,
+    Kawi,
+    Kayah_Li,
+    Kharoshthi,
+    Khitan_Small_Script,
+    Khmer,
+    Khojki,
+    Khudawadi,
+    Lao,
+    Latin,
+    Lepcha,
+    Limbu,
+    Linear_A,
+    Linear_B,
+    Lisu,
+    Lycian,
+    Lydian,
+    Mahajani,
+    Makasar,
+    Malayalam,
+    Mandaic,
+    Manichaean,
+    Marchen,
+    Masaram_Gondi,
+    Medefaidrin,
+    Meetei_Mayek,
+    Mende_Kikakui,
+    Meroitic_Cursive,
+    Meroitic_Hieroglyphs,
+    Miao,
+    Modi,
+    Mongolian,
+    Mro,
+    Multani,
+    Myanmar,
+    Nabataean,
+    Nag_Mundari,
+    Nandinagari,
+    New_Tai_Lue,
+    Newa,
+    Nko,
+    Nushu,
+    Nyiakeng_Puachue_Hmong,
+    Ogham,
+    Ol_Chiki,
+    Old_Hungarian,
+    Old_Italic,
+    Old_North_Arabian,
+    Old_Permic,
+    Old_Persian,
+    Old_Sogdian,
+    Old_South_Arabian,
+    Old_Turkic,
+    Old_Uyghur,
+    Oriya,
+    Osage,
+    Osmanya,
+    Pahawh_Hmong,
+    Palmyrene,
+    Pau_Cin_Hau,
+    Phags_Pa,
+    Phoenician,
+    Psalter_Pahlavi,
+    Rejang,
+    Runic,
+    Samaritan,
+    Saurashtra,
+    Sharada,
+    Shavian,
+    Siddham,
+    SignWriting,
+    Sinhala,
+    Sogdian,
+    Sora_Sompeng,
+    Soyombo,
+    Sundanese,
+    Syloti_Nagri,
+    Syriac,
+    Tagalog,
+    Tagbanwa,
+    Tai_Le,
+    Tai_Tham,
+    Tai_Viet,
+    Takri,
+    Tamil,
+    Tangsa,
+    Tangut,
+    Telugu,
+    Thaana,
+    Thai,
+    Tibetan,
+    Tifinagh,
+    Tirhuta,
+    Toto,
+    Ugaritic,
+    Vai,
+    Vithkuqi,
+    Wancho,
+    Warang_Citi,
+    Yezidi,
+    Yi,
+    Zanabazar_Square,
+};
+
+allocator: mem.Allocator,
+s1: []u16 = undefined,
+s2: []u8 = undefined,
+s3: []u8 = undefined,
+
+const Self = @This();
+
+pub fn init(allocator: mem.Allocator) !Self {
+    const decompressor = compress.deflate.decompressor;
+    const in_bytes = @embedFile("scripts");
+    var in_fbs = std.io.fixedBufferStream(in_bytes);
+    var in_decomp = try decompressor(allocator, in_fbs.reader(), null);
+    defer in_decomp.deinit();
+    var reader = in_decomp.reader();
+
+    const endian = builtin.cpu.arch.endian();
+
+    var self = Self{ .allocator = allocator };
+
+    const s1_len: u16 = try reader.readInt(u16, endian);
+    self.s1 = try allocator.alloc(u16, s1_len);
+    for (0..s1_len) |i| self.s1[i] = try reader.readInt(u16, endian);
+
+    const s2_len: u16 = try reader.readInt(u16, endian);
+    self.s2 = try allocator.alloc(u8, s2_len);
+    _ = try reader.readAll(self.s2);
+
+    const s3_len: u16 = try reader.readInt(u8, endian);
+    self.s3 = try allocator.alloc(u8, s3_len);
+    _ = try reader.readAll(self.s3);
+
+    return self;
+}
+
+pub fn deinit(self: *const Self) void {
+    self.allocator.free(self.s1);
+    self.allocator.free(self.s2);
+    self.allocator.free(self.s3);
+}
+
+/// Lookup the Script type for `cp`.
+pub fn script(self: Self, cp: u21) ?Script {
+    const byte = self.s3[self.s2[self.s1[cp >> 8] + (cp & 0xff)]];
+    if (byte == 0) return null;
+    return @enumFromInt(byte);
+}
+
+test "script" {
+    const self = try init(std.testing.allocator);
+    defer self.deinit();
+    try testing.expectEqual(Script.Latin, self.script('A').?);
+}
diff --git a/src/WidthData.zig b/src/WidthData.zig
index 32f8658..d17f0cd 100644
--- a/src/WidthData.zig
+++ b/src/WidthData.zig
@@ -39,7 +39,7 @@ pub fn init(allocator: mem.Allocator) !Self {
     return self;
 }
 
-pub fn deinit(self: *Self) void {
+pub fn deinit(self: *const Self) void {
     self.allocator.free(self.s1);
     self.allocator.free(self.s2);
     self.g_data.deinit();
diff --git a/src/grapheme.zig b/src/grapheme.zig
index e55a6a4..ad43cfd 100644
--- a/src/grapheme.zig
+++ b/src/grapheme.zig
@@ -237,7 +237,7 @@ test "Segmentation GraphemeIterator" {
     var buf_reader = std.io.bufferedReader(file.reader());
     var input_stream = buf_reader.reader();
 
-    var data = try GraphemeData.init(allocator);
+    const data = try GraphemeData.init(allocator);
     defer data.deinit();
 
     var buf: [4096]u8 = undefined;
@@ -302,7 +302,7 @@ test "Segmentation ZWJ and ZWSP emoji sequences" {
     const with_zwsp = seq_1 ++ "\u{200B}" ++ seq_2;
     const no_joiner = seq_1 ++ seq_2;
 
-    var data = try GraphemeData.init(std.testing.allocator);
+    const data = try GraphemeData.init(std.testing.allocator);
     defer data.deinit();
 
     var iter = Iterator.init(with_zwj, &data);