diff --git a/README.md b/README.md
index c52e57f..288a53f 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# typst-oxifmt (v0.3.0)
+# typst-oxifmt (v1.0.0)
 
 A Typst library that brings convenient string formatting and interpolation through the `strfmt` function. Its syntax is taken directly from Rust's `format!` syntax, so feel free to read its page for more information (https://doc.rust-lang.org/std/fmt/); however, this README should have enough information and examples for all expected uses of the library. Only a few things aren't supported from the Rust syntax, such as the `p` (pointer) format type, or the `.*` precision specifier. Check out the ["Examples" section](#examples) for more.
 
@@ -9,7 +9,7 @@ A few extras (beyond the Rust-like syntax) will be added over time, though (feel
 ## Quick examples
 
 ```typ
-#import "@preview/oxifmt:0.3.0": strfmt
+#import "@preview/oxifmt:1.0.0": strfmt
 
 // "User John has 10 apples."
 #strfmt("User {} has {} apples.", "John", 10)
@@ -17,8 +17,8 @@ A few extras (beyond the Rust-like syntax) will be added over time, though (feel
 // "if exp > 100 { true }"
 #strfmt("if {var} > {num} {{ true }}", var: "exp", num: 100)
 
-// "1.10e2 meters"
-#strfmt("{:.2e} meters", 110.0)
+// "1.10e2 meters (**wow**)"
+#strfmt("{:.2e} meters ({:*^7})", 110.0, "wow")
 
 // "20_000 players have more than +002,300 points."
 #strfmt(
@@ -50,7 +50,7 @@ A few extras (beyond the Rust-like syntax) will be added over time, though (feel
 You can use this library through Typst's package manager (for Typst v0.6.0+):
 
 ```typ
-#import "@preview/oxifmt:0.3.0": strfmt
+#import "@preview/oxifmt:1.0.0": strfmt
 ```
 
 For older Typst versions, download the `oxifmt.typ` file either from Releases or directly from the repository. Then, move it to your project's folder, and write at the top of your Typst file(s):
@@ -64,7 +64,7 @@ Doing the above will give you access to the main function provided by this libra
 Its syntax is almost identical to Rust's `format!` (as specified here: https://doc.rust-lang.org/std/fmt/). You can escape formats by duplicating braces (`{{` and `}}` become `{` and `}`). Here's an example (see more examples in the file `tests/strfmt-tests.typ`):
 
 ```typ
-#import "@preview/oxifmt:0.3.0": strfmt
+#import "@preview/oxifmt:1.0.0": strfmt
 
 #let s = strfmt("I'm {}. I have {num} cars. I'm {0}. {} is {{cool}}.", "John", "Carl", num: 10)
 #assert.eq(s, "I'm John. I have 10 cars. I'm John. Carl is {cool}.")
@@ -82,7 +82,7 @@ You can use `{:spec}` to customize your output. See the Rust docs linked above f
     - For strings, `?` (and thus `repr()`) has the effect of printing them with double quotes. For floats, this ensures a `.0` appears after it, even if it doesn't have decimal digits. For integers, this doesn't change anything. Finally, for labels, the `<label>` (with `?`) is printed as `<label>` instead of `label`.
     - **TIP:** Prefer to always use `?` when you're inserting something that isn't a string, number or label, in order to ensure consistent results even if the library eventually changes the non-`?` representation.
 - After the `:`, add e.g. `_<8` to align the string to the left, padding it with as many `_`s as necessary for it to be at least `8` characters long (for example). Replace `<` by `>` for right alignment, or `^` for center alignment. (If the `_` is omitted, it defaults to ' ' (aligns with spaces).)
-    - If you prefer to specify the minimum width (the `8` there) as a separate argument to `strfmt` instead, you can specify `argument$` in place of the width, which will extract it from the integer at `argument`. For example, `_^3$` will center align the output with `_`s, where the minimum width desired is specified by the fourth positional argument (index `3`), as an integer. This means that a call such as `strfmt("{:_^3$}", 1, 2, 3, 4)` would produce `"__1__"`, as `3$` would evaluate to `4` (the value at the fourth positional argument/index `3`). Similarly, `named$` would take the width from the argument with name `named`, if it is an integer (otherwise, error).
+    - If you prefer to specify the minimum width (the `8` there) as a separate argument to `strfmt` instead, you can specify `argument$` in place of the width, which will extract it from the integer at `argument`. For example, `_^3$` will center align the output with `_`s, where the minimum width desired is specified by the fourth positional argument (index `3`), as an integer. This means that a call such as `strfmt("{v:_^3$}", 1, 2, 3, 4, v: 88)` would produce `"_88_"`, as `3$` would evaluate to `4` (the value at the fourth positional argument/index `3`). Similarly, `named$` would take the width from the argument with name `named`, if it is an integer (otherwise, error).
 - **For numbers:**
     - Specify `+` after the `:` to ensure zero or positive numbers are prefixed with `+` before them (instead of having no sign). `-` is also accepted but ignored (negative numbers always specify their sign anyways).
     - Use something like `:09` to add zeroes to the left of the number until it has at least 9 digits / characters.
@@ -104,7 +104,7 @@ You can use `{:spec}` to customize your output. See the Rust docs linked above f
 Some examples:
 
 ```typ
-#import "@preview/oxifmt:0.3.0": strfmt
+#import "@preview/oxifmt:1.0.0": strfmt
 
 #let s1 = strfmt("{0:?}, {test:+012e}, {1:-<#8x}", "hi", -74, test: 569.4)
 #assert.eq(s1, "\"hi\", +00005.694e2, -0x4a---")
@@ -120,7 +120,7 @@ Some examples:
 
 - **Inserting labels, text and numbers into strings:**
 ```typ
-#import "@preview/oxifmt:0.3.0": strfmt
+#import "@preview/oxifmt:1.0.0": strfmt
 
 #let s = strfmt("First: {}, Second: {}, Fourth: {3}, Banana: {banana} (brackets: {{escaped}})", 1, 2.1, 3, label("four"), banana: "Banana!!")
 #assert.eq(s, "First: 1, Second: 2.1, Fourth: four, Banana: Banana!! (brackets: {escaped})")
@@ -128,7 +128,7 @@ Some examples:
 
 - **Forcing `repr()` with `{:?}`** (which adds quotes around strings, and other things - basically represents a Typst value):
 ```typ
-#import "@preview/oxifmt:0.3.0": strfmt
+#import "@preview/oxifmt:1.0.0": strfmt
 
 #let s = strfmt("The value is: {:?} | Also the label is {:?}", "something", label("label"))
 #assert.eq(s, "The value is: \"something\" | Also the label is <label>")
@@ -136,7 +136,7 @@ Some examples:
 
 - **Inserting other types than numbers and strings** (for now, they will always use `repr()`, even without `{...:?}`, although that is more explicit):
 ```typ
-#import "@preview/oxifmt:0.3.0": strfmt
+#import "@preview/oxifmt:1.0.0": strfmt
 
 #let s = strfmt("Values: {:?}, {1:?}, {stuff:?}", (test: 500), ("a", 5.1), stuff: [a])
 #assert.eq(s, "Values: (test: 500), (\"a\", 5.1), [a]")
@@ -144,16 +144,16 @@ Some examples:
 
 - **Padding to a certain width with characters:** Use `{:x<8}`, where `x` is the **character to pad with** (e.g. space or `_`, but can be anything), `<` is the **alignment of the original text** relative to the padding (can be `<` for left aligned (padding goes to the right), `>` for right aligned (padded to its left) and `^` for center aligned (padded at both left and right)), and `8` is the **desired total width** (padding will add enough characters to reach this width; if the replacement string already has this width, no padding will be added):
 ```typ
-#import "@preview/oxifmt:0.3.0": strfmt
+#import "@preview/oxifmt:1.0.0": strfmt
 
 #let s = strfmt("Left5 {:-<5}, Right6 {:=>6}, Center10 {centered: ^10?}, Left3 {tleft:_<3}", "xx", 539, tleft: "okay", centered: [a])
-#assert.eq(s, "Left5 xx---, Right6 ===539, Center10     [a]    , Left3 okay")
+#assert.eq(s, "Left5 xx---, Right6 ===539, Center10    [a]    , Left3 okay")
 // note how 'okay' didn't suffer any padding at all (it already had at least the desired total width).
 ```
 
 - **Padding numbers with zeroes to the left:** It's a similar functionality to the above, however you write `{:08}` for 8 characters (for instance) - note that any characters in the number's representation matter for width (including sign, dot and decimal part):
 ```typ
-#import "@preview/oxifmt:0.3.0": strfmt
+#import "@preview/oxifmt:1.0.0": strfmt
 
 #let s = strfmt("Left-padded7 numbers: {:07} {:07} {:07} {3:07}", 123, -344, 44224059, 45.32)
 #assert.eq(s, "Left-padded7 numbers: 0000123 -000344 44224059 0045.32")
@@ -161,7 +161,7 @@ Some examples:
 
 - **Defining padding-to width using parameters, not literals:** If you want the desired replacement width (the `8` in `{:08}` or `{: ^8}`) to be passed via parameter (instead of being hardcoded into the format string), you can specify `parameter$` in place of the width, e.g. `{:02$}` to take it from the third positional parameter, or `{:a>banana$}` to take it from the parameter named `banana` - note that the chosen parameter **must be an integer** (desired total width):
 ```typ
-#import "@preview/oxifmt:0.3.0": strfmt
+#import "@preview/oxifmt:1.0.0": strfmt
 
 #let s = strfmt("Padding depending on parameter: {0:02$} and {0:a>banana$}", 432, 0, 5, banana: 9)
 #assert.eq(s, "Padding depending on parameter: 00432 aaaaaa432")  // widths 5 and 9
@@ -169,7 +169,7 @@ Some examples:
 
 - **Displaying `+` on positive numbers:** Just add a `+` at the "beginning", i.e., before the `#0` (if either is there), or after the custom fill and align (if it's there and not `0` - see [Grammar](#grammar) for the exact positioning), like so:
 ```typ
-#import "@preview/oxifmt:0.3.0": strfmt
+#import "@preview/oxifmt:1.0.0": strfmt
 
 #let s = strfmt("Some numbers: {:+} {:+08}; With fill and align: {:_<+8}; Negative (no-op): {neg:+}", 123, 456, 4444, neg: -435)
 #assert.eq(s, "Some numbers: +123 +0000456; With fill and align: +4444___; Negative (no-op): -435")
@@ -178,7 +178,7 @@ Some examples:
 
 - **Converting numbers to bases 2, 8 and 16:** Use one of the following specifier types (i.e., characters which always go at the very end of the format): `b` (binary), `o` (octal), `x` (lowercase hexadecimal) or `X` (uppercase hexadecimal). You can also add a `#` between `+` and `0` (see the exact position at the [Grammar](#grammar)) to display a **base prefix** before the number (i.e. `0b` for binary, `0o` for octal and `0x` for hexadecimal):
 ```typ
-#import "@preview/oxifmt:0.3.0": strfmt
+#import "@preview/oxifmt:1.0.0": strfmt
 
 #let s = strfmt("Bases (10, 2, 8, 16(l), 16(U):) {0} {0:b} {0:o} {0:x} {0:X} | W/ prefixes and modifiers: {0:#b} {0:+#09o} {0:_>+#9X}", 124)
 #assert.eq(s, "Bases (10, 2, 8, 16(l), 16(U):) 124 1111100 174 7c 7C | W/ prefixes and modifiers: 0b1111100 +0o000174 ____+0x7C")
@@ -186,7 +186,7 @@ Some examples:
 
 - **Picking float precision (right-extending with zeroes):** Add, at the end of the format (just before the spec type (such as `?`), if there's any), either `.precision` (hardcoded, e.g. `.8` for 8 decimal digits) or `.parameter$` (taking the precision value from the specified parameter, like with `width`):
 ```typ
-#import "@preview/oxifmt:0.3.0": strfmt
+#import "@preview/oxifmt:1.0.0": strfmt
 
 #let s = strfmt("{0:.8} {0:.2$} {0:.potato$}", 1.234, 0, 2, potato: 5)
 #assert.eq(s, "1.23400000 1.23 1.23400")
@@ -194,7 +194,7 @@ Some examples:
 
 - **Scientific notation:** Use `e` (lowercase) or `E` (uppercase) as specifier types (can be combined with precision):
 ```typ
-#import "@preview/oxifmt:0.3.0": strfmt
+#import "@preview/oxifmt:1.0.0": strfmt
 
 #let s = strfmt("{0:e} {0:E} {0:+.9e} | {1:e} | {2:.4E}", 124.2312, 50, -0.02)
 #assert.eq(s, "1.242312e2 1.242312E2 +1.242312000e2 | 5e1 | -2.0000E-2")
@@ -206,7 +206,7 @@ Oxifmt has some additional formatting options laid on top of Rust's, listed belo
 
 - **Customizing the decimal separator on floats:** Just specify `fmt-decimal-separator: ","` (comma as an example):
 ```typ
-#import "@preview/oxifmt:0.3.0": strfmt
+#import "@preview/oxifmt:1.0.0": strfmt
 
 #let s = strfmt("{0} {0:.6} {0:.5e}", 1.432, fmt-decimal-separator: ",")
 #assert.eq(s, "1,432 1,432000 1,43200e0")
@@ -214,7 +214,7 @@ Oxifmt has some additional formatting options laid on top of Rust's, listed belo
 
 - **Displaying thousands separators on numbers:** Specify `fmt-thousands-separator: "_"` (underscore as an example - the default is `""` which disables the feature):
 ```typ
-#import "@preview/oxifmt:0.3.0": strfmt
+#import "@preview/oxifmt:1.0.0": strfmt
 
 #let s = strfmt("{}", 20000, fmt-thousands-separator: "_")
 #assert.eq(s, "20_000")
@@ -222,12 +222,20 @@ Oxifmt has some additional formatting options laid on top of Rust's, listed belo
 
 - **Customizing the distance between thousands separators:** Specify `fmt-thousands-count: 2` (2 as an example - the default is 3):
 ```typ
-#import "@preview/oxifmt:0.3.0": strfmt
+#import "@preview/oxifmt:1.0.0": strfmt
 
 #let s = strfmt("{}", 20000, fmt-thousands-count: 2, fmt-thousands-separator: "_")
 #assert.eq(s, "2_00_00")
 ```
 
+- **Variable distances between thousands separators:** Specify `fmt-thousands-count: (3, 2)`, such that the rightmost (first) thousand will have 3 digits, then the second from the right will have 2 digits, and any further ones will have 2 digits as well (last group size is repeated):
+```typ
+#import "@preview/oxifmt:1.0.0": strfmt
+
+#let s = strfmt("{}", 1000000, fmt-thousands-count: (3, 2), fmt-thousands-separator: ",")
+#assert.eq(s, "10,00,000")
+```
+
 ### Grammar
 
 Here's the grammar specification for valid format `spec`s (in `{name:spec}`), which is basically Rust's format:
@@ -264,7 +272,23 @@ The tests succeeded if you received no error messages from the last command (ple
 
 ## Changelog
 
-### v0.3.0
+### v1.0.0 (2025-06-04)
+
+`oxifmt` is two years old!
+
+- **Breaking change:** Replacement names can no longer contain braces for consistency with Rust. ([Issue #17](https://github.com/PgBiel/typst-oxifmt/issues/17))
+  - That is, `{a {{ b}` and `{a }} b}` are now errors.
+  - Braces inside replacement names cannot be escaped, and `}` ends the name eagerly.
+  - Leads to less apparent ambiguity in some cases, and is also what Rust does.
+- **Breaking change:** Private symbols are now hidden. This package's entrypoint now only exports the `strfmt` function. ([PR #26](https://github.com/PgBiel/typst-oxifmt/pull/26))
+  - Technically not a breaking change as these weren't intended for public usage, but worth giving some attention to anyway.
+- Added variably-sized thousands for insertion of separators through `fmt-thousands-count: (group 1 size, group 2 size, ..., remaining group sizes)`. This may be useful for certain numbering systems used in India. ([Issue #21](https://github.com/PgBiel/typst-oxifmt/issues/21))
+  - For instance, one may have a digit group of size 3 followed by any amount of size 2 groups using `strfmt("1000000", fmt-thousands-count: (3, 2), fmt-thousands-separator: ",")`, which outputs `10,00,000` (note that groups go from right to left, similarly to the numbers themselves).
+- Fixed an inconsistency with Rust where `{` and `}` would not be valid padding characters in format specifiers. The following is now valid: `{:{<5}` i.e. pad to 5 characters to the left with `{` (similarly for `}`). ([Issue #28](https://github.com/PgBiel/typst-oxifmt/issues/28))
+- Fixed an inconsistency with Rust where center-aligned padding could result in more than the specified width as padding was forced to be equal on both sides for perfect centering. Now, `strfmt("{:_^4}", "a")` will output `"_a__"` (exactly 4 characters, even if not perfectly centered) instead of `"__a__"` (5 characters). ([Issue #29](https://github.com/PgBiel/typst-oxifmt/issues/29))
+- Fixed a bug with scientific notation conversion for fixed-point `decimal` where certain digits would not be displayed. ([Issue #23](https://github.com/PgBiel/typst-oxifmt/issues/23))
+
+### v0.3.0 (2025-05-27)
 
 - **Breaking change:** Named replacements prefixed with `fmt-` are now an error. Those are reserved for future `oxifmt` options. ([Issue #15](https://github.com/PgBiel/typst-oxifmt/issues/15))
   - For example, instead of `strfmt("{fmt-x}", fmt-x: 10)`, write `strfmt("{_fmt-x}, _fmt-x: 10")` instead (or some other name with a different prefix).
@@ -279,13 +303,13 @@ The tests succeeded if you received no error messages from the last command (ple
   - However, this was only triggered when a very rare formatting option was used (dynamic precision specifiers, which have a dollar sign `$`, e.g. `{:.prec$}`), so existing code is unlikely to be affected. Still a good idea to upgrade, though.
 - Fixed exponential notation formatting with very large numbers. Note that they might need rounding to look good (e.g. `strfmt("{:.2e}", number)` instead of just `{:e}`), but they will no longer cause an error. ([Issue #16](https://github.com/PgBiel/typst-oxifmt/issues/16))
 
-### v0.2.1
+### v0.2.1 (2024-05-08)
 
 - Fixed formatting of UTF-8 strings. Before, strings with multi-byte UTF-8 codepoints would cause formatting inconsistencies or even crashes. ([Issue #6](https://github.com/PgBiel/typst-oxifmt/issues/6))
 - Fixed an inconsistency in negative number formatting. Now, it will always print a regular hyphen (e.g. '-2'), which is consistent with Rust's behavior; before, it would occasionally print a minus sign instead (as observed in a comment to [Issue #4](https://github.com/PgBiel/typst-oxifmt/issues/4)).
 - Added compatibility with Typst 0.8.0's new type system.
 
-### v0.2.0
+### v0.2.0 (2023-08-02)
 
 - The package's name is now `oxifmt`!
 - `oxifmt:0.2.0` is now available through Typst's Package Manager! You can now write `#import "@preview/oxifmt:0.2.0": strfmt` to use the library.
@@ -293,7 +317,7 @@ The tests succeeded if you received no error messages from the last command (ple
 - Fixed negative numbers being formatted with two minus signs.
 - Fixed custom precision of floats not working when they are exact integers.
 
-### v0.1.0
+### v0.1.0 (2023-06-04)
 
 - Initial release, added `strfmt`.
 
diff --git a/bin/package.sh b/bin/package.sh
index 93df95a..ebb960e 100755
--- a/bin/package.sh
+++ b/bin/package.sh
@@ -9,7 +9,7 @@ orig_dir="$(realpath "$(dirname "$0")/..")"
 dest_dir="$1/packages/preview/oxifmt/${version}"
 mkdir -p "${dest_dir}"
 IFS=$' '
-for file in LICENSE LICENSE-MIT LICENSE-APACHE README.md oxifmt.typ typst.toml
+for file in LICENSE LICENSE-MIT LICENSE-APACHE README.md oxifmt.typ lib.typ typst.toml
 do
     cp "${orig_dir}/${file}" -t "${dest_dir}"
 done
diff --git a/lib.typ b/lib.typ
new file mode 100644
index 0000000..d2f7329
--- /dev/null
+++ b/lib.typ
@@ -0,0 +1 @@
+#import "oxifmt.typ": strfmt
diff --git a/oxifmt.typ b/oxifmt.typ
index c12882e..a26d651 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -5,6 +5,7 @@
 #let _float-type = type(5.5)
 #let _str-type = type("")
 #let _label-type = type(<hello>)
+#let _arr-type = type(())
 
 #let _minus-sign = "\u{2212}"
 #let using-080 = type(type(5)) != _str-type
@@ -32,6 +33,39 @@
   }
 }
 
+// Splits an array into dynamic chunk sizes.
+// 'chunks' is an array e.g. (1, 2, 3) indicating
+// the sizes of each chunk. The last size is repeated if there
+// are more elements than the chunks combined can cover.
+//
+// For example, if arr = ("a", "b", "c", "d", "e", "f", "g", "h", "i") and
+// chunks = (2, 3), this will return
+// (("a", "b"), ("c", "d", "e"), ("f", "g", "h"), ("i",))
+#let _arr-dyn-chunks(arr, chunks) = {
+  let i = 0
+  let res = ()
+  let chunk-i = 0
+  if chunks == () {
+    return ()
+  }
+
+  for element in arr {
+    if i == 0 {
+      res.push(())
+      i = chunks.at(chunk-i)
+      if i <= 0 {
+        assert(false, message: "String formatter error: internal error: received chunk of invalid size")
+      }
+      if chunk-i + 1 != chunks.len() {
+        chunk-i += 1
+      }
+    }
+    res.last().push(element)
+    i -= 1
+  }
+  res
+}
+
 #let _float-is-nan = if using-0110 {
   float.is-nan
 } else {
@@ -54,6 +88,8 @@
   // -- parsing state --
   let current-fmt-span = none
   let current-fmt-name = none
+  // if we're at {abc:|, i.e. right after a colon in {}
+  let last-was-fmt-colon = false
   // if the last character was an unescaped {
   let last-was-lbracket = false
   // if the last character was an unescaped }
@@ -82,6 +118,7 @@
   // -- parse loop --
   let last-i = none
   let i = 0
+  let code-i = 0
   for character in codepoints {
     if character == "{" {
       // double l-bracket = escape
@@ -89,67 +126,74 @@
         last-was-lbracket = false  // escape {{
         last-was-rbracket = false
         if current-fmt-span.at(0) == last-i {
+          // outside a span ({...} {{ <-) => emit an 'escaped' token
           current-fmt-span = none  // cancel this span
           current-fmt-name = none
-        }
-        if current-fmt-name != none {
-          // if in the middle of a larger span ({ ... {{ <-):
-          // add the escaped character to the format name
-          current-fmt-name += character
-        } else {
-          // outside a span ({...} {{ <-) => emit an 'escaped' token
           result.push((escape: (escaped: "{", span: (last-i, i + 1))))
+        } else {
+          panic("String formatter error: internal error: invalid left bracket state")
         }
-
-        last-i = i
-        i += 1  // '{' is ASCII, so 1 byte
-        continue
-      }
-      if last-was-rbracket {
-        // { ... }{ <--- ok, close the previous span
-        (result, current-fmt-span, current-fmt-name) = write-format-span(last-i, result, current-fmt-span, current-fmt-name)
-        last-was-rbracket = false
-      }
-      if current-fmt-span == none {
+      } else if current-fmt-span == none {
         // begin span
         current-fmt-span = (i, none)
         current-fmt-name = ""
+
+        // indicate we just started a span
+        // in case it is escaped right afterwards
+        last-was-lbracket = true
+      } else if last-was-fmt-colon and codepoints.len() > code-i + 1 and codepoints.at(code-i + 1) in ("<", "^", ">") {
+        // don't error on mid-span { if this { might be used for padding
+        // 'escape' it right away
+        // e.g. {a:{<5} => formats "bc" as "{{{bc"
+        current-fmt-name += character
+        last-was-lbracket = false
+      } else {
+        // if in the middle of a larger span ({ ... { <-):
+        // error
+        excessive-lbracket()
       }
-      last-was-lbracket = true
+
+      last-was-fmt-colon = false
     } else if character == "}" {
       last-was-lbracket = false
-      if last-was-rbracket {
-        last-was-rbracket = false  // escape }}
-        if current-fmt-name != none {
-          current-fmt-name += character
-        } else {
+      if current-fmt-span == none {
+        if last-was-rbracket {
+          last-was-rbracket = false  // escape }}
           result.push((escape: (escaped: "}", span: (last-i, i + 1))))
+        } else {
+          // delay erroring on unmatched } to the next iteration
+          // in case this is an escaped }
+          last-was-rbracket = true
         }
-
-        last-i = i
-        i += 1  // '}' is ASCII, so 1 byte
-        continue
+      } else if last-was-fmt-colon and codepoints.len() > code-i + 1 and codepoints.at(code-i + 1) in ("<", "^", ">") {
+        // don't close span with } if this } might be used for padding
+        // e.g. {a:}<5} => formats "bc" as "}}}bc"
+        current-fmt-name += character
+        last-was-rbracket = false
+      } else {
+        // { ... } <--- ok, close the previous span
+        // Do this eagerly, escaping } inside { ... } is invalid
+        (result, current-fmt-span, current-fmt-name) = write-format-span(i, result, current-fmt-span, current-fmt-name)
       }
-      // delay closing the span to the next iteration
-      // in case this is an escaped }
-      last-was-rbracket = true
+
+      last-was-fmt-colon = false
     } else {
-      // { ... {A  <--- non-escaped { inside larger {}
-      if last-was-lbracket and (current-fmt-span != none and current-fmt-span.at(0) != last-i) {
-        excessive-lbracket()
-      }
       if last-was-rbracket {
         if current-fmt-span == none {
           // {...} }A <--- non-escaped } with no matching {
           excessive-rbracket()
         } else {
-          // { ... }A <--- ok, close the previous span
-          (result, current-fmt-span, current-fmt-name) = write-format-span(last-i, result, current-fmt-span, current-fmt-name)
+          // { ... }A <--- span should have been eagerly closed already
+          panic("String formatter error: internal error: invalid right bracket state")
         }
       }
-      // {abc <--- add character to the format name
-      if current-fmt-name != none {
+
+      if current-fmt-name == none {
+        last-was-fmt-colon = false
+      } else {
+        // {abc <--- add character to the format name
         current-fmt-name += character
+        last-was-fmt-colon = character == ":"
       }
       last-was-lbracket = false
       last-was-rbracket = false
@@ -157,16 +201,21 @@
 
     last-i = i
     i += character.len() // index must be in bytes, and a UTF-8 codepoint can have more than one byte
+    code-i += 1
   }
   // { ...
   if current-fmt-span != none {
     if last-was-rbracket {
       // ... } <--- ok, close span
       (result, current-fmt-span, current-fmt-name) = write-format-span(last-i, result, current-fmt-span, current-fmt-name)
+      last-was-fmt-colon = false
     } else {
       // {abcd| <--- string ended with unclosed span
       missing-rbracket()
     }
+  } else if last-was-rbracket {
+    // } <--- unmatched and unescaped } at the very end
+    excessive-rbracket()
   }
 
   result
@@ -276,15 +325,7 @@
     // Normalize decimals with larger scales than is needed
     let fractional = fractional.sum(default: "").trim("0", at: end)
     let (integral, fractional, exponent) = if num > -1 and num < 1 and fractional != "" {
-      let first-non-zero = fractional.position("1")
-      if first-non-zero == none { first-non-zero = fractional.position("2") }
-      if first-non-zero == none { first-non-zero = fractional.position("3") }
-      if first-non-zero == none { first-non-zero = fractional.position("4") }
-      if first-non-zero == none { first-non-zero = fractional.position("5") }
-      if first-non-zero == none { first-non-zero = fractional.position("6") }
-      if first-non-zero == none { first-non-zero = fractional.position("7") }
-      if first-non-zero == none { first-non-zero = fractional.position("8") }
-      if first-non-zero == none { first-non-zero = fractional.position("9") }
+      let first-non-zero = fractional.codepoints().position(s => s != "0")
       assert(first-non-zero != none, message: "String formatter internal error: expected non-zero fractional digit")
 
       // Integral part is zero
@@ -362,7 +403,12 @@ parameter := argument '$'
       }
       let (integral, ..fractional) = string-replacement.split(".")
       if fmt-thousands-separator != "" and not is-nan and not is-inf {
-        integral = _arr-chunks(integral.codepoints().rev(), fmt-thousands-count)
+        let digit-groups = if type(fmt-thousands-count) == _arr-type {
+          _arr-dyn-chunks(integral.codepoints().rev(), fmt-thousands-count)
+        } else {
+          _arr-chunks(integral.codepoints().rev(), fmt-thousands-count)
+        }
+        integral = digit-groups
           .join(fmt-thousands-separator.codepoints().rev())
           .rev()
           .join()
@@ -554,7 +600,12 @@ parameter := argument '$'
 
     // Format with thousands AFTER zeroes, but BEFORE applying textual prefixes
     if fmt-thousands-separator != "" and not is-nan and not is-inf {
-      integral = _arr-chunks(integral.codepoints().rev(), fmt-thousands-count)
+      let digit-groups = if type(fmt-thousands-count) == _arr-type {
+        _arr-dyn-chunks(integral.codepoints().rev(), fmt-thousands-count)
+      } else {
+        _arr-chunks(integral.codepoints().rev(), fmt-thousands-count)
+      }
+      integral = digit-groups
         .join(fmt-thousands-separator.codepoints().rev())
         .rev()
         .join()
@@ -594,8 +645,10 @@ parameter := argument '$'
       } else if align == right {
         replacement = (fill * width-diff) + replacement
       } else if align == center {
-        let width-fill = fill * (calc.ceil(float(width-diff) / 2))
-        replacement = width-fill + replacement + width-fill
+        let half-width = calc.quo(width-diff, 2)
+        let left-fill = fill * half-width // floor div
+        let right-fill = fill * (half-width + calc.rem(width-diff, 2)) // ceil div (if adding odd fill, add 1 to the right)
+        replacement = left-fill + replacement + right-fill
       }
     }
   }
@@ -623,17 +676,23 @@ parameter := argument '$'
     )
   }
 
-  if type(fmt-thousands-count) != _int-type {
+  if type(fmt-thousands-count) == _arr-type {
     assert(
-      false,
-      message: "String formatter error: 'fmt-thousands-count' must be an integer, got '" + str(type(fmt-thousands-count)) + "' instead."
+      fmt-thousands-count.all(c => type(c) == _int-type and c > 0),
+      message: "String formatter error: 'fmt-thousands-count' must be a positive integer or array of positive integers, got an array with at least one element that isn't a positive integer."
     )
-  }
-
-  if fmt-thousands-count <= 0 {
+    assert(fmt-thousands-count != (), message: "String formatter error: 'fmt-thousands-count' must not be an empty array, but an array of positive integers.")
+  } else if type(fmt-thousands-count) == _int-type {
+    if fmt-thousands-count <= 0 {
+      assert(
+        false,
+        message: "String formatter error: 'fmt-thousands-count' must be a positive integer, got " + str(fmt-thousands-count) + " instead."
+      )
+    }
+  } else {
     assert(
       false,
-      message: "String formatter error: 'fmt-thousands-count' must be a positive integer, got " + str(fmt-thousands-count) + " instead."
+      message: "String formatter error: 'fmt-thousands-count' must be a positive integer or array of positive integers, got '" + str(type(fmt-thousands-count)) + "' instead."
     )
   }
 
diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index 25c5114..d83ba22 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -1,4 +1,5 @@
-#import "../oxifmt.typ": strfmt, using-0120
+#import "../lib.typ": strfmt
+#import "../oxifmt.typ": using-0120
 
 #{
   // test basics (sequential args, named args, pos args)
@@ -11,10 +12,12 @@
   assert.eq(strfmt("a{{}}b ={}{}= c{0}d", false, (a: "55", b: 20.3)), "a{}b =false(a: \"55\", b: 20.3)= cfalsed")
 
   // test escaping {{ }} from inside { } formats
-  assert.eq(strfmt("a{b{{b}}b}", ..("b{b}b": 5)), "a5")
+  // (this is now invalid and should error)
+  // assert.eq(strfmt("a{b{{b}}b}", ..("b{b}b": 5)), "a5")
+  // assert.eq(strfmt("a{b}}b}", ..("b}b": 5)), "a5")
 
   // test 0 prefix with numbers, but also using 0 as a non-numeric affix
-  assert.eq(strfmt("{:08}|{0:0<8}|{0:0>8}|{0:0^8}", 120), "00000120|12000000|00000120|000120000")
+  assert.eq(strfmt("{:08}|{0:0<8}|{0:0>8}|{0:0^8}", 120), "00000120|12000000|00000120|00120000")
 
   // test other kinds of affixes / fills and alignments
   assert.eq(strfmt("{:a>8}, {:^20.10}, {:+05.4}, {:07}, {other:06?}", "b", 5.5, 11, -4, other: -30.0), "aaaaaaab,     5.5000000000    , +0011, -000004, -030.0")
@@ -103,9 +106,27 @@
   assert.eq(strfmt("{:#b}", 255, fmt-thousands-count: 1, fmt-thousands-separator: "_"), "0b1_1_1_1_1_1_1_1")
   assert.eq(strfmt("{:#x}", -16 * 16 * 16 * 16 * 15, fmt-thousands-count: 2, fmt-thousands-separator: "_"), "-0xf_00_00")
   assert.eq(strfmt("{:o}", -16 * 16 * 16 * 16 * 15, fmt-thousands-count: 4, fmt-thousands-separator: "_"), "-360_0000")
-  assert.eq(strfmt("{:05}", float("nan"), fmt-thousands-count: 2, fmt-thousands-separator: "_"), "00NaN")
-  assert.eq(strfmt("{:05}", float("inf"), fmt-thousands-count: 2, fmt-thousands-separator: "_"), "00inf")
-  assert.eq(strfmt("{:05}", -float("inf"), fmt-thousands-count: 2, fmt-thousands-separator: "_"), "-0inf")
+  assert.eq(strfmt("{:08}", float("nan"), fmt-thousands-count: 2, fmt-thousands-separator: "_"), "00000NaN")
+  assert.eq(strfmt("{:08}", float("inf"), fmt-thousands-count: 2, fmt-thousands-separator: "_"), "00000inf")
+  assert.eq(strfmt("{:08}", -float("inf"), fmt-thousands-count: 2, fmt-thousands-separator: "_"), "-0000inf")
+
+  // Issue #21: variable group sizes
+  assert.eq(strfmt("{}", 10, fmt-thousands-count: (3, 2), fmt-thousands-separator: "_"), "10")
+  assert.eq(strfmt("{}", 1000000, fmt-thousands-count: (3, 2), fmt-thousands-separator: ","), "10,00,000")
+  assert.eq(strfmt("{}", 1000000, fmt-thousands-count: (3, 2, 2, 2, 2, 2, 2, 2), fmt-thousands-separator: ","), "10,00,000")
+  assert.eq(strfmt("{}", 10000000000, fmt-thousands-count: (3, 2), fmt-thousands-separator: ","), "10,00,00,00,000")
+  assert.eq(strfmt("{}", 10000000000, fmt-thousands-count: (1, 2, 3), fmt-thousands-separator: ","), "10,000,000,00,0")
+  assert.eq(strfmt("{}", 10000000.3231, fmt-thousands-count: (1, 2, 3), fmt-thousands-separator: "_"), "10_000_00_0.3231")
+  assert.eq(strfmt("{}", float("nan"), fmt-thousands-count: (1, 2, 3), fmt-thousands-separator: "_"), "NaN")
+  assert.eq(strfmt("{}", float("inf"), fmt-thousands-count: (1, 2, 3), fmt-thousands-separator: "_"), "inf")
+  assert.eq(strfmt("{}", -float("inf"), fmt-thousands-count: (1, 2, 3), fmt-thousands-separator: "_"), "-inf")
+  assert.eq(strfmt("{:014}", -23003, fmt-thousands-count: (4, 4, 2), fmt-thousands-separator: "|"), "-0|00|00|0002|3003")
+  assert.eq(strfmt("{:#b}", 255, fmt-thousands-count: (1, 2, 1, 2, 1), fmt-thousands-separator: "_"), "0b1_1_11_1_11_1")
+  assert.eq(strfmt("{:#x}", -16 * 16 * 16 * 16 * 15, fmt-thousands-count: (3, 2), fmt-thousands-separator: "_"), "-0xf0_000")
+  assert.eq(strfmt("{:o}", -16 * 16 * 16 * 16 * 15, fmt-thousands-count: (4, 2, 1), fmt-thousands-separator: "_"), "-3_60_0000")
+  assert.eq(strfmt("{:08}", float("nan"), fmt-thousands-count: (2, 3), fmt-thousands-separator: "_"), "00000NaN")
+  assert.eq(strfmt("{:08}", float("inf"), fmt-thousands-count: (2, 3), fmt-thousands-separator: "_"), "00000inf")
+  assert.eq(strfmt("{:08}", -float("inf"), fmt-thousands-count: (2, 3), fmt-thousands-separator: "_"), "-0000inf")
 }
 // Issue #11: Decimals
 #if using-0120 {
@@ -132,6 +153,9 @@
   assert.eq(strfmt("{:e}", decimal("132423")), "1.32423e5")
   assert.eq(strfmt("{:e}", decimal("-132423")), "-1.32423e5")
   assert.eq(strfmt("{:011.5}", decimal("1234.5")), "01234.50000")
+
+  // Issue #23: decimal exponential
+  assert.eq(strfmt("{:e}", decimal("0.31")), "3.1e-1")
 }
 // Issue #16: large numbers
 #{
