/* Generated from Zero standard-library sources. Run node --experimental-strip-types --disable-warning=ExperimentalWarning scripts/embed-stdlib-sources.mts to refresh. */
#ifndef ZERO_EMBEDDED_STDLIB_INC
#define ZERO_EMBEDDED_STDLIB_INC

static const char *const zero_embedded_stdlib_std_math_0_chunks[] = {
  "fn __zero_std_math_min_u32(left: u32, right: u32) -> u32 {\n    if left < right {\n        return left\n    }\n    return right\n}\n\nfn __zero_std_math_max_u32(left: u32, right: u32) -> u32 {\n    if left > right {\n        return left\n    }\n    return right\n}\n\nfn __zero_std_math_clamp_u32(value: u32, low: u32, high: u32) -> u32 {\n    let lower: u32 = __zero_std_math_min_u32(low, high)\n    let upper: u32 = __zero_std_math_max_u32(low, high)\n    if value < lower {\n        return lower\n    }\n    if value > upper {\n        return upper\n    }\n    return value\n}\n\nfn __zero_std_math_gcd_u32(a0: u32, b0: u32) -> u32 {\n    var a: u32 = a0\n    var b: u32 = b0\n    while b != 0 {\n        let next: u32 = a % b\n        a = b\n        b = next\n    }\n    return a\n}\n\nfn __zero_std_math_lcm_u32(left: u32, right: u32) -> u32 {\n    if left == 0 || right == 0 {\n        return 0\n    }\n    return left / __zero_std_math_gcd_u32(left, right) * right\n}\n\nfn __zero_std_math_pow_u32(base: u32, exponent: u32) -> u32 {\n    var result: u32 = 1\n    var current: u32 = base\n    var exp: u32 = exponent\n    while exp > 0 {\n        if exp % 2 == 1 {\n            result = result * current\n        }\n        current = current * current\n        exp = exp / 2\n    }\n    return result\n}\n\nfn __zero_std_math_mod_pow_u32(base: u32, exponent: u32, modulus: u32) -> u32 {\n    if modulus == 0 {\n        return 0\n    }\n    var result: u32 = 1 % modulus\n    var current: u32 = base % modulus\n    var exp: u32 = exponent\n    while exp > 0 {\n        if exp % 2 == 1 {\n            result = result * current % modulus\n        }\n        current = current * current % modulus\n        exp = exp / 2\n    }\n    return result\n}\n\nfn __zero_std_math_is_prime_u32(value: u32) -> Bool {\n    if value < 2 {\n        return false\n    }\n    if value == 2 {\n        return true\n    }\n    if value % 2 == 0 {\n        return false\n    }\n    var divisor: u32 = 3\n    while divisor <= value / divisor {\n        if value % divisor == 0 {\n            return false\n        }\n        divisor = divisor + 2\n    }\n    return true\n}\n\nfn __zero_std_math_divisor_count_u32(value: u32) -> u32 {\n    if value == 0 {\n        return 0\n    }\n    var count: u32 = 0\n    var divisor: u32 = 1\n    while divisor <= value / divisor {\n        if value % divisor == 0 {\n            let paired: u32 = value / divisor\n            if paired == divisor {\n                count = count + 1\n            } else {\n                count = count + 2\n            }\n        }\n        divisor = divisor + 1\n    }\n    return count\n}\n\nfn __zero_std_math_proper_divisor_sum_u32(value: u32) -> u32 {\n    if value <= 1 {\n        return 0\n    }\n    var sum: u32 = 1\n    var divisor: u32 = 2\n    while divisor <= value / divisor {\n        if value % divisor == 0 {\n            let paired: u32 = value / divisor\n            sum = sum + divisor\n",
  "            if paired != divisor {\n                sum = sum + paired\n            }\n        }\n        divisor = divisor + 1\n    }\n    return sum\n}\n",
  NULL
};

