utf8

Encodes a sequence of code points into a UTF-8 string.

This functions similarly to string.char, invalid code points raise an error.

Returns the code points of all characters that start between byte positions start_position and end_position (both inclusive).

This functions similarly to string.byte, use utf8.unpack for long strings.

The last code point is decoded completely even if it ends after end_position.

Returns an iterator function that iterates over the code points of a UTF-8 string.

Yields the byte position and the code point of every character, like the standard utf8.codes.

Invalid sequences raise an error, or yield U+FFFD if lax is true.

Decodes a single UTF-8 sequence starting at the given byte position.

In lax mode invalid sequences do not raise an error, nil is returned as the code point together with the length of the maximal invalid subpart (the number of bytes to skip), the position of the offending byte and the error code.

Encodes a single code point into a UTF-8 sequence.

Returns the number of code points that start between byte positions start_position and end_position (both inclusive).

Unlike the standard utf8.len, an invalid sequence raises an error instead of returning nil and its position.

Returns a well-formed copy of a UTF-8 string, every invalid sequence is replaced with replacement_str.

Each maximal invalid subpart is replaced once (Unicode 3.9 "U+FFFD Substitution of Maximal Subparts", the same as the WHATWG decoder), e.g. "\xE2\x82A" becomes "\u{FFFD}A" and "\x80\x80" becomes "\u{FFFD}\u{FFFD}".

This is not Unicode normalization (NFC, NFD, NFKC, NFKD): valid sequences are copied as is, so canonically equivalent strings like "\u{E9}" and "e\u{301}" stay different.

Only the range between start_position and end_position is returned, a sequence cut by end_position is invalid.

Returns the byte positions where the n-th code point, counting from byte position, starts and ends.

This functions similarly to utf8.offset from Lua 5.5:

• n > 0 counts forward, 1 is the code point that starts at position.
• n < 0 counts backward, -1 is the code point right before position.
• n = 0 returns the code point that contains byte position.

#utf8_string + 1 is the position right after the last code point and is returned as #utf8_string + 1, #utf8_string + 1, so utf8.offset( s, utf8.len( s ) + 1 ) is #s + 1, just like Lua.

In lax mode every invalid sequence counts as one code point (the same way utf8.len counts them), otherwise any invalid sequence that is walked over raises an error.

Raises an error if n ~= 0 and position points inside a code point.

Returns the code points between byte positions start_position and end_position in reverse order.

This functions similarly to string.reverse, but the bytes of each code point keep their order.

Returns the substring between code points start_position and end_position (both inclusive).

This functions similarly to string.sub, but positions are in code points, negative positions count from the end of the string.

The bytes are copied as is, in lax mode invalid sequences are kept (each counts as one code point).

Decodes a UTF-8 string into a table of code points.