@@ -150,6 +174,36 @@
   assert.eq(strfmt("{0:e}",1.7976931348623157e+308), "1.7976931348623146e308")
   assert.eq(strfmt("{0:e}",-1.7976931348623157e+308), "-1.7976931348623146e308")
 }
+// Issue #17: should not escape bracket in format var name
+#{
+  assert.eq(strfmt("{{{}}}", 1), "{1}")
+  assert.eq(strfmt("{{"), "{")
+  assert.eq(strfmt("}}"), "}")
+
+  // Issue #28: pad with {} inside :
+  assert.eq(strfmt("{:}>4}", "a"), "}}}a")
+  assert.eq(strfmt("{:}^4}", "a"), "}a}}")
+  assert.eq(strfmt("{:}<4}", "a"), "a}}}")
+  assert.eq(strfmt("{:{>4}", "a"), "{{{a")
+  assert.eq(strfmt("{:{^4}", "a"), "{a{{")
+  assert.eq(strfmt("{:{<4}", "a"), "a{{{")
+  assert.eq(strfmt("{:{^}", "a"), "a")
+  assert.eq(strfmt("{:}^}", "a"), "a")
+  assert.eq(strfmt("{:}}}", "a"), "a}")
+}
+// Issue #29: center alignment
+#{
+  assert.eq(strfmt("{:}^1}", "a"), "a")
+  assert.eq(strfmt("{:}^2}", "a"), "a}")
+  assert.eq(strfmt("{:}^3}", "a"), "}a}")
+  assert.eq(strfmt("{:}^4}", "a"), "}a}}")
+  assert.eq(strfmt("{:}^5}", "a"), "}}a}}")
+
+  assert.eq(strfmt("{:}>4}", "a"), "}}}a")
+  assert.eq(strfmt("{:}<4}", "a"), "a}}}")
+  assert.eq(strfmt("{:}>5}", "a"), "}}}}a")
+  assert.eq(strfmt("{:}<5}", "a"), "a}}}}")
+}
 // DOC TESTS
 #{
   // --- Quick examples ---