static const char *const zero_embedded_stdlib_std_path_0_chunks[] = {
  "fn __zero_std_path_is_sep(byte: u8) -> Bool {\n    return byte == 47_u8 || byte == 92_u8\n}\n\nfn __zero_std_path_segment_end(path: String, index: usize) -> Bool {\n    return index >= std.mem.len(path) || __zero_std_path_is_sep(path[index])\n}\n\nfn __zero_std_path_trim_end(path: String) -> usize {\n    var end: usize = std.mem.len(path)\n    while end > 0 && __zero_std_path_is_sep(path[end - 1]) {\n        end = end - 1\n    }\n    return end\n}\n\nfn __zero_std_path_basename(path: String) -> String {\n    let end: usize = __zero_std_path_trim_end(path)\n    var start: usize = end\n    while start > 0 && !__zero_std_path_is_sep(path[start - 1]) {\n        start = start - 1\n    }\n    return path[start..end]\n}\n\nfn __zero_std_path_dirname(path: String) -> String {\n    let end: usize = __zero_std_path_trim_end(path)\n    var root_len: usize = 0\n    if std.mem.len(path) > 0 && __zero_std_path_is_sep(path[0]) {\n        root_len = 1\n    }\n    if root_len > 0 && end == 0 {\n        return path[..root_len]\n    }\n    var split: usize = end\n    while split > 0 && !__zero_std_path_is_sep(path[split - 1]) {\n        split = split - 1\n    }\n    while split > root_len && __zero_std_path_is_sep(path[split - 1]) {\n        split = split - 1\n    }\n    return path[..split]\n}\n\nfn __zero_std_path_extension(path: String) -> String {\n    let end: usize = __zero_std_path_trim_end(path)\n    var start: usize = end\n    while start > 0 && !__zero_std_path_is_sep(path[start - 1]) {\n        start = start - 1\n    }\n    var dot: usize = end\n    var scan: usize = end\n    while scan > start {\n        scan = scan - 1\n        if path[scan] == 46_u8 {\n            dot = scan\n            scan = start\n        }\n    }\n    if dot == end {\n        return path[end..end]\n    }\n    if dot == start {\n        return path[end..end]\n    }\n    return path[dot + 1..end]\n}\n\nfn __zero_std_path_copy(buffer: MutSpan<u8>, source: String) -> Maybe<String> {\n    let len: usize = std.mem.len(source)\n    if len > std.mem.len(buffer) {\n        return null\n    }\n    var index: usize = 0\n    while index < len {\n        buffer[index] = source[index]\n        index = index + 1\n    }\n    return buffer[..len]\n}\n\nfn __zero_std_path_join(buffer: MutSpan<u8>, left: String, right: String) -> Maybe<String> {\n    var left_end: usize = __zero_std_path_trim_end(left)\n    if left_end == 0 && (std.mem.len(left) > 0 && __zero_std_path_is_sep(left[0])) {\n        left_end = 1\n    }\n    let left_is_root: Bool = left_end == 1 && __zero_std_path_is_sep(left[0])\n    let right_is_root: Bool = std.mem.len(right) > 0 && __zero_std_path_is_sep(right[0])\n    var right_start: usize = 0\n    while right_start < std.mem.len(right) && __zero_std_path_is_sep(right[right_start]) {\n        right_start = right_start + 1\n    }\n    let right_len: usize = std.mem.len(right) - right_start\n    var total: usize = left_end + right_len\n    if left_end == 0 && right_is_root {\n",
  "        total = total + 1\n    }\n    if left_end > 0 && right_len > 0 && !left_is_root {\n        total = total + 1\n    }\n    if total > std.mem.len(buffer) {\n        return null\n    }\n    var out: usize = 0\n    while out < left_end {\n        if left_is_root && out == 0 {\n            buffer[out] = 47_u8\n        } else {\n            buffer[out] = left[out]\n        }\n        out = out + 1\n    }\n    if left_end == 0 && right_is_root {\n        buffer[out] = 47_u8\n        out = out + 1\n    }\n    if left_end > 0 && right_len > 0 && !left_is_root {\n        buffer[out] = 47_u8\n        out = out + 1\n    }\n    var read: usize = right_start\n    while read < std.mem.len(right) {\n        buffer[out] = right[read]\n        out = out + 1\n        read = read + 1\n    }\n    return buffer[..out]\n}\n\nfn __zero_std_path_output_ends_parent(buffer: MutSpan<u8>, out: usize, root_len: usize) -> Bool {\n    if out <= root_len {\n        return false\n    }\n    var segment_start: usize = out\n    while segment_start > root_len && !__zero_std_path_is_sep(buffer[segment_start - 1]) {\n        segment_start = segment_start - 1\n    }\n    let segment_len: usize = out - segment_start\n    if segment_len != 2 {\n        return false\n    }\n    return buffer[segment_start] == 46_u8 && buffer[segment_start + 1] == 46_u8\n}\n\nfn __zero_std_path_normalize(buffer: MutSpan<u8>, path: String) -> Maybe<String> {\n    var read: usize = 0\n    var out: usize = 0\n    var root_len: usize = 0\n    if std.mem.len(path) > 0 && __zero_std_path_is_sep(path[0]) {\n        if std.mem.len(buffer) == 0 {\n            return null\n        }\n        buffer[0] = 47_u8\n        out = 1\n        root_len = 1\n        read = 1\n    }\n    while read < std.mem.len(path) {\n        while read < std.mem.len(path) && __zero_std_path_is_sep(path[read]) {\n            read = read + 1\n        }\n        if read < std.mem.len(path) {\n            let segment_start: usize = read\n            while read < std.mem.len(path) && !__zero_std_path_is_sep(path[read]) {\n                read = read + 1\n            }\n            let segment_end: usize = read\n            let segment_len: usize = segment_end - segment_start\n            if segment_len == 1 && path[segment_start] == 46_u8 {\n                read = segment_end\n            } else if segment_len == 2 && path[segment_start] == 46_u8 && path[segment_start + 1] == 46_u8 {\n                if root_len == 1 && out == root_len {\n                    read = segment_end\n                } else if out > root_len && !__zero_std_path_output_ends_parent(buffer, out, root_len) {\n                    while out > root_len && !__zero_std_path_is_sep(buffer[out - 1]) {\n                        out = out - 1\n                    }\n                    if out > root_len && __zero_std_path_is_sep(buffer[out - 1]) {\n                        out = out - 1\n                    }\n                } else {\n",
  "                    var needed: usize = segment_len\n                    if out > root_len {\n                        needed = needed + 1\n                    }\n                    if out + needed > std.mem.len(buffer) {\n                        return null\n                    }\n                    if out > root_len {\n                        buffer[out] = 47_u8\n                        out = out + 1\n                    }\n                    var copy: usize = segment_start\n                    while copy < segment_end {\n                        buffer[out] = path[copy]\n                        out = out + 1\n                        copy = copy + 1\n                    }\n                }\n            } else {\n                var needed: usize = segment_len\n                if out > root_len {\n                    needed = needed + 1\n                }\n                if out + needed > std.mem.len(buffer) {\n                    return null\n                }\n                if out > root_len {\n                    buffer[out] = 47_u8\n                    out = out + 1\n                }\n                var copy: usize = segment_start\n                while copy < segment_end {\n                    buffer[out] = path[copy]\n                    out = out + 1\n                    copy = copy + 1\n                }\n            }\n        }\n    }\n    return buffer[..out]\n}\n\nfn __zero_std_path_relative(buffer: MutSpan<u8>, base: String, target: String) -> Maybe<String> {\n    let base_end: usize = __zero_std_path_trim_end(base)\n    let target_len: usize = std.mem.len(target)\n    let base_prefix: String = base[..base_end]\n    let base_matches: Bool = std.str.startsWith(target, base_prefix)\n    if base_matches && base_end == target_len {\n        return buffer[..0]\n    }\n    if base_matches && base_end < target_len {\n        if __zero_std_path_is_sep(target[base_end]) {\n            var out: usize = 0\n            var read: usize = base_end + 1\n            let rel_len: usize = target_len - read\n            if rel_len > std.mem.len(buffer) {\n                return null\n            }\n            while read < target_len {\n                buffer[out] = target[read]\n                out = out + 1\n                read = read + 1\n            }\n            return buffer[..out]\n        }\n    }\n    return __zero_std_path_copy(buffer, target)\n}\n",
  NULL
};

static const char *const zero_embedded_stdlib_std_str_0_chunks[] = {
  "fn __zero_std_str_is_ascii_space(byte: u8) -> Bool {\n    return byte == 32_u8 || byte == 9_u8 || (byte == 10_u8 || byte == 13_u8)\n}\n\nfn __zero_std_str_reverse(buffer: MutSpan<u8>, text: Span<u8>) -> Maybe<Span<u8>> {\n    let len: usize = std.mem.len(text)\n    if len > std.mem.len(buffer) {\n        return null\n    }\n    var index: usize = 0\n    while index < len {\n        buffer[index] = text[len - 1 - index]\n        index = index + 1\n    }\n    return buffer[..len]\n}\n\nfn __zero_std_str_count_byte(text: Span<u8>, byte: u8) -> usize {\n    var index: usize = 0\n    var count: usize = 0\n    while index < std.mem.len(text) {\n        if text[index] == byte {\n            count = count + 1\n        }\n        index = index + 1\n    }\n    return count\n}\n\nfn __zero_std_str_starts_with(text: Span<u8>, prefix: Span<u8>) -> Bool {\n    let prefix_len: usize = std.mem.len(prefix)\n    if prefix_len > std.mem.len(text) {\n        return false\n    }\n    var index: usize = 0\n    while index < prefix_len {\n        if text[index] != prefix[index] {\n            return false\n        }\n        index = index + 1\n    }\n    return true\n}\n\nfn __zero_std_str_ends_with(text: Span<u8>, suffix: Span<u8>) -> Bool {\n    let text_len: usize = std.mem.len(text)\n    let suffix_len: usize = std.mem.len(suffix)\n    if suffix_len > text_len {\n        return false\n    }\n    let start: usize = text_len - suffix_len\n    var index: usize = 0\n    while index < suffix_len {\n        if text[start + index] != suffix[index] {\n            return false\n        }\n        index = index + 1\n    }\n    return true\n}\n\nfn __zero_std_str_contains(text: Span<u8>, needle: Span<u8>) -> Bool {\n    let needle_len: usize = std.mem.len(needle)\n    if needle_len == 0 {\n        return true\n    }\n    let text_len: usize = std.mem.len(text)\n    if needle_len > text_len {\n        return false\n    }\n    let last_start: usize = text_len - needle_len\n    var start: usize = 0\n    while start <= last_start {\n        var offset: usize = 0\n        var same: Bool = true\n        while same && offset < needle_len {\n            if text[start + offset] != needle[offset] {\n                same = false\n            } else {\n                offset = offset + 1\n            }\n        }\n        if same {\n            return true\n        }\n        start = start + 1\n    }\n    return false\n}\n\nfn __zero_std_str_trim_ascii(text: Span<u8>) -> Span<u8> {\n    var start: usize = 0\n    var end: usize = std.mem.len(text)\n    while start < end && __zero_std_str_is_ascii_space(text[start]) {\n        start = start + 1\n    }\n    while end > start && __zero_std_str_is_ascii_space(text[end - 1]) {\n        end = end - 1\n    }\n    return text[start..end]\n}\n\nfn __zero_std_str_word_count_ascii(text: Span<u8>) -> usize {\n    var index: usize = 0\n    var count: usize = 0\n    var in_word: Bool = false\n    while index < std.mem.len(text) {\n",
  "        if __zero_std_str_is_ascii_space(text[index]) {\n            in_word = false\n        } else if !in_word {\n            count = count + 1\n            in_word = true\n        }\n        index = index + 1\n    }\n    return count\n}\n",
  NULL
};

#endif