@@ -166,10 +220,10 @@
       strfmt("if {var} > {num} {{ true }}", var: "exp", num: 100)
     )
 
-    // "1.10e2 meters"
+    // "1.10e2 meters (**wow**)"
     assert.eq(
-      "1.10e2 meters",
-      strfmt("{:.2e} meters", 110.0)
+      "1.10e2 meters (**wow**)",
+      strfmt("{:.2e} meters ({:*^7})", 110.0, "wow")
     )
 
     // "20_000 players have more than +002,3 points."
@@ -221,7 +275,7 @@
   }
   {
     let s = strfmt("Left5 {:_<5}, Right6 {:*>6}, Center10 {centered: ^10?}, Left3 {tleft:_<3}", "xx", 539, tleft: "okay", centered: [a])
-    assert.eq(s, "Left5 xx___, Right6 ***539, Center10     [a]    , Left3 okay")
+    assert.eq(s, "Left5 xx___, Right6 ***539, Center10    [a]    , Left3 okay")
   }
   {
     let s = strfmt("Left-padded7 numbers: {:07} {:07} {:07} {3:07}", 123, -344, 44224059, 45.32)
@@ -256,4 +310,8 @@
     let s = strfmt("{}", 20000, fmt-thousands-count: 2, fmt-thousands-separator: "_")
     assert.eq(s, "2_00_00")
   }
+  {
+    let s = strfmt("{}", 1000000, fmt-thousands-count: (3, 2), fmt-thousands-separator: ",")
+    assert.eq(s, "10,00,000")
+  }
 }
diff --git a/typst.toml b/typst.toml
index 0174763..a1785e3 100644
--- a/typst.toml
+++ b/typst.toml
@@ -1,8 +1,8 @@
 [package]
 name = "oxifmt"
-version = "0.3.0"
+version = "1.0.0"
 authors = ["PgBiel <https://github.com/PgBiel>"]
 license = "MIT OR Apache-2.0"
 description = "Convenient Rust-like string formatting in Typst"
-entrypoint = "oxifmt.typ"
+entrypoint = "lib.typ"
 repository = "https://github.com/PgBiel/typst-oxifmt"