From 68888bfc4ff93ed4d64e4fb4390c162aa697038c Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 1 Aug 2023 23:55:36 -0300
Subject: [PATCH 01/60] fix negative numbers with two minus signs

---
 tests/strfmt-tests.typ | 2 +-
 typst-strfmt.typ       | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index 1700cde..dcf6d9d 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -17,7 +17,7 @@
     assert.eq(strfmt("{:08}|{0:0<8}|{0:0>8}|{0:0^8}", 120), "00000120|12000000|00000120|000120000")
 
     // test other kinds of affixes / fills and alignments
-    assert.eq(strfmt("{:a>8}, {:^20.10}, {:+05.4}, {}", "b", 5.5, 11, -4), "aaaaaaab,     5.5000000000    , +0011, -4")
+    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")
 
     // test base conversion (I)
     assert.eq(strfmt("{:b}, {0:05b}, {:#010b}, {:05x}, {:05X}, {:+#05X}, {2:x?}, {3:X?}", 5, 5, 27, 27, 27), "101, 00101, 0b00000101, 0001b, 0001B, +0x1B, 1b, 1B")
diff --git a/typst-strfmt.typ b/typst-strfmt.typ
index d4c0c72..ffb5123 100644
--- a/typst-strfmt.typ
+++ b/typst-strfmt.typ
@@ -1,3 +1,4 @@
+// typst-strfmt v0.1.1 (WIP)
 #let _strfmt_formatparser(s) = {
   if type(s) != "string" {
     panic("String format parsing internal error: String format parser given non-string.")
@@ -336,6 +337,9 @@ parameter := argument '$'
       sign = ""
     }
 
+    // we'll add the sign back later!
+    replacement = calc.abs(replacement)
+
     if spectype in ("e", "E") {
       let exponent-sign = if spectype == "E" { "E" } else { "e" }
       replacement = _strfmt_exp-format(calc.abs(replacement), exponent-sign: exponent-sign, precision: precision)

From 69b70174c03a32ff9fc80a22c4b22557c1fc6b14 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 2 Aug 2023 01:19:18 -0300
Subject: [PATCH 02/60] fix precision on floats which are exact integers

---
 tests/strfmt-tests.typ |  3 +++
 typst-strfmt.typ       | 17 +++++++++++++----
 2 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index dcf6d9d..9811a43 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -34,6 +34,9 @@
     // test taking width and precision from pos args / named args (.x$ / y$ notation)
     assert.eq(strfmt("{:.1$}; {woah:0france$.moment$}; {}; {2:a>1$}", 5.5399234, 9, "stringy", woah: 3.9, france: 7, moment: 2), "5.539923400; 0003.90; 9; aastringy")
 
+    // test weird precision cases
+    assert.eq(strfmt("{0:e} {0:+.9E} | {1:.3e} {1:.3} {2:.3} | {3:.4} {3:.4E} | {4:.2} {4:.3} {4:.5}", 124.2312, 50, 50.0, -0.02, 2.44454), "1.242312e2 +1.242312000E2 | 5.000e1 50 50.000 | -0.0200 -2.0000E-2 | 2.44 2.445 2.44454")
+
     // test custom decimal separators (I)
     assert.eq(strfmt("{}; {:07e}; {}; {}; {:?}", 1.532, 45000, -5.6, "a.b", "c.d", fmt-decimal-separator: ","), "1,532; 004,5e4; -5,6; a.b; \"c.d\"")
 
diff --git a/typst-strfmt.typ b/typst-strfmt.typ
index ffb5123..94737f8 100644
--- a/typst-strfmt.typ
+++ b/typst-strfmt.typ
@@ -180,13 +180,22 @@
   }
   let result = _strfmt_stringify(calc.round(float(num), digits: calc.min(50, precision)))
   let digits-match = result.match(regex("^\\d+\\.(\\d+)$"))
+  let digits-len-diff = 0
   if digits-match != none and digits-match.captures.len() > 0 {
+    // get the digits capture group; its length will be digit amount
     let digits = digits-match.captures.first()
-    let digits-len-diff = precision - digits.len()
-    // add missing zeroes for precision
-    if digits-len-diff > 0 {
-      result += "0" * digits-len-diff
+    digits-len-diff = precision - digits.len()
+  } else if "." not in result {  // 5.0 or something
+    // 0 digits! Difference will be exactly 'precision'
+    digits-len-diff = precision
+  }
+
+  // add missing zeroes for precision
+  if digits-len-diff > 0 {
+    if "." not in result {
+      result += "."  // decimal separator missing
     }
+    result += "0" * digits-len-diff
   }
 
   result

From 2edd1de5cbd165fcb066fe3aadf117d5a460471a Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 18 Jul 2023 23:30:25 -0300
Subject: [PATCH 03/60] organize README

---
 README.md | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index fc0885b..b8b9a04 100644
--- a/README.md
+++ b/README.md
@@ -6,6 +6,13 @@ I intend to add a few extras over time, though. The first "extra" I've added so
 
 **Compatible with:** [Typst](https://github.com/typst/typst) v0.4.0
 
+## Table of Contents
+
+- [Usage](#usage)
+- [Grammar](#grammar)
+- [Changelog](#changelog)
+- [License](#license)
+
 ## Usage
 
 Download the `typst-strfmt.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):
@@ -14,7 +21,7 @@ Download the `typst-strfmt.typ` file either from Releases or directly from the r
 #import "typst-strfmt.typ": strfmt
 ```
 
-That will give you access to the main function provided by this library (`strfmt`), which accepts a format string, followed by zero or more replacements to insert in that string (according to `{...}` formats inserted in that string), an optional `fmt-decimal-separator` parameter, and returns the formatted string, as described below.
+Doing the above will give you access to the main function provided by this library (`strfmt`), which accepts a format string, followed by zero or more replacements to insert in that string (according to `{...}` formats inserted in that string), an optional `fmt-decimal-separator` parameter, and returns the formatted string, as described below.
 
 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`):
 
@@ -83,3 +90,7 @@ Note, however, that precision of type `.*` is not supported yet and will raise a
 ### v0.1.0
 
 - Initial release, added `strfmt`.
+
+## License
+
+MIT license (see the `LICENSE` file).

From 3132ad8c95f2a48bc936e57b395c62432ac93196 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 18 Jul 2023 23:46:25 -0300
Subject: [PATCH 04/60] add more versions and testing to README

---
 README.md | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index b8b9a04..bb8a35f 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@ A Typst library that brings convenient string formatting and interpolation throu
 
 I intend to add a few extras over time, though. The first "extra" I've added so far is the `fmt-decimal-separator: "string"` parameter, which lets you customize the decimal separator for decimal numbers (floats) inserted into strings. E.g. `strfmt("Result: {}", 5.8, fmt-decimal-separator: ",")` will return the string `"Result: 5,8"` (comma instead of dot). See more below.
 
-**Compatible with:** [Typst](https://github.com/typst/typst) v0.4.0
+**Compatible with:** [Typst](https://github.com/typst/typst) v0.4.0, v0.5.0, v0.6.0
 
 ## Table of Contents
 
@@ -85,6 +85,14 @@ parameter := argument '$'
 
 Note, however, that precision of type `.*` is not supported yet and will raise an error.
 
+## Testing
+
+Test with the following command (from the project root folder):
+
+```sh
+cd tests && typst c strfmt-tests.typ
+```
+
 ## Changelog
 
 ### v0.1.0

From a36acec61e41a39226f866530b5aa3b1d5b103d3 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 18 Jul 2023 23:47:01 -0300
Subject: [PATCH 05/60] fix testing command

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index bb8a35f..a14c1f9 100644
--- a/README.md
+++ b/README.md
@@ -90,7 +90,7 @@ Note, however, that precision of type `.*` is not supported yet and will raise a
 Test with the following command (from the project root folder):
 
 ```sh
-cd tests && typst c strfmt-tests.typ
+cd tests && typst c strfmt-tests.typ --root ..
 ```
 
 ## Changelog

From 17dbdfb281da66b737b51d302088d15f47e59cb7 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 18 Jul 2023 23:51:18 -0300
Subject: [PATCH 06/60] improve testing docs wording

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index a14c1f9..f32188c 100644
--- a/README.md
+++ b/README.md
@@ -87,7 +87,7 @@ Note, however, that precision of type `.*` is not supported yet and will raise a
 
 ## Testing
 
-Test with the following command (from the project root folder):
+If you wish to contribute, you may test this package with the following command (from the project root folder):
 
 ```sh
 cd tests && typst c strfmt-tests.typ --root ..

From c6d110a072b7146bab9603390ecba0f22ad04870 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 19 Jul 2023 00:04:07 -0300
Subject: [PATCH 07/60] add typst.toml

---
 typst.toml | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 typst.toml

diff --git a/typst.toml b/typst.toml
new file mode 100644
index 0000000..9cb1239
--- /dev/null
+++ b/typst.toml
@@ -0,0 +1,8 @@
+[package]
+name = "strfmt"
+version = "0.1.0"
+authors = ["PgBiel <https://github.com/PgBiel>"]
+license = "MIT"
+description = "Convenient Rust-like string formatting in Typst"
+entrypoint = "typst-strfmt.typ"
+repository = "https://github.com/PgBiel/typst-strfmt"

From ba51dec1d1d4fc425d6967fc0bf91704c00c9ebe Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 1 Aug 2023 13:17:45 -0300
Subject: [PATCH 08/60] rename to oxifmt

---
 .gitignore                           | 2 +-
 README.md                            | 6 +++---
 tests/strfmt-tests.typ               | 2 +-
 typst-strfmt.typ => typst-oxifmt.typ | 0
 typst.toml                           | 6 +++---
 5 files changed, 8 insertions(+), 8 deletions(-)
 rename typst-strfmt.typ => typst-oxifmt.typ (100%)

diff --git a/.gitignore b/.gitignore
index 59808ce..51b3b14 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,2 @@
-typst-strfmt.pdf
+typst-oxifmt.pdf
 strfmt-tests.pdf
diff --git a/README.md b/README.md
index f32188c..26975e7 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# typst-strfmt (v0.1.0)
+# typst-oxifmt (v0.1.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 read its page for more information (https://doc.rust-lang.org/std/fmt/). Only a few things aren't supported from the Rust syntax, such as the `p` (pointer) format type, or the `.*` precision specifier.
 
@@ -15,10 +15,10 @@ I intend to add a few extras over time, though. The first "extra" I've added so
 
 ## Usage
 
-Download the `typst-strfmt.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):
+Download the `typst-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):
 
 ```js
-#import "typst-strfmt.typ": strfmt
+#import "typst-oxifmt.typ": strfmt
 ```
 
 Doing the above will give you access to the main function provided by this library (`strfmt`), which accepts a format string, followed by zero or more replacements to insert in that string (according to `{...}` formats inserted in that string), an optional `fmt-decimal-separator` parameter, and returns the formatted string, as described below.
diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index 9811a43..5b678c5 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -1,4 +1,4 @@
-#import "../typst-strfmt.typ": strfmt
+#import "../typst-oxifmt.typ": strfmt
 
 #{
     // test basics (sequential args, named args, pos args)
diff --git a/typst-strfmt.typ b/typst-oxifmt.typ
similarity index 100%
rename from typst-strfmt.typ
rename to typst-oxifmt.typ
diff --git a/typst.toml b/typst.toml
index 9cb1239..9983cfb 100644
--- a/typst.toml
+++ b/typst.toml
@@ -1,8 +1,8 @@
 [package]
-name = "strfmt"
+name = "oxifmt"
 version = "0.1.0"
 authors = ["PgBiel <https://github.com/PgBiel>"]
 license = "MIT"
 description = "Convenient Rust-like string formatting in Typst"
-entrypoint = "typst-strfmt.typ"
-repository = "https://github.com/PgBiel/typst-strfmt"
+entrypoint = "typst-oxifmt.typ"
+repository = "https://github.com/PgBiel/typst-oxifmt"

From fdd334f1395d9c51748530a97e61edfaddb17e8b Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 1 Aug 2023 13:22:00 -0300
Subject: [PATCH 09/60] MIT-0 license

---
 LICENSE    | 29 ++++++++++++-----------------
 README.md  |  2 +-
 typst.toml |  2 +-
 3 files changed, 14 insertions(+), 19 deletions(-)

diff --git a/LICENSE b/LICENSE
index 762c85e..a9cb23f 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,21 +1,16 @@
-MIT License
+MIT No Attribution
 
 Copyright (c) 2023 Pg Biel
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify,
+merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so.
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/README.md b/README.md
index 26975e7..8525205 100644
--- a/README.md
+++ b/README.md
@@ -101,4 +101,4 @@ cd tests && typst c strfmt-tests.typ --root ..
 
 ## License
 
-MIT license (see the `LICENSE` file).
+MIT-0 license (see the `LICENSE` file).
diff --git a/typst.toml b/typst.toml
index 9983cfb..4ae8b03 100644
--- a/typst.toml
+++ b/typst.toml
@@ -2,7 +2,7 @@
 name = "oxifmt"
 version = "0.1.0"
 authors = ["PgBiel <https://github.com/PgBiel>"]
-license = "MIT"
+license = "MIT-0"
 description = "Convenient Rust-like string formatting in Typst"
 entrypoint = "typst-oxifmt.typ"
 repository = "https://github.com/PgBiel/typst-oxifmt"

From dccdec4d0233a9a4cb6ec6d34ce9239b061cbfb0 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 1 Aug 2023 13:47:56 -0300
Subject: [PATCH 10/60] add repository references to readme

---
 README.md | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 8525205..9cbba71 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 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 read its page for more information (https://doc.rust-lang.org/std/fmt/). Only a few things aren't supported from the Rust syntax, such as the `p` (pointer) format type, or the `.*` precision specifier.
 
-I intend to add a few extras over time, though. The first "extra" I've added so far is the `fmt-decimal-separator: "string"` parameter, which lets you customize the decimal separator for decimal numbers (floats) inserted into strings. E.g. `strfmt("Result: {}", 5.8, fmt-decimal-separator: ",")` will return the string `"Result: 5,8"` (comma instead of dot). See more below.
+A few extras (beyond the Rust-like syntax) will be added over time, though (feel free to drop suggestions at the repository: https://github.com/PgBiel/typst-oxifmt). The first "extra" so far is the `fmt-decimal-separator: "string"` parameter, which lets you customize the decimal separator for decimal numbers (floats) inserted into strings. E.g. `strfmt("Result: {}", 5.8, fmt-decimal-separator: ",")` will return the string `"Result: 5,8"` (comma instead of dot). See more below.
 
 **Compatible with:** [Typst](https://github.com/typst/typst) v0.4.0, v0.5.0, v0.6.0
 
@@ -10,6 +10,8 @@ I intend to add a few extras over time, though. The first "extra" I've added so
 
 - [Usage](#usage)
 - [Grammar](#grammar)
+- [Issues and Contributing](#issues-and-contributing)
+- [Testing](#testing)
 - [Changelog](#changelog)
 - [License](#license)
 
@@ -85,6 +87,10 @@ parameter := argument '$'
 
 Note, however, that precision of type `.*` is not supported yet and will raise an error.
 
+## Issues and Contributing
+
+Please report any issues or send any contributions (through pull requests) to the repository at https://github.com/PgBiel/typst-oxifmt
+
 ## Testing
 
 If you wish to contribute, you may test this package with the following command (from the project root folder):

From ebc1748e32134039a6699c9f6a61e1aa4e8788d9 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 2 Aug 2023 00:53:36 -0300
Subject: [PATCH 11/60] add examples section to README

---
 README.md | 108 ++++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 105 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 9cbba71..748c810 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,9 @@ A few extras (beyond the Rust-like syntax) will be added over time, though (feel
 ## Table of Contents
 
 - [Usage](#usage)
-- [Grammar](#grammar)
+    - [Formatting options](#formatting-options)
+    - [Examples](#examples)
+    - [Grammar](#grammar)
 - [Issues and Contributing](#issues-and-contributing)
 - [Testing](#testing)
 - [Changelog](#changelog)
@@ -28,13 +30,19 @@ 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`):
 
 ```js
+#import "typst-oxifmt.typ": 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}.")
 ```
 
 Note that `{}` extracts positional arguments after the string sequentially (the first `{}` extracts the first one, the second `{}` extracts the second one, and so on), while `{0}`, `{1}`, etc. will always extract the first, the second etc. positional arguments after the string. Additionally, `{bananas}` will extract the named argument "bananas".
 
-You can use `{:spec}` to customize your output. See the Rust docs linked above for more info, but here's a summary:
+### Formatting options
+
+You can use `{:spec}` to customize your output. See the Rust docs linked above for more info, but a summary is below.
+
+(You may also want to check out the examples at [Examples](#examples).)
 
 - Adding a `?` at the end of `spec` (that is, writing e.g. `{0:?}`) will call `repr()` to stringify your argument, instead of `str()`. Note that this only has an effect if your argument is a string, an integer, a float or a `label()` / `<label>` - for all other types (such as booleans or elements), `repr()` is always called (as `str()` is unsupported for those).
     - 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`.
@@ -59,6 +67,8 @@ You can use `{:spec}` to customize your output. See the Rust docs linked above f
 Some examples:
 
 ```js
+#import "typst-oxifmt.typ": strfmt
+
 #let s1 = strfmt("{0:?}, {test:+012e}, {1:-<#8x}", "hi", -74, test: 569.4)
 #assert.eq(s1, "\"hi\", +00005.694e2, -0x4a---")
 
@@ -69,7 +79,99 @@ Some examples:
 #assert.eq(s3, "Dict: (a: 5)!!!!")
 ```
 
-## Grammar
+### Examples
+
+- **Inserting labels, text and numbers into strings:**
+```js
+#import "typst-oxifmt.typ": 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})")
+```
+
+- **Forcing `repr()` with `{:?}`** (which adds quotes around strings, and other things - basically represents a Typst value):
+```js
+#import "typst-oxifmt.typ": 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>")
+```
+
+- **Inserting other types than numbers and strings** (for now, they will always use `repr()`, even without `{...:?}`, although that is more explicit):
+```js
+#import "typst-oxifmt.typ": strfmt
+
+#let s = strfmt("Values: {:?}, {1:?}, {stuff:?}", (test: 500), ("a", 5.1), stuff: [a])
+#assert.eq(s, "Values: (test: 500), (\"a\", 5.1), [a]")
+```
+
+- **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 (can be `<` for left aligned (padding goes to the right), `>` for right aligned (padded to its left) and `^` for center aligned (padded both left and right)):
+```js
+#import "typst-oxifmt.typ": 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")
+// 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 just 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):
+```js
+#import "typst-oxifmt.typ": 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")
+```
+
+- **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):
+```js
+#import "typst-oxifmt.typ": 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
+```
+
+- **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:
+```js
+#import "typst-oxifmt.typ": 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")
+
+```
+
+- **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` (base 2), `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):
+```js
+#import "typst-oxifmt.typ": 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")
+```
+
+- **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`):
+```js
+#import "typst-oxifmt.typ": 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")
+```
+
+- **Scientific notation:** Use `e` (lowercase) or `E` (uppercase) as specifier types (can be combined with precision):
+```js
+#import "typst-oxifmt.typ": strfmt
+
+#let s = strfmt("{0:e} {0:E} {0:+.9e} | {1:e} | {2:E}", 124.2312, 50, -0.02)
+#assert.eq(s, "1.242312e2 1.242312E2 +1.242312000e2 | 5e1 | -2E-2")
+```
+
+- **Customizing the decimal separator on floats:** Just specify `fmt-decimal-separator: ","` (comma as an example):
+```js
+#import "typst-oxifmt.typ": strfmt
+
+#let s = strfmt("{0} {0:.6} {0:.5e}", 1.432, fmt-decimal-separator: ",")
+#assert.eq(s, "1,432 1,432000 1,43200e0")
+```
+
+### Grammar
 
 Here's the grammar specification for valid format `spec`s (in `{name:spec}`), which is basically Rust's format:
 

From ff46c74ceb28062a2bca821d94afb69ce23a028c Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 2 Aug 2023 00:53:52 -0300
Subject: [PATCH 12/60] add docs examples to tests

---
 tests/strfmt-tests.typ | 60 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)

diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index 5b678c5..dd872bc 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -46,3 +46,63 @@
     // test custom decimal separators (III) - ensure we can fetch it from inside
     assert.eq(strfmt("5{fmt-decimal-separator}6", fmt-decimal-separator: "|"), "5|6")
 }
+// DOC TESTS
+#{
+    // --- Usage ---
+    {
+        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}.")
+    }
+    // --- Formatting options ---
+    {
+        let s1 = strfmt("{0:?}, {test:+012e}, {1:-<#8x}", "hi", -74, test: 569.4)
+        assert.eq(s1, "\"hi\", +00005.694e2, -0x4a---")
+
+        let s2 = strfmt("{:_>+11.5}", 59.4)
+        assert.eq(s2, "__+59.40000")
+
+        let s3 = strfmt("Dict: {:!<10?}", (a: 5))
+        assert.eq(s3, "Dict: (a: 5)!!!!")
+    }
+    // --- Examples ---
+    {
+        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})")
+    }
+    {
+        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>")
+    }
+    {
+        let s = strfmt("Values: {:?}, {1:?}, {stuff:?}", (test: 500), ("a", 5.1), stuff: [a])
+        assert.eq(s, "Values: (test: 500), (\"a\", 5.1), [a]")
+    }
+    {
+        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")
+    }
+    {
+        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")
+    }
+    {
+        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")
+    }
+    {
+        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")
+    }
+    {
+        let s = strfmt("{0:.8} {0:.2$} {0:.potato$}", 1.234, 0, 2, potato: 5)
+        assert.eq(s, "1.23400000 1.23 1.23400")
+    }
+    {
+        let s = strfmt("{0:e} {0:E} {0:+.9e} | {1:e} | {2:E}", 124.2312, 50, -0.02)
+        assert.eq(s, "1.242312e2 1.242312E2 +1.242312000e2 | 5e1 | -2E-2")
+    }
+    {
+        let s = strfmt("{0} {0:.6} {0:.5e}", 1.432, fmt-decimal-separator: ",")
+        assert.eq(s, "1,432 1,432000 1,43200e0")
+    }
+}

From 17ab698133b26766f08cb39eeab8528220626318 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 2 Aug 2023 00:55:33 -0300
Subject: [PATCH 13/60] rename references to oxifmt in code

---
 typst-oxifmt.typ | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/typst-oxifmt.typ b/typst-oxifmt.typ
index 94737f8..96d7607 100644
--- a/typst-oxifmt.typ
+++ b/typst-oxifmt.typ
@@ -1,4 +1,4 @@
-// typst-strfmt v0.1.1 (WIP)
+// typst-oxifmt v0.1.1 (WIP)
 #let _strfmt_formatparser(s) = {
   if type(s) != "string" {
     panic("String format parsing internal error: String format parser given non-string.")
@@ -317,7 +317,7 @@ parameter := argument '$'
   let valid-specs = ("", "?", "b", "x", "X", "o", "x?", "X?", "e", "E")
   let spec-error() = {
     panic(
-      "String formatter error: Unknown spec type '" + spectype + "', from '{" + fullname.replace("{", "{{").replace("}", "}}") + "}'. Valid options include: '" + valid-specs.join("', '") + "'. Maybe you specified some invalid formatting spec syntax (after the ':'), which can also prompt this error. Check the typst-strfmt docs for more information.")
+      "String formatter error: Unknown spec type '" + spectype + "', from '{" + fullname.replace("{", "{{").replace("}", "}}") + "}'. Valid options include: '" + valid-specs.join("', '") + "'. Maybe you specified some invalid formatting spec syntax (after the ':'), which can also prompt this error. Check the typst-oxifmt docs for more information.")
   }
   if spectype not in valid-specs {
     spec-error()

From cfb8a59f8c7ae0c89435fff522ef5a923231d3fb Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 2 Aug 2023 00:57:25 -0300
Subject: [PATCH 14/60] convert test indentation to 2 spaces instead of 4

---
 tests/strfmt-tests.typ | 174 ++++++++++++++++++++---------------------
 1 file changed, 87 insertions(+), 87 deletions(-)

diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index dd872bc..996ca5b 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -1,108 +1,108 @@
 #import "../typst-oxifmt.typ": strfmt
 
 #{
-    // test basics (sequential args, named args, pos args)
-    assert.eq(strfmt("a {} b {} c {named} {0} {1}", 10, "tests", named: -24), "a 10 b tests c -24 10 tests")
+  // test basics (sequential args, named args, pos args)
+  assert.eq(strfmt("a {} b {} c {named} {0} {1}", 10, "tests", named: -24), "a 10 b tests c -24 10 tests")
 
-    // test {:?} (force usage of repr())
-    assert.eq(strfmt("a {} c {} d {:?}", true, "testA", "testA"), "a true c testA d \"testA\"")
+  // test {:?} (force usage of repr())
+  assert.eq(strfmt("a {} c {} d {:?}", true, "testA", "testA"), "a true c testA d \"testA\"")
 
-    // test escaping {{ }}, plus repr() on bools and dicts (and anything that can't be str()'ed)
-    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 {{ }}, plus repr() on bools and dicts (and anything that can't be str()'ed)
+  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")
+  // test escaping {{ }} from inside { } formats
+  assert.eq(strfmt("a{b{{b}}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")
+  // 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")
 
-    // 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")
+  // 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")
 
-    // test base conversion (I)
-    assert.eq(strfmt("{:b}, {0:05b}, {:#010b}, {:05x}, {:05X}, {:+#05X}, {2:x?}, {3:X?}", 5, 5, 27, 27, 27), "101, 00101, 0b00000101, 0001b, 0001B, +0x1B, 1b, 1B")
+  // test base conversion (I)
+  assert.eq(strfmt("{:b}, {0:05b}, {:#010b}, {:05x}, {:05X}, {:+#05X}, {2:x?}, {3:X?}", 5, 5, 27, 27, 27), "101, 00101, 0b00000101, 0001b, 0001B, +0x1B, 1b, 1B")
 
-    // test base conversion (II)
-    assert.eq(strfmt("{:x}, {:X}, {:#X}, {:#X}, {:o}, {:#o}", 259, 259, 259, -259, 66, 66), "103, 103, 0x103, -0x103, 102, 0o102")
+  // test base conversion (II)
+  assert.eq(strfmt("{:x}, {:X}, {:#X}, {:#X}, {:o}, {:#o}", 259, 259, 259, -259, 66, 66), "103, 103, 0x103, -0x103, 102, 0o102")
 
-    // some numeric tests with affixes and stuff
-    assert.eq(strfmt("{:-^+#10b}, {fl:+08}", 5, fl: 55.43), "--+0b101--, +0055.43")
+  // some numeric tests with affixes and stuff
+  assert.eq(strfmt("{:-^+#10b}, {fl:+08}", 5, fl: 55.43), "--+0b101--, +0055.43")
 
-    // test scientific notation
-    assert.eq(strfmt("{:e}, {:.7E}, {:e}, {:010.2E}, {:+e}", 4213.4, 521.32947, 0.0241, -0.00432, 190000), "4.2134e3, 5.2132947E2, 2.41e-2, -004.32E-3, +1.9e5")
+  // test scientific notation
+  assert.eq(strfmt("{:e}, {:.7E}, {:e}, {:010.2E}, {:+e}", 4213.4, 521.32947, 0.0241, -0.00432, 190000), "4.2134e3, 5.2132947E2, 2.41e-2, -004.32E-3, +1.9e5")
 
-    // test taking width and precision from pos args / named args (.x$ / y$ notation)
-    assert.eq(strfmt("{:.1$}; {woah:0france$.moment$}; {}; {2:a>1$}", 5.5399234, 9, "stringy", woah: 3.9, france: 7, moment: 2), "5.539923400; 0003.90; 9; aastringy")
+  // test taking width and precision from pos args / named args (.x$ / y$ notation)
+  assert.eq(strfmt("{:.1$}; {woah:0france$.moment$}; {}; {2:a>1$}", 5.5399234, 9, "stringy", woah: 3.9, france: 7, moment: 2), "5.539923400; 0003.90; 9; aastringy")
 
-    // test weird precision cases
-    assert.eq(strfmt("{0:e} {0:+.9E} | {1:.3e} {1:.3} {2:.3} | {3:.4} {3:.4E} | {4:.2} {4:.3} {4:.5}", 124.2312, 50, 50.0, -0.02, 2.44454), "1.242312e2 +1.242312000E2 | 5.000e1 50 50.000 | -0.0200 -2.0000E-2 | 2.44 2.445 2.44454")
+  // test weird precision cases
+  assert.eq(strfmt("{0:e} {0:+.9E} | {1:.3e} {1:.3} {2:.3} | {3:.4} {3:.4E} | {4:.2} {4:.3} {4:.5}", 124.2312, 50, 50.0, -0.02, 2.44454), "1.242312e2 +1.242312000E2 | 5.000e1 50 50.000 | -0.0200 -2.0000E-2 | 2.44 2.445 2.44454")
 
-    // test custom decimal separators (I)
-    assert.eq(strfmt("{}; {:07e}; {}; {}; {:?}", 1.532, 45000, -5.6, "a.b", "c.d", fmt-decimal-separator: ","), "1,532; 004,5e4; -5,6; a.b; \"c.d\"")
+  // test custom decimal separators (I)
+  assert.eq(strfmt("{}; {:07e}; {}; {}; {:?}", 1.532, 45000, -5.6, "a.b", "c.d", fmt-decimal-separator: ","), "1,532; 004,5e4; -5,6; a.b; \"c.d\"")
 
-    // test custom decimal separators (II) - weird values
-    assert.eq(strfmt("{}; {:015e}; {}; {}; {:?}", 1.532, 45000, -5.6, "a.b", "c.d", fmt-decimal-separator: (a: 5)), "1(a: 5)532; 000004(a: 5)5e4; -5(a: 5)6; a.b; \"c.d\"")
+  // test custom decimal separators (II) - weird values
+  assert.eq(strfmt("{}; {:015e}; {}; {}; {:?}", 1.532, 45000, -5.6, "a.b", "c.d", fmt-decimal-separator: (a: 5)), "1(a: 5)532; 000004(a: 5)5e4; -5(a: 5)6; a.b; \"c.d\"")
 
-    // test custom decimal separators (III) - ensure we can fetch it from inside
-    assert.eq(strfmt("5{fmt-decimal-separator}6", fmt-decimal-separator: "|"), "5|6")
+  // test custom decimal separators (III) - ensure we can fetch it from inside
+  assert.eq(strfmt("5{fmt-decimal-separator}6", fmt-decimal-separator: "|"), "5|6")
 }
 // DOC TESTS
 #{
-    // --- Usage ---
-    {
-        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}.")
-    }
-    // --- Formatting options ---
-    {
-        let s1 = strfmt("{0:?}, {test:+012e}, {1:-<#8x}", "hi", -74, test: 569.4)
-        assert.eq(s1, "\"hi\", +00005.694e2, -0x4a---")
-
-        let s2 = strfmt("{:_>+11.5}", 59.4)
-        assert.eq(s2, "__+59.40000")
-
-        let s3 = strfmt("Dict: {:!<10?}", (a: 5))
-        assert.eq(s3, "Dict: (a: 5)!!!!")
-    }
-    // --- Examples ---
-    {
-        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})")
-    }
-    {
-        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>")
-    }
-    {
-        let s = strfmt("Values: {:?}, {1:?}, {stuff:?}", (test: 500), ("a", 5.1), stuff: [a])
-        assert.eq(s, "Values: (test: 500), (\"a\", 5.1), [a]")
-    }
-    {
-        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")
-    }
-    {
-        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")
-    }
-    {
-        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")
-    }
-    {
-        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")
-    }
-    {
-        let s = strfmt("{0:.8} {0:.2$} {0:.potato$}", 1.234, 0, 2, potato: 5)
-        assert.eq(s, "1.23400000 1.23 1.23400")
-    }
-    {
-        let s = strfmt("{0:e} {0:E} {0:+.9e} | {1:e} | {2:E}", 124.2312, 50, -0.02)
-        assert.eq(s, "1.242312e2 1.242312E2 +1.242312000e2 | 5e1 | -2E-2")
-    }
-    {
-        let s = strfmt("{0} {0:.6} {0:.5e}", 1.432, fmt-decimal-separator: ",")
-        assert.eq(s, "1,432 1,432000 1,43200e0")
-    }
+  // --- Usage ---
+  {
+    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}.")
+  }
+  // --- Formatting options ---
+  {
+    let s1 = strfmt("{0:?}, {test:+012e}, {1:-<#8x}", "hi", -74, test: 569.4)
+    assert.eq(s1, "\"hi\", +00005.694e2, -0x4a---")
+
+    let s2 = strfmt("{:_>+11.5}", 59.4)
+    assert.eq(s2, "__+59.40000")
+
+    let s3 = strfmt("Dict: {:!<10?}", (a: 5))
+    assert.eq(s3, "Dict: (a: 5)!!!!")
+  }
+  // --- Examples ---
+  {
+    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})")
+  }
+  {
+    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>")
+  }
+  {
+    let s = strfmt("Values: {:?}, {1:?}, {stuff:?}", (test: 500), ("a", 5.1), stuff: [a])
+    assert.eq(s, "Values: (test: 500), (\"a\", 5.1), [a]")
+  }
+  {
+    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")
+  }
+  {
+    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")
+  }
+  {
+    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")
+  }
+  {
+    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")
+  }
+  {
+    let s = strfmt("{0:.8} {0:.2$} {0:.potato$}", 1.234, 0, 2, potato: 5)
+    assert.eq(s, "1.23400000 1.23 1.23400")
+  }
+  {
+    let s = strfmt("{0:e} {0:E} {0:+.9e} | {1:e} | {2:E}", 124.2312, 50, -0.02)
+    assert.eq(s, "1.242312e2 1.242312E2 +1.242312000e2 | 5e1 | -2E-2")
+  }
+  {
+    let s = strfmt("{0} {0:.6} {0:.5e}", 1.432, fmt-decimal-separator: ",")
+    assert.eq(s, "1,432 1,432000 1,43200e0")
+  }
 }

From a640b1f53bdfedf87b8a012faf6ce5989d6a6e05 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 2 Aug 2023 12:49:28 -0300
Subject: [PATCH 15/60] improve readme examples

---
 README.md              | 10 +++++-----
 tests/strfmt-tests.typ |  4 ++--
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index 748c810..adc71b7 100644
--- a/README.md
+++ b/README.md
@@ -105,7 +105,7 @@ Some examples:
 #assert.eq(s, "Values: (test: 500), (\"a\", 5.1), [a]")
 ```
 
-- **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 (can be `<` for left aligned (padding goes to the right), `>` for right aligned (padded to its left) and `^` for center aligned (padded both left and right)):
+- **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):
 ```js
 #import "typst-oxifmt.typ": strfmt
 
@@ -114,7 +114,7 @@ Some examples:
 // 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 just 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):
+- **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):
 ```js
 #import "typst-oxifmt.typ": strfmt
 
@@ -139,7 +139,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` (base 2), `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):
+- **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):
 ```js
 #import "typst-oxifmt.typ": strfmt
 
@@ -159,8 +159,8 @@ Some examples:
 ```js
 #import "typst-oxifmt.typ": strfmt
 
-#let s = strfmt("{0:e} {0:E} {0:+.9e} | {1:e} | {2:E}", 124.2312, 50, -0.02)
-#assert.eq(s, "1.242312e2 1.242312E2 +1.242312000e2 | 5e1 | -2E-2")
+#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")
 ```
 
 - **Customizing the decimal separator on floats:** Just specify `fmt-decimal-separator: ","` (comma as an example):
diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index 996ca5b..65357bf 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -98,8 +98,8 @@
     assert.eq(s, "1.23400000 1.23 1.23400")
   }
   {
-    let s = strfmt("{0:e} {0:E} {0:+.9e} | {1:e} | {2:E}", 124.2312, 50, -0.02)
-    assert.eq(s, "1.242312e2 1.242312E2 +1.242312000e2 | 5e1 | -2E-2")
+    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")
   }
   {
     let s = strfmt("{0} {0:.6} {0:.5e}", 1.432, fmt-decimal-separator: ",")

From aca61dd8ba7e5f7417bf912ff79cb15a709378b1 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 2 Aug 2023 13:01:50 -0300
Subject: [PATCH 16/60] readme formatting options improvements

---
 README.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index adc71b7..3f69f03 100644
--- a/README.md
+++ b/README.md
@@ -46,9 +46,10 @@ You can use `{:spec}` to customize your output. See the Rust docs linked above f
 
 - Adding a `?` at the end of `spec` (that is, writing e.g. `{0:?}`) will call `repr()` to stringify your argument, instead of `str()`. Note that this only has an effect if your argument is a string, an integer, a float or a `label()` / `<label>` - for all other types (such as booleans or elements), `repr()` is always called (as `str()` is unsupported for those).
     - 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`.
-- 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. Replace `<` by `>` for right alignment, or `^` for center alignment. (If the `_` is omitted, it defaults to ' ' (aligns with spaces).)
+    - **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).
-- For numbers:
+- **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.
         - The `9` here is also a width, so the same comment from before applies (you can add `$` to take it from an argument to the `strfmt` function).

From 6187289e61e5edd3c82487986e397ecd1ecc562c Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 2 Aug 2023 13:05:22 -0300
Subject: [PATCH 17/60] improve initial readme description

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 3f69f03..0a1d8aa 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # typst-oxifmt (v0.1.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 read its page for more information (https://doc.rust-lang.org/std/fmt/). Only a few things aren't supported from the Rust syntax, such as the `p` (pointer) format type, or the `.*` precision specifier.
+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.
 
 A few extras (beyond the Rust-like syntax) will be added over time, though (feel free to drop suggestions at the repository: https://github.com/PgBiel/typst-oxifmt). The first "extra" so far is the `fmt-decimal-separator: "string"` parameter, which lets you customize the decimal separator for decimal numbers (floats) inserted into strings. E.g. `strfmt("Result: {}", 5.8, fmt-decimal-separator: ",")` will return the string `"Result: 5,8"` (comma instead of dot). See more below.
 

From fa2879422c525ede065f2c23c151cc37dcc12081 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 2 Aug 2023 13:10:02 -0300
Subject: [PATCH 18/60] typst.toml: 0.1.0 -> 0.2.0

---
 typst.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/typst.toml b/typst.toml
index 4ae8b03..8faadda 100644
--- a/typst.toml
+++ b/typst.toml
@@ -1,6 +1,6 @@
 [package]
 name = "oxifmt"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["PgBiel <https://github.com/PgBiel>"]
 license = "MIT-0"
 description = "Convenient Rust-like string formatting in Typst"

From e768e0cd6d6828553b209f2ea26861575544149a Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 2 Aug 2023 13:24:24 -0300
Subject: [PATCH 19/60] update testing info in README

---
 README.md | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 0a1d8aa..d5c4382 100644
--- a/README.md
+++ b/README.md
@@ -196,12 +196,16 @@ Please report any issues or send any contributions (through pull requests) to th
 
 ## Testing
 
-If you wish to contribute, you may test this package with the following command (from the project root folder):
+If you wish to contribute, you may clone the repository and test this package with the following commands (from the project root folder):
 
 ```sh
-cd tests && typst c strfmt-tests.typ --root ..
+git clone https://github.com/PgBiel/typst-oxifmt
+cd typst-oxifmt/tests
+typst c strfmt-tests.typ --root ..
 ```
 
+The tests succeeded if you received no error messages from the last command (please ensure you're using a supported Typst version).
+
 ## Changelog
 
 ### v0.1.0

From 487eba16af47f06562b37eb0ec9f0442d6e4e84c Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 2 Aug 2023 13:29:10 -0300
Subject: [PATCH 20/60] bump version to v0.2.0

---
 README.md        | 42 +++++++++++++++++++++++++++---------------
 typst-oxifmt.typ |  2 +-
 2 files changed, 28 insertions(+), 16 deletions(-)

diff --git a/README.md b/README.md
index d5c4382..04a1fd7 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# typst-oxifmt (v0.1.0)
+# typst-oxifmt (v0.2.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.
 
@@ -19,7 +19,13 @@ A few extras (beyond the Rust-like syntax) will be added over time, though (feel
 
 ## Usage
 
-Download the `typst-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):
+You can use this library through Typst's package manager (for Typst v0.6.0+):
+
+```js
+#import "@preview/oxifmt:0.2.0": strfmt
+```
+
+For older Typst versions, download the `typst-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):
 
 ```js
 #import "typst-oxifmt.typ": strfmt
@@ -30,7 +36,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`):
 
 ```js
-#import "typst-oxifmt.typ": strfmt
+#import "@preview/oxifmt:0.2.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}.")
@@ -68,7 +74,7 @@ You can use `{:spec}` to customize your output. See the Rust docs linked above f
 Some examples:
 
 ```js
-#import "typst-oxifmt.typ": strfmt
+#import "@preview/oxifmt:0.2.0": strfmt
 
 #let s1 = strfmt("{0:?}, {test:+012e}, {1:-<#8x}", "hi", -74, test: 569.4)
 #assert.eq(s1, "\"hi\", +00005.694e2, -0x4a---")
@@ -84,7 +90,7 @@ Some examples:
 
 - **Inserting labels, text and numbers into strings:**
 ```js
-#import "typst-oxifmt.typ": strfmt
+#import "@preview/oxifmt:0.2.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})")
@@ -92,7 +98,7 @@ Some examples:
 
 - **Forcing `repr()` with `{:?}`** (which adds quotes around strings, and other things - basically represents a Typst value):
 ```js
-#import "typst-oxifmt.typ": strfmt
+#import "@preview/oxifmt:0.2.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>")
@@ -100,7 +106,7 @@ Some examples:
 
 - **Inserting other types than numbers and strings** (for now, they will always use `repr()`, even without `{...:?}`, although that is more explicit):
 ```js
-#import "typst-oxifmt.typ": strfmt
+#import "@preview/oxifmt:0.2.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]")
@@ -108,7 +114,7 @@ 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):
 ```js
-#import "typst-oxifmt.typ": strfmt
+#import "@preview/oxifmt:0.2.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")
@@ -117,7 +123,7 @@ Some examples:
 
 - **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):
 ```js
-#import "typst-oxifmt.typ": strfmt
+#import "@preview/oxifmt:0.2.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")
@@ -125,7 +131,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):
 ```js
-#import "typst-oxifmt.typ": strfmt
+#import "@preview/oxifmt:0.2.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
@@ -133,7 +139,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:
 ```js
-#import "typst-oxifmt.typ": strfmt
+#import "@preview/oxifmt:0.2.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")
@@ -142,7 +148,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):
 ```js
-#import "typst-oxifmt.typ": strfmt
+#import "@preview/oxifmt:0.2.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")
@@ -150,7 +156,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`):
 ```js
-#import "typst-oxifmt.typ": strfmt
+#import "@preview/oxifmt:0.2.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")
@@ -158,7 +164,7 @@ Some examples:
 
 - **Scientific notation:** Use `e` (lowercase) or `E` (uppercase) as specifier types (can be combined with precision):
 ```js
-#import "typst-oxifmt.typ": strfmt
+#import "@preview/oxifmt:0.2.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")
@@ -166,7 +172,7 @@ Some examples:
 
 - **Customizing the decimal separator on floats:** Just specify `fmt-decimal-separator: ","` (comma as an example):
 ```js
-#import "typst-oxifmt.typ": strfmt
+#import "@preview/oxifmt:0.2.0": strfmt
 
 #let s = strfmt("{0} {0:.6} {0:.5e}", 1.432, fmt-decimal-separator: ",")
 #assert.eq(s, "1,432 1,432000 1,43200e0")
@@ -208,6 +214,12 @@ The tests succeeded if you received no error messages from the last command (ple
 
 ## Changelog
 
+### v0.2.0
+
+- `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.
+- Fixed negative numbers being formatted with two minus signs
+- Fixed custom precision of floats not working when they are exact integers
+
 ### v0.1.0
 
 - Initial release, added `strfmt`.
diff --git a/typst-oxifmt.typ b/typst-oxifmt.typ
index 96d7607..5190813 100644
--- a/typst-oxifmt.typ
+++ b/typst-oxifmt.typ
@@ -1,4 +1,4 @@
-// typst-oxifmt v0.1.1 (WIP)
+// typst-oxifmt v0.2.0
 #let _strfmt_formatparser(s) = {
   if type(s) != "string" {
     panic("String format parsing internal error: String format parser given non-string.")

From aadde9433e7520fb983d2e11b19b49286d74ad66 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 2 Aug 2023 13:40:33 -0300
Subject: [PATCH 21/60] typst-oxifmt.typ -> oxifmt.typ

---
 .gitignore                     | 2 +-
 README.md                      | 4 ++--
 typst-oxifmt.typ => oxifmt.typ | 4 ++--
 tests/strfmt-tests.typ         | 2 +-
 typst.toml                     | 2 +-
 5 files changed, 7 insertions(+), 7 deletions(-)
 rename typst-oxifmt.typ => oxifmt.typ (99%)

diff --git a/.gitignore b/.gitignore
index 51b3b14..1635c0c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,2 @@
-typst-oxifmt.pdf
+oxifmt.pdf
 strfmt-tests.pdf
diff --git a/README.md b/README.md
index 04a1fd7..dbb0efa 100644
--- a/README.md
+++ b/README.md
@@ -25,10 +25,10 @@ You can use this library through Typst's package manager (for Typst v0.6.0+):
 #import "@preview/oxifmt:0.2.0": strfmt
 ```
 
-For older Typst versions, download the `typst-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):
+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):
 
 ```js
-#import "typst-oxifmt.typ": strfmt
+#import "oxifmt.typ": strfmt
 ```
 
 Doing the above will give you access to the main function provided by this library (`strfmt`), which accepts a format string, followed by zero or more replacements to insert in that string (according to `{...}` formats inserted in that string), an optional `fmt-decimal-separator` parameter, and returns the formatted string, as described below.
diff --git a/typst-oxifmt.typ b/oxifmt.typ
similarity index 99%
rename from typst-oxifmt.typ
rename to oxifmt.typ
index 5190813..aba04be 100644
--- a/typst-oxifmt.typ
+++ b/oxifmt.typ
@@ -1,4 +1,4 @@
-// typst-oxifmt v0.2.0
+// oxifmt v0.2.0
 #let _strfmt_formatparser(s) = {
   if type(s) != "string" {
     panic("String format parsing internal error: String format parser given non-string.")
@@ -317,7 +317,7 @@ parameter := argument '$'
   let valid-specs = ("", "?", "b", "x", "X", "o", "x?", "X?", "e", "E")
   let spec-error() = {
     panic(
-      "String formatter error: Unknown spec type '" + spectype + "', from '{" + fullname.replace("{", "{{").replace("}", "}}") + "}'. Valid options include: '" + valid-specs.join("', '") + "'. Maybe you specified some invalid formatting spec syntax (after the ':'), which can also prompt this error. Check the typst-oxifmt docs for more information.")
+      "String formatter error: Unknown spec type '" + spectype + "', from '{" + fullname.replace("{", "{{").replace("}", "}}") + "}'. Valid options include: '" + valid-specs.join("', '") + "'. Maybe you specified some invalid formatting spec syntax (after the ':'), which can also prompt this error. Check the oxifmt docs for more information.")
   }
   if spectype not in valid-specs {
     spec-error()
diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index 65357bf..3a91788 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -1,4 +1,4 @@
-#import "../typst-oxifmt.typ": strfmt
+#import "../oxifmt.typ": strfmt
 
 #{
   // test basics (sequential args, named args, pos args)
diff --git a/typst.toml b/typst.toml
index 8faadda..59286eb 100644
--- a/typst.toml
+++ b/typst.toml
@@ -4,5 +4,5 @@ version = "0.2.0"
 authors = ["PgBiel <https://github.com/PgBiel>"]
 license = "MIT-0"
 description = "Convenient Rust-like string formatting in Typst"
-entrypoint = "typst-oxifmt.typ"
+entrypoint = "oxifmt.typ"
 repository = "https://github.com/PgBiel/typst-oxifmt"

From 3e69762a8d952fd9bd0e8a555dd003a23f4fe65e Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 2 Aug 2023 13:51:57 -0300
Subject: [PATCH 22/60] add dots at the README

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index dbb0efa..20528ff 100644
--- a/README.md
+++ b/README.md
@@ -217,8 +217,8 @@ The tests succeeded if you received no error messages from the last command (ple
 ### v0.2.0
 
 - `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.
-- Fixed negative numbers being formatted with two minus signs
-- Fixed custom precision of floats not working when they are exact integers
+- Fixed negative numbers being formatted with two minus signs.
+- Fixed custom precision of floats not working when they are exact integers.
 
 ### v0.1.0
 

From 4c0029d5d9526824cff1e16f84335996d72db74f Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 2 Aug 2023 14:31:02 -0300
Subject: [PATCH 23/60] add README changes in v0.2.0 to changelog

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 20528ff..2e9a2d2 100644
--- a/README.md
+++ b/README.md
@@ -217,6 +217,7 @@ The tests succeeded if you received no error messages from the last command (ple
 ### v0.2.0
 
 - `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.
+- Greatly improved the README, adding a section for common examples.
 - Fixed negative numbers being formatted with two minus signs.
 - Fixed custom precision of floats not working when they are exact integers.
 

From f483e954d79ff1d6291d5558af68ac90fcb61bda Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 2 Aug 2023 15:05:33 -0300
Subject: [PATCH 24/60] add package renaming to 0.2.0 changelog

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 2e9a2d2..564ed1f 100644
--- a/README.md
+++ b/README.md
@@ -216,6 +216,7 @@ The tests succeeded if you received no error messages from the last command (ple
 
 ### v0.2.0
 
+- 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.
 - Greatly improved the README, adding a section for common examples.
 - Fixed negative numbers being formatted with two minus signs.

From 450472c1233715fe5a016b44ffea0169df36d23e Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 2 Aug 2023 18:52:54 -0300
Subject: [PATCH 25/60] small blunder in the initial README example

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 564ed1f..7f04eae 100644
--- a/README.md
+++ b/README.md
@@ -38,8 +38,8 @@ Its syntax is almost identical to Rust's `format!` (as specified here: https://d
 ```js
 #import "@preview/oxifmt:0.2.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}.")
+#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}.")
 ```
 
 Note that `{}` extracts positional arguments after the string sequentially (the first `{}` extracts the first one, the second `{}` extracts the second one, and so on), while `{0}`, `{1}`, etc. will always extract the first, the second etc. positional arguments after the string. Additionally, `{bananas}` will extract the named argument "bananas".

From 2f27f4b88fc5be58eb29f0e1a221fd7ae5375847 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 13 Dec 2023 21:02:21 -0300
Subject: [PATCH 26/60] create FUNDING.yml

add sponsorship info
---
 .github/FUNDING.yml | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 .github/FUNDING.yml

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 0000000..5a130ed
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,3 @@
+# You may support oxifmt by sponsoring the account(s) below
+
+github: PgBiel

From 5340e49346af1e94d62c642062b41cec68efcbbc Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sat, 27 Apr 2024 12:39:29 -0300
Subject: [PATCH 27/60] support typst 0.8.0 types

---
 oxifmt.typ | 29 ++++++++++++++++++-----------
 1 file changed, 18 insertions(+), 11 deletions(-)

diff --git a/oxifmt.typ b/oxifmt.typ
index aba04be..6e78cf0 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -1,6 +1,13 @@
-// oxifmt v0.2.0
+// oxifmt v0.2.1
+
+// For compatibility with pre-0.8.0 Typst types, which were strings
+#let _int-type = type(0)
+#let _float-type = type(5.5)
+#let _str-type = type("")
+#let _label-type = type(<hello>)
+
 #let _strfmt_formatparser(s) = {
-  if type(s) != "string" {
+  if type(s) != _str-type {
     panic("String format parsing internal error: String format parser given non-string.")
   }
   let result = ()
@@ -124,7 +131,7 @@
   let subparts = name.match(regex("^([^:]*)(?::(.*))?$")).captures
   let name = subparts.at(0)
   let extras = subparts.at(1)
-  let name = if type(name) != "string" {
+  let name = if type(name) != _str-type {
     name
   } else if name == "" {
     none
@@ -137,11 +144,11 @@
 }
 
 #let _strfmt_is-numeric-type(obj) = {
-  type(obj) in ("integer", "float")
+  type(obj) in (_int-type, _float-type)
 }
 
 #let _strfmt_stringify(obj) = {
-  if type(obj) in ("integer", "float", "label", "string") {
+  if type(obj) in (_int-type, _float-type, _label-type, _str-type) {
     str(obj)
   } else {
     repr(obj)
@@ -150,7 +157,7 @@
 
 #let _strfmt_display-radix(num, radix, signed: true, lowercase: false) = {
   let num = int(num)
-  if type(radix) != "integer" or num == 0 or radix <= 1 {
+  if type(radix) != _int-type or num == 0 or radix <= 1 {
     return "0"
   }
   let sign = if num < 0 and signed { "-" } else { "" }
@@ -266,7 +273,7 @@ parameter := argument '$'
       )
       let arg = pos-replacements.at(i)
       assert(
-        type(arg) == "integer",
+        type(arg) == _int-type,
         message: "String formatter error: Attempted to use positional argument " + str(i) + " for " + spec-part-name + ", but it was a(n) '" + type(arg) + "', not an integer (from '{" + fullname.replace("{", "{{").replace("}", "}}") + "}')."
       )
 
@@ -282,7 +289,7 @@ parameter := argument '$'
       )
       let arg = named-replacements.at(named)
       assert(
-        type(arg) == "integer",
+        type(arg) == _int-type,
         message: "String formatter error: Attempted to use named argument '" + named + "' for " + spec-part-name + ", but it was a(n) '" + type(arg) + "', not an integer (from '{" + fullname.replace("{", "{{").replace("}", "}}") + "}')."
       )
 
@@ -352,9 +359,9 @@ parameter := argument '$'
     if spectype in ("e", "E") {
       let exponent-sign = if spectype == "E" { "E" } else { "e" }
       replacement = _strfmt_exp-format(calc.abs(replacement), exponent-sign: exponent-sign, precision: precision)
-    } else if type(replacement) != "integer" and precision != none {
+    } else if type(replacement) != _int-type and precision != none {
       replacement = _strfmt_with-precision(replacement, precision)
-    } else if type(replacement) == "integer" and spectype in ("x", "X", "b", "o", "x?", "X?") {
+    } else if type(replacement) == _int-type and spectype in ("x", "X", "b", "o", "x?", "X?") {
       let radix-map = (x: 16, X: 16, "x?": 16, "X?": 16, b: 2, o: 8)
       let radix = radix-map.at(spectype)
       let lowercase = spectype.starts-with("x")
@@ -453,7 +460,7 @@ parameter := argument '$'
         }
         replace-by = num-replacements.at(fmt-index)
         unnamed-format-index += 1
-      } else if type(name) == "integer" {
+      } else if type(name) == _int-type {
         let fmt-index = name
         let amount-pos-replacements = num-replacements.len()
         if amount-pos-replacements == 0 {

From be4818529aa0628a52bb9c723a076e8cf10bed6c Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sat, 27 Apr 2024 12:44:55 -0300
Subject: [PATCH 28/60] fix minus sign inconsistency

here we diverge from str(...) as we always use hyphens, so we can consider reverting this in the
future, but it was inconsistent otherwise, as we would use hyphen on rich formatting
---
 oxifmt.typ | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/oxifmt.typ b/oxifmt.typ
index 6e78cf0..d190905 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -148,7 +148,11 @@
 }
 
 #let _strfmt_stringify(obj) = {
-  if type(obj) in (_int-type, _float-type, _label-type, _str-type) {
+  if type(obj) in (_int-type, _float-type) {
+    // Fix negative sign not being a hyphen
+    // for consistency with our rich formatting output
+    str(obj).replace("\u{2212}", "-")
+  } else if type(obj) in (_label-type, _str-type) {
     str(obj)
   } else {
     repr(obj)
@@ -215,7 +219,7 @@
   let mantissa = f / calc.pow(10, exponent)
   let mantissa = _strfmt_with-precision(mantissa, precision)
 
-  mantissa + exponent-sign + str(exponent)
+  mantissa + exponent-sign + _strfmt_stringify(exponent)
 }
 
 // Parses {format:specslikethis}.

From 13f9bedf5573f41c3f9508766044326d27eeb7ac Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sat, 27 Apr 2024 14:58:56 -0300
Subject: [PATCH 29/60] fix utf-8 parsing

- Spans were using codepoint indices, not byte indices
- Fix by adding "character.len()" to the index on each iteration
---
 oxifmt.typ             | 33 +++++++++++++++++++++------------
 tests/strfmt-tests.typ | 11 +++++++++++
 2 files changed, 32 insertions(+), 12 deletions(-)

diff --git a/oxifmt.typ b/oxifmt.typ
index d190905..1283f24 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -20,11 +20,10 @@
   let last-was-lbracket = false
   // if the last character was an unescaped }
   let last-was-rbracket = false
-  let last-i = 0
 
   // -- procedures --
-  let write-format-span(i, result, current-fmt-span, current-fmt-name) = {
-    current-fmt-span.at(1) = i  // end index
+  let write-format-span(last-i, result, current-fmt-span, current-fmt-name) = {
+    current-fmt-span.at(1) = last-i + 1  // end index
     result.push((format: (name: current-fmt-name, span: current-fmt-span)))
     current-fmt-span = none
     current-fmt-name = none
@@ -43,14 +42,15 @@
   }
 
   // -- parse loop --
-  for (i, character) in codepoints.enumerate() {
-    last-i = i
+  let last-i = none
+  let i = 0
+  for character in codepoints {
     if character == "{" {
       // double l-bracket = escape
       if last-was-lbracket {
         last-was-lbracket = false  // escape {{
         last-was-rbracket = false
-        if current-fmt-span.at(0) == i - 1 {
+        if current-fmt-span.at(0) == last-i {
           current-fmt-span = none  // cancel this span
           current-fmt-name = none
         }
@@ -60,13 +60,16 @@
           current-fmt-name += character
         } else {
           // outside a span ({...} {{ <-) => emit an 'escaped' token
-          result.push((escape: (escaped: "{", span: (i - 1, i + 1))))
+          result.push((escape: (escaped: "{", span: (last-i, i + 1))))
         }
+
+        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(i, result, current-fmt-span, current-fmt-name)
+        (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 {
@@ -82,8 +85,11 @@
         if current-fmt-name != none {
           current-fmt-name += character
         } else {
-          result.push((escape: (escaped: "}", span: (i - 1, i + 1))))
+          result.push((escape: (escaped: "}", span: (last-i, i + 1))))
         }
+
+        last-i = i
+        i += 1  // '}' is ASCII, so 1 byte
         continue
       }
       // delay closing the span to the next iteration
@@ -91,7 +97,7 @@
       last-was-rbracket = true
     } else {
       // { ... {A  <--- non-escaped { inside larger {}
-      if last-was-lbracket and (current-fmt-span != none and current-fmt-span.at(0) != i - 1) {
+      if last-was-lbracket and (current-fmt-span != none and current-fmt-span.at(0) != last-i) {
         excessive-lbracket()
       }
       if last-was-rbracket {
@@ -100,7 +106,7 @@
           excessive-rbracket()
         } else {
           // { ... }A <--- ok, close the previous span
-          (result, current-fmt-span, current-fmt-name) = write-format-span(i, result, current-fmt-span, current-fmt-name)
+          (result, current-fmt-span, current-fmt-name) = write-format-span(last-i, result, current-fmt-span, current-fmt-name)
         }
       }
       // {abc <--- add character to the format name
@@ -110,12 +116,15 @@
       last-was-lbracket = false
       last-was-rbracket = false
     }
+
+    last-i = i
+    i += character.len() // index must be in bytes, and a UTF-8 codepoint can have more than one byte
   }
   // { ...
   if current-fmt-span != none {
     if last-was-rbracket {
       // ... } <--- ok, close span
-      (result, current-fmt-span, current-fmt-name) = write-format-span(last-i + 1, result, current-fmt-span, current-fmt-name)
+      (result, current-fmt-span, current-fmt-name) = write-format-span(last-i, result, current-fmt-span, current-fmt-name)
     } else {
       // {abcd| <--- string ended with unclosed span
       missing-rbracket()
diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index 3a91788..27862c1 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -46,6 +46,17 @@
   // test custom decimal separators (III) - ensure we can fetch it from inside
   assert.eq(strfmt("5{fmt-decimal-separator}6", fmt-decimal-separator: "|"), "5|6")
 }
+// Issue #6: UTF-8
+#{
+  // shouldn't crash
+  assert.eq(strfmt("Hello € {}", "man"), "Hello € man")
+
+  // should replace at the appropriate location
+  assert.eq(strfmt("Bank: {company-bank-name} € IBAN: {company-bank-iban}", company-bank-name: "FAKE", company-bank-iban: "Broken stuff"), "Bank: FAKE € IBAN: Broken stuff")
+
+  // test grapheme clusters
+  assert.eq(strfmt("Ĺo͂řȩ{}m̅", 5.5), "Ĺo͂řȩ5.5m̅")
+}
 // DOC TESTS
 #{
   // --- Usage ---

From ef9d37ccdef52e13ed3a54211c220c0123966d24 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sun, 5 May 2024 21:03:13 -0300
Subject: [PATCH 30/60] create tests-ci.yml

Closes https://github.com/PgBiel/typst-oxifmt/issues/8
---
 .github/workflows/tests-ci.yml | 39 ++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 .github/workflows/tests-ci.yml

diff --git a/.github/workflows/tests-ci.yml b/.github/workflows/tests-ci.yml
new file mode 100644
index 0000000..c4f3159
--- /dev/null
+++ b/.github/workflows/tests-ci.yml
@@ -0,0 +1,39 @@
+name: Tests CI
+
+# Controls when the workflow will run
+on:
+  # Triggers the workflow on push or pull request events but only for the branches below
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+  # Allows one to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  # This workflow contains a single job called "build"
+  build:
+    # The type of runner that the job will run on
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        # Test for the following Typst versions
+        # 0.4.0 (earliest supported), 0.6.0 (first version with package management),
+        # 0.11.0 (latest supported)
+        typst-version: [v0.4.0, v0.6.0, v0.11.0]
+
+    # Steps represent a sequence of tasks that will be executed as part of the job
+    steps:
+      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+      - uses: actions/checkout@v4
+
+      - name: 📥 Setup Typst
+        uses: typst-community/setup-typst@v3
+        id: setup-typst
+        with:
+          version: ${{ matrix.typst-version }}
+
+      - name: 🛠️ Compile test document
+        run: "typst compile tests/strfmt-tests.typ --root ."

From a03bbed15e192f2679f74880205751e9e0e8b3f2 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sun, 5 May 2024 21:06:35 -0300
Subject: [PATCH 31/60] ci: fix typst-version parameter

---
 .github/workflows/tests-ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/tests-ci.yml b/.github/workflows/tests-ci.yml
index c4f3159..8c9c5b9 100644
--- a/.github/workflows/tests-ci.yml
+++ b/.github/workflows/tests-ci.yml
@@ -33,7 +33,7 @@ jobs:
         uses: typst-community/setup-typst@v3
         id: setup-typst
         with:
-          version: ${{ matrix.typst-version }}
+          typst-version: ${{ matrix.typst-version }}
 
       - name: 🛠️ Compile test document
         run: "typst compile tests/strfmt-tests.typ --root ."

From edf009e2b187a816a1674d493af9e88b7f77411e Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sun, 5 May 2024 21:10:34 -0300
Subject: [PATCH 32/60] ci: fix --root parameter order

---
 .github/workflows/tests-ci.yml | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/tests-ci.yml b/.github/workflows/tests-ci.yml
index 8c9c5b9..d2ca340 100644
--- a/.github/workflows/tests-ci.yml
+++ b/.github/workflows/tests-ci.yml
@@ -35,5 +35,10 @@ jobs:
         with:
           typst-version: ${{ matrix.typst-version }}
 
-      - name: 🛠️ Compile test document
+      - name: 🛠️ Compile test document (<v0.7.0)
+        if: ${{ matrix.typst-version != 'v0.11.0' }}
+        run: "typst compile --root . tests/strfmt-tests.typ"
+
+      - name: 🛠️ Compile test document (v0.7.0+)
+        if: ${{ matrix.typst-version == 'v0.11.0' }}
         run: "typst compile tests/strfmt-tests.typ --root ."

From 39214730acdd285f42f31d9d0263fbb351acc6e9 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sun, 5 May 2024 21:12:06 -0300
Subject: [PATCH 33/60] ci: another attempt at fixing --root

---
 .github/workflows/tests-ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/tests-ci.yml b/.github/workflows/tests-ci.yml
index d2ca340..3504f46 100644
--- a/.github/workflows/tests-ci.yml
+++ b/.github/workflows/tests-ci.yml
@@ -37,7 +37,7 @@ jobs:
 
       - name: 🛠️ Compile test document (<v0.7.0)
         if: ${{ matrix.typst-version != 'v0.11.0' }}
-        run: "typst compile --root . tests/strfmt-tests.typ"
+        run: "typst --root . compile tests/strfmt-tests.typ"
 
       - name: 🛠️ Compile test document (v0.7.0+)
         if: ${{ matrix.typst-version == 'v0.11.0' }}

From 2100cff067e775c9db29ca16a34e3f235f56efd5 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Mon, 6 May 2024 11:24:50 -0300
Subject: [PATCH 34/60] Release v0.2.1 (#7)

---
 README.md  | 72 +++++++++++++++++++++++++++++-------------------------
 typst.toml |  2 +-
 2 files changed, 40 insertions(+), 34 deletions(-)

diff --git a/README.md b/README.md
index 7f04eae..4782894 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
-# typst-oxifmt (v0.2.0)
+# typst-oxifmt (v0.2.1)
 
 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.
 
 A few extras (beyond the Rust-like syntax) will be added over time, though (feel free to drop suggestions at the repository: https://github.com/PgBiel/typst-oxifmt). The first "extra" so far is the `fmt-decimal-separator: "string"` parameter, which lets you customize the decimal separator for decimal numbers (floats) inserted into strings. E.g. `strfmt("Result: {}", 5.8, fmt-decimal-separator: ",")` will return the string `"Result: 5,8"` (comma instead of dot). See more below.
 
-**Compatible with:** [Typst](https://github.com/typst/typst) v0.4.0, v0.5.0, v0.6.0
+**Compatible with:** [Typst](https://github.com/typst/typst) v0.4.0+
 
 ## Table of Contents
 
@@ -21,13 +21,13 @@ 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+):
 
-```js
-#import "@preview/oxifmt:0.2.0": strfmt
+```typ
+#import "@preview/oxifmt:0.2.1": 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):
 
-```js
+```typ
 #import "oxifmt.typ": strfmt
 ```
 
@@ -35,8 +35,8 @@ 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`):
 
-```js
-#import "@preview/oxifmt:0.2.0": strfmt
+```typ
+#import "@preview/oxifmt:0.2.1": 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}.")
@@ -73,8 +73,8 @@ You can use `{:spec}` to customize your output. See the Rust docs linked above f
 
 Some examples:
 
-```js
-#import "@preview/oxifmt:0.2.0": strfmt
+```typ
+#import "@preview/oxifmt:0.2.1": strfmt
 
 #let s1 = strfmt("{0:?}, {test:+012e}, {1:-<#8x}", "hi", -74, test: 569.4)
 #assert.eq(s1, "\"hi\", +00005.694e2, -0x4a---")
@@ -89,57 +89,57 @@ Some examples:
 ### Examples
 
 - **Inserting labels, text and numbers into strings:**
-```js
-#import "@preview/oxifmt:0.2.0": strfmt
+```typ
+#import "@preview/oxifmt:0.2.1": 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})")
 ```
 
 - **Forcing `repr()` with `{:?}`** (which adds quotes around strings, and other things - basically represents a Typst value):
-```js
-#import "@preview/oxifmt:0.2.0": strfmt
+```typ
+#import "@preview/oxifmt:0.2.1": 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>")
 ```
 
 - **Inserting other types than numbers and strings** (for now, they will always use `repr()`, even without `{...:?}`, although that is more explicit):
-```js
-#import "@preview/oxifmt:0.2.0": strfmt
+```typ
+#import "@preview/oxifmt:0.2.1": strfmt
 
 #let s = strfmt("Values: {:?}, {1:?}, {stuff:?}", (test: 500), ("a", 5.1), stuff: [a])
 #assert.eq(s, "Values: (test: 500), (\"a\", 5.1), [a]")
 ```
 
 - **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):
-```js
-#import "@preview/oxifmt:0.2.0": strfmt
+```typ
+#import "@preview/oxifmt:0.2.1": 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")
+#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")
 // 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):
-```js
-#import "@preview/oxifmt:0.2.0": strfmt
+```typ
+#import "@preview/oxifmt:0.2.1": 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")
 ```
 
 - **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):
-```js
-#import "@preview/oxifmt:0.2.0": strfmt
+```typ
+#import "@preview/oxifmt:0.2.1": 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
 ```
 
 - **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:
-```js
-#import "@preview/oxifmt:0.2.0": strfmt
+```typ
+#import "@preview/oxifmt:0.2.1": 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")
@@ -147,32 +147,32 @@ 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):
-```js
-#import "@preview/oxifmt:0.2.0": strfmt
+```typ
+#import "@preview/oxifmt:0.2.1": 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")
 ```
 
 - **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`):
-```js
-#import "@preview/oxifmt:0.2.0": strfmt
+```typ
+#import "@preview/oxifmt:0.2.1": 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")
 ```
 
 - **Scientific notation:** Use `e` (lowercase) or `E` (uppercase) as specifier types (can be combined with precision):
-```js
-#import "@preview/oxifmt:0.2.0": strfmt
+```typ
+#import "@preview/oxifmt:0.2.1": 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")
 ```
 
 - **Customizing the decimal separator on floats:** Just specify `fmt-decimal-separator: ","` (comma as an example):
-```js
-#import "@preview/oxifmt:0.2.0": strfmt
+```typ
+#import "@preview/oxifmt:0.2.1": strfmt
 
 #let s = strfmt("{0} {0:.6} {0:.5e}", 1.432, fmt-decimal-separator: ",")
 #assert.eq(s, "1,432 1,432000 1,43200e0")
@@ -214,6 +214,12 @@ The tests succeeded if you received no error messages from the last command (ple
 
 ## Changelog
 
+### v0.2.1
+
+- 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
 
 - The package's name is now `oxifmt`!
diff --git a/typst.toml b/typst.toml
index 59286eb..6f680c1 100644
--- a/typst.toml
+++ b/typst.toml
@@ -1,6 +1,6 @@
 [package]
 name = "oxifmt"
-version = "0.2.0"
+version = "0.2.1"
 authors = ["PgBiel <https://github.com/PgBiel>"]
 license = "MIT-0"
 description = "Convenient Rust-like string formatting in Typst"

From 735e2ca1c5e3d5556b672d110e93c405ee7aff45 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 1 Oct 2024 00:24:31 -0300
Subject: [PATCH 35/60] change license to MIT/Apache

---
 LICENSE        |  16 ----
 LICENSE-APACHE | 201 +++++++++++++++++++++++++++++++++++++++++++++++++
 LICENSE-MIT    |  21 ++++++
 README.md      |   2 +-
 typst.toml     |   2 +-
 5 files changed, 224 insertions(+), 18 deletions(-)
 delete mode 100644 LICENSE
 create mode 100644 LICENSE-APACHE
 create mode 100644 LICENSE-MIT

diff --git a/LICENSE b/LICENSE
deleted file mode 100644
index a9cb23f..0000000
--- a/LICENSE
+++ /dev/null
@@ -1,16 +0,0 @@
-MIT No Attribution
-
-Copyright (c) 2023 Pg Biel
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this
-software and associated documentation files (the "Software"), to deal in the Software
-without restriction, including without limitation the rights to use, copy, modify,
-merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
-INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/LICENSE-APACHE b/LICENSE-APACHE
new file mode 100644
index 0000000..71b8799
--- /dev/null
+++ b/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2024 PgBiel
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/LICENSE-MIT b/LICENSE-MIT
new file mode 100644
index 0000000..869be70
--- /dev/null
+++ b/LICENSE-MIT
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 PgBiel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
index 4782894..ac10e3c 100644
--- a/README.md
+++ b/README.md
@@ -234,4 +234,4 @@ The tests succeeded if you received no error messages from the last command (ple
 
 ## License
 
-MIT-0 license (see the `LICENSE` file).
+Licensed under MIT or Apache-2.0, at your option.
diff --git a/typst.toml b/typst.toml
index 6f680c1..13fcdba 100644
--- a/typst.toml
+++ b/typst.toml
@@ -2,7 +2,7 @@
 name = "oxifmt"
 version = "0.2.1"
 authors = ["PgBiel <https://github.com/PgBiel>"]
-license = "MIT-0"
+license = "MIT OR Apache-2.0"
 description = "Convenient Rust-like string formatting in Typst"
 entrypoint = "oxifmt.typ"
 repository = "https://github.com/PgBiel/typst-oxifmt"

From d660b1130fe4467e5fe494652f8eb240f1cd379a Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 8 Oct 2024 23:49:55 -0300
Subject: [PATCH 36/60] Add thousand separator options (#12)

* experiment with thousand sep

* add fmt-thousands-count and tests, fix bugs

* bump minimum typst version

* test version compat

* polyfill array chunks

* fix polyfill version

* add Typst v0.10.0 to tests

* workaround for repr inconsistency

* fix utf-8 bugs

* fix simple negative numbers

* use array.rev() for thousands separator stuff

* handle NaN

* update this test

* allow typst 0.7.0

* use codepoints for thousand sep

* optimize arr-chunks polyfill

because why not

* test more recent typst versions

* move is-nan
---
 .github/workflows/tests-ci.yml |  19 ++---
 oxifmt.typ                     | 147 +++++++++++++++++++++++++++------
 tests/strfmt-tests.typ         |  40 +++++++++
 3 files changed, 171 insertions(+), 35 deletions(-)

diff --git a/.github/workflows/tests-ci.yml b/.github/workflows/tests-ci.yml
index 3504f46..b4cdf8a 100644
--- a/.github/workflows/tests-ci.yml
+++ b/.github/workflows/tests-ci.yml
@@ -4,9 +4,9 @@ name: Tests CI
 on:
   # Triggers the workflow on push or pull request events but only for the branches below
   push:
-    branches: [ "main" ]
+    branches: ["main"]
   pull_request:
-    branches: [ "main" ]
+    branches: ["main"]
 
   # Allows one to run this workflow manually from the Actions tab
   workflow_dispatch:
@@ -20,9 +20,11 @@ jobs:
     strategy:
       matrix:
         # Test for the following Typst versions
-        # 0.4.0 (earliest supported), 0.6.0 (first version with package management),
-        # 0.11.0 (latest supported)
-        typst-version: [v0.4.0, v0.6.0, v0.11.0]
+        # 0.7.0 (earliest supported), 0.8.0,
+        # 0.9.0 (first version with version checks), 0.10.0,
+        # 0.11.0, 0.11.1, 0.12-rc1 (latest supported)
+        typst-version:
+          [v0.7.0, v0.8.0, v0.9.0, v0.10.0, v0.11.0, v0.11.1, v0.12.0-rc1]
 
     # Steps represent a sequence of tasks that will be executed as part of the job
     steps:
@@ -35,10 +37,5 @@ jobs:
         with:
           typst-version: ${{ matrix.typst-version }}
 
-      - name: 🛠️ Compile test document (<v0.7.0)
-        if: ${{ matrix.typst-version != 'v0.11.0' }}
-        run: "typst --root . compile tests/strfmt-tests.typ"
-
-      - name: 🛠️ Compile test document (v0.7.0+)
-        if: ${{ matrix.typst-version == 'v0.11.0' }}
+      - name: 🛠️ Compile test document
         run: "typst compile tests/strfmt-tests.typ --root ."
diff --git a/oxifmt.typ b/oxifmt.typ
index 1283f24..4ca2c66 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -6,6 +6,40 @@
 #let _str-type = type("")
 #let _label-type = type(<hello>)
 
+#let using-080 = type(type(5)) != _str-type
+#let using-090 = using-080 and str(-1).codepoints().first() == "\u{2212}"
+#let using-0110 = using-090 and sys.version >= version(0, 11, 0)
+
+#let _arr-chunks = if using-0110 {
+  array.chunks
+} else {
+  (arr, chunks) => {
+    let i = 0
+    let res = ()
+    for element in arr {
+      if i == 0 {
+        res.push(())
+        i = chunks
+      }
+      res.last().push(element)
+      i -= 1
+    }
+    res
+  }
+}
+
+#let _float-is-nan = if using-0110 {
+  float.is-nan
+} else {
+  x => type(x) == _float-type and "NaN" in repr(x)
+}
+
+#let _float-is-infinite = if using-0110 {
+  float.is-infinite
+} else {
+  x => type(x) == _float-type and "inf" in repr(x)
+}
+
 #let _strfmt_formatparser(s) = {
   if type(s) != _str-type {
     panic("String format parsing internal error: String format parser given non-string.")
@@ -195,7 +229,7 @@
 }
 
 #let _strfmt_with-precision(num, precision) = {
-  if precision == none {
+  if precision == none or type(num) == _float-type and (_float-is-nan(num) or _float-is-infinite(num)) {
     return _strfmt_stringify(num)
   }
   let result = _strfmt_stringify(calc.round(float(num), digits: calc.min(50, precision)))
@@ -228,7 +262,7 @@
   let mantissa = f / calc.pow(10, exponent)
   let mantissa = _strfmt_with-precision(mantissa, precision)
 
-  mantissa + exponent-sign + _strfmt_stringify(exponent)
+  (mantissa, exponent-sign + _strfmt_stringify(exponent))
 }
 
 // Parses {format:specslikethis}.
@@ -244,16 +278,37 @@ type := '' | '?' | 'x?' | 'X?' | identifier
 count := parameter | integer
 parameter := argument '$'
 */
-#let _generate-replacement(fullname, extras, replacement, pos-replacements: (), named-replacements: (:), fmt-decimal-separator: auto) = {
+#let _generate-replacement(
+  fullname, extras, replacement,
+  pos-replacements: (), named-replacements: (:),
+  fmt-decimal-separator: auto,
+  fmt-thousands-count: 3,
+  fmt-thousands-separator: ""
+) = {
   if extras == none {
-    if not _strfmt_is-numeric-type(replacement) {
-      fmt-decimal-separator = auto
-    }
-    replacement = _strfmt_stringify(replacement)
-    if fmt-decimal-separator not in (auto, none) {
-      replacement = replacement.replace(".", _strfmt_stringify(fmt-decimal-separator))
+    let is-numeric = _strfmt_is-numeric-type(replacement)
+
+    if is-numeric {
+      let is-nan = type(replacement) == _float-type and _float-is-nan(replacement)
+      let string-replacement = _strfmt_stringify(calc.abs(replacement))
+      let sign = if not is-nan and replacement < 0 { "-" } else { "" }
+      let (integral, ..fractional) = string-replacement.split(".")
+      if fmt-thousands-separator != "" and (type(replacement) != _float-type or not _float-is-nan(replacement) and not _float-is-infinite(replacement)) {
+        integral = _arr-chunks(integral.codepoints().rev(), fmt-thousands-count)
+          .join(fmt-thousands-separator.codepoints().rev())
+          .rev()
+          .join()
+      }
+
+      if fractional.len() > 0 {
+        let decimal-separator = if fmt-decimal-separator not in (auto, none) { _strfmt_stringify(fmt-decimal-separator) } else { "." }
+        return sign + integral + decimal-separator + fractional.first()
+      } else {
+        return sign + integral
+      }
+    } else {
+      return _strfmt_stringify(replacement)
     }
-    return replacement
   }
   let extras = _strfmt_stringify(extras)
   // note: usage of [\s\S] in regex to include all characters, incl. newline
@@ -345,6 +400,7 @@ parameter := argument '$'
 
   let is-numeric = _strfmt_is-numeric-type(replacement)
   if is-numeric {
+    let is-nan = type(replacement) == _float-type and _float-is-nan(replacement)
     if zero {
       // disable fill, we will be prefixing with zeroes if necessary
       fill = none
@@ -358,9 +414,9 @@ parameter := argument '$'
     }
 
     // if + is specified, + will appear before all numbers >= 0.
-    if sign == "+" and replacement >= 0 {
+    if sign == "+" and not is-nan and replacement >= 0 {
       sign = "+"
-    } else if replacement < 0 {
+    } else if not is-nan and replacement < 0 {
       sign = "-"
     } else {
       sign = ""
@@ -369,37 +425,65 @@ parameter := argument '$'
     // we'll add the sign back later!
     replacement = calc.abs(replacement)
 
+    // Separate integral from fractional parts
+    // We'll recompose them later
+    let integral = ""
+    let fractional = ()
+    let exponent-suffix = ""
+
     if spectype in ("e", "E") {
       let exponent-sign = if spectype == "E" { "E" } else { "e" }
-      replacement = _strfmt_exp-format(calc.abs(replacement), exponent-sign: exponent-sign, precision: precision)
+      let (mantissa, exponent) = _strfmt_exp-format(calc.abs(replacement), exponent-sign: exponent-sign, precision: precision)
+      (integral, ..fractional) = mantissa.split(".")
+      exponent-suffix = exponent
     } else if type(replacement) != _int-type and precision != none {
-      replacement = _strfmt_with-precision(replacement, precision)
+      let new-replacement = _strfmt_with-precision(replacement, precision)
+      (integral, ..fractional) = new-replacement.split(".")
     } else if type(replacement) == _int-type and spectype in ("x", "X", "b", "o", "x?", "X?") {
       let radix-map = (x: 16, X: 16, "x?": 16, "X?": 16, b: 2, o: 8)
       let radix = radix-map.at(spectype)
       let lowercase = spectype.starts-with("x")
-      replacement = _strfmt_stringify(_strfmt_display-radix(replacement, radix, lowercase: lowercase, signed: false))
+      integral = _strfmt_stringify(_strfmt_display-radix(replacement, radix, lowercase: lowercase, signed: false))
       if hashtag {
         let hashtag-prefix-map = ("16": "0x", "2": "0b", "8": "0o")
         hashtag-prefix = hashtag-prefix-map.at(str(radix))
       }
     } else {
       precision = none
-      replacement = if spectype.ends-with("?") {
-        repr(replacement)
+      let new-replacement = if spectype.ends-with("?") {
+        let repr-res = repr(replacement)
+        if using-090 and not using-0110 and type(replacement) == _float-type and "." not in repr-res {
+          // Workaround for repr inconsistency in Typst 0.9.0 and 0.10.0
+          repr-res + ".0"
+        } else {
+          repr-res
+        }
       } else {
         _strfmt_stringify(replacement)
       }
+      (integral, ..fractional) = new-replacement.split(".")
     }
-    if fmt-decimal-separator not in (auto, none) {
-      replacement = replacement.replace(".", _strfmt_stringify(fmt-decimal-separator))
-    }
+
+    let decimal-separator = if fmt-decimal-separator not in (auto, none) { _strfmt_stringify(fmt-decimal-separator) } else { "." }
+    let replaced-fractional = if fractional.len() > 0 { decimal-separator + fractional.join(decimal-separator) } else { "" }
+    let exponent-suffix = exponent-suffix.replace(".", decimal-separator)
+
     if zero {
-      let width-diff = width - (replacement.len() + sign.len() + hashtag-prefix.len())
+      let width-diff = width - (integral.len() + replaced-fractional.codepoints().len() + sign.len() + hashtag-prefix.len() + exponent-suffix.codepoints().len())
       if width-diff > 0 {  // prefix with the appropriate amount of zeroes
-        replacement = ("0" * width-diff) + replacement
+        integral = ("0" * width-diff) + integral
       }
     }
+
+    // Format with thousands AFTER zeroes, but BEFORE applying textual prefixes
+    if fmt-thousands-separator != "" and (type(replacement) != _float-type or not _float-is-nan(replacement) and not _float-is-infinite(replacement)) {
+      integral = _arr-chunks(integral.codepoints().rev(), fmt-thousands-count)
+        .join(fmt-thousands-separator.codepoints().rev())
+        .rev()
+        .join()
+    }
+
+    replacement = integral + replaced-fractional + exponent-suffix
   } else {
     sign = ""
     hashtag-prefix = ""
@@ -426,7 +510,7 @@ parameter := argument '$'
 
   if fill != none {
     // perform fill/width adjustments: "x" ---> "  x" if width is 4
-    let width-diff = width - replacement.len()  // number prefixes are also considered for width
+    let width-diff = width - replacement.codepoints().len()  // number prefixes are also considered for width
     if width-diff > 0 {
       if align == left {
         replacement = replacement + (fill * width-diff)
@@ -449,6 +533,21 @@ parameter := argument '$'
   let named-replacements = replacements.named()
   let unnamed-format-index = 0
   let fmt-decimal-separator = if "fmt-decimal-separator" in named-replacements { named-replacements.at("fmt-decimal-separator") } else { auto }
+  let fmt-thousands-count = if "fmt-thousands-count" in named-replacements { named-replacements.at("fmt-thousands-count") } else { 3 }
+  let fmt-thousands-separator = if "fmt-thousands-separator" in named-replacements { named-replacements.at("fmt-thousands-separator") } else { "" }
+
+  assert(
+    type(fmt-thousands-count) == _int-type,
+    message: "String formatter error: 'fmt-thousands-count' must be an integer, got '" + type(fmt-thousands-count) + "' instead."
+  )
+  assert(
+    fmt-thousands-count > 0,
+    message: "String formatter error: 'fmt-thousands-count' must be a positive integer, got " + str(fmt-thousands-count) + " instead."
+  )
+  assert(
+    type(fmt-thousands-separator) == _str-type,
+    message: "String formatter error: 'fmt-thousands-separator' must be a string (or empty string, \"\", to disable), got '" + type(fmt-thousands-separator) + "' instead."
+  )
 
   let parts = ()
   let last-span-end = 0
@@ -490,7 +589,7 @@ parameter := argument '$'
         }
         replace-by = named-replacements.at(name)
       }
-      replace-by = _generate-replacement(f.name, extras, replace-by, pos-replacements: num-replacements, named-replacements: named-replacements, fmt-decimal-separator: fmt-decimal-separator)
+      replace-by = _generate-replacement(f.name, extras, replace-by, pos-replacements: num-replacements, named-replacements: named-replacements, fmt-decimal-separator: fmt-decimal-separator, fmt-thousands-count: fmt-thousands-count, fmt-thousands-separator: fmt-thousands-separator)
       replace-span = f.span
     } else {
       panic("String formatter error: Internal error (unexpected format received).")
diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index 27862c1..03d8309 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -56,6 +56,46 @@
 
   // test grapheme clusters
   assert.eq(strfmt("Ĺo͂řȩ{}m̅", 5.5), "Ĺo͂řȩ5.5m̅")
+
+  // padding should use codepoint len
+  assert.eq(strfmt("{:€>15}", "Ĺo͂řȩ5.5m̅"), "€€€€€Ĺo͂řȩ5.5m̅")
+  assert.eq(strfmt("{:€>10}", "abc€d"), "€€€€€abc€d")
+}
+// Issue #5: Thousands
+#{
+  // Test separator
+  assert.eq(strfmt("{}", 10, fmt-thousands-separator: "_"), "10")
+  assert.eq(strfmt("{}", 1000, fmt-thousands-separator: ""), "1000")
+  assert.eq(strfmt("{}", 1000, fmt-thousands-separator: "_"), "1_000")
+  assert.eq(strfmt("{}", 100000000, fmt-thousands-separator: "_"), "100_000_000")
+  assert.eq(strfmt("{}", 100000000.0, fmt-thousands-separator: "_"), "100_000_000")
+  assert.eq(strfmt("{}", 10000000.3231, fmt-thousands-separator: "_"), "10_000_000.3231")
+  assert.eq(strfmt("{}", -230, fmt-thousands-separator: "_"), "-230")
+  assert.eq(strfmt("{}", -2300, fmt-thousands-separator: "_"), "-2_300")
+  assert.eq(strfmt("{}", -2300.453, fmt-thousands-separator: "_"), "-2_300.453")
+  assert.eq(strfmt("{}", 5555.2, fmt-thousands-separator: "€", fmt-decimal-separator: "€€"), "5€555€€2")
+  assert.eq(strfmt("{:010}", -23003, fmt-thousands-separator: "abc"), "-000abc023abc003")
+  assert.eq(strfmt("{:+013}", 23003.34, fmt-thousands-separator: "abc"), "+000abc023abc003.34")
+  assert.eq(strfmt("{:#b}", 255, fmt-thousands-separator: "_"), "0b11_111_111")
+  assert.eq(strfmt("{:#x}", -16 * 16 * 16 * 16 * 15, fmt-thousands-separator: "_"), "-0xf0_000")
+  assert.eq(strfmt("{:o}", -16 * 16 * 16 * 16 * 15, fmt-thousands-separator: "_"), "-3_600_000")
+  assert.eq(strfmt("{:?}", 5555.0, fmt-thousands-separator: "_"), "5_555.0")
+  assert.eq(strfmt("{:e}", 5555.2, fmt-thousands-separator: "_", fmt-decimal-separator: "heap"), "5heap5552e3")
+  assert.eq(strfmt("{:010}", 5555.2, fmt-thousands-separator: "_", fmt-decimal-separator: "€"), "00_005_555€2")
+  assert.eq(strfmt("{:€>10}", 5555.2, fmt-thousands-separator: "_", fmt-decimal-separator: "€"), "€€€5_555€2")
+  assert.eq(strfmt("{:€>10}", 5555.2, fmt-thousands-separator: "€a", fmt-decimal-separator: "€"), "€€5€a555€2")
+
+  // Test count
+  assert.eq(strfmt("{}", 10, fmt-thousands-count: 3, fmt-thousands-separator: "_"), "10")
+  assert.eq(strfmt("{}", 10, fmt-thousands-count: 1, fmt-thousands-separator: "_"), "1_0")
+  assert.eq(strfmt("{}", 1000, fmt-thousands-count: 2, fmt-thousands-separator: "_"), "10_00")
+  assert.eq(strfmt("{}", 10000000.3231, fmt-thousands-count: 2, fmt-thousands-separator: "_"), "10_00_00_00.3231")
+  assert.eq(strfmt("{}", float("nan"), fmt-thousands-count: 2, fmt-thousands-separator: "_"), "NaN")
+  assert.eq(strfmt("{:010}", -23003, fmt-thousands-count: 4, fmt-thousands-separator: "|"), "-0|0002|3003")
+  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")
 }
 // DOC TESTS
 #{

From e78fc63463bc4f0e8cad4cab17f6c7fee79381ef Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 8 Oct 2024 23:28:03 -0300
Subject: [PATCH 37/60] address more float edge cases

---
 oxifmt.typ             | 12 +++++++-----
 tests/strfmt-tests.typ | 13 +++++++++++++
 2 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/oxifmt.typ b/oxifmt.typ
index 4ca2c66..521433f 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -229,7 +229,7 @@
 }
 
 #let _strfmt_with-precision(num, precision) = {
-  if precision == none or type(num) == _float-type and (_float-is-nan(num) or _float-is-infinite(num)) {
+  if precision == none {
     return _strfmt_stringify(num)
   }
   let result = _strfmt_stringify(calc.round(float(num), digits: calc.min(50, precision)))
@@ -290,10 +290,11 @@ parameter := argument '$'
 
     if is-numeric {
       let is-nan = type(replacement) == _float-type and _float-is-nan(replacement)
+      let is-inf = type(replacement) == _float-type and _float-is-infinite(replacement)
       let string-replacement = _strfmt_stringify(calc.abs(replacement))
       let sign = if not is-nan and replacement < 0 { "-" } else { "" }
       let (integral, ..fractional) = string-replacement.split(".")
-      if fmt-thousands-separator != "" and (type(replacement) != _float-type or not _float-is-nan(replacement) and not _float-is-infinite(replacement)) {
+      if fmt-thousands-separator != "" and not is-nan and not is-inf {
         integral = _arr-chunks(integral.codepoints().rev(), fmt-thousands-count)
           .join(fmt-thousands-separator.codepoints().rev())
           .rev()
@@ -401,6 +402,7 @@ parameter := argument '$'
   let is-numeric = _strfmt_is-numeric-type(replacement)
   if is-numeric {
     let is-nan = type(replacement) == _float-type and _float-is-nan(replacement)
+    let is-inf = type(replacement) == _float-type and _float-is-infinite(replacement)
     if zero {
       // disable fill, we will be prefixing with zeroes if necessary
       fill = none
@@ -431,12 +433,12 @@ parameter := argument '$'
     let fractional = ()
     let exponent-suffix = ""
 
-    if spectype in ("e", "E") {
+    if spectype in ("e", "E") and not is-nan and not is-inf {
       let exponent-sign = if spectype == "E" { "E" } else { "e" }
       let (mantissa, exponent) = _strfmt_exp-format(calc.abs(replacement), exponent-sign: exponent-sign, precision: precision)
       (integral, ..fractional) = mantissa.split(".")
       exponent-suffix = exponent
-    } else if type(replacement) != _int-type and precision != none {
+    } else if type(replacement) != _int-type and precision != none and not is-nan and not is-inf {
       let new-replacement = _strfmt_with-precision(replacement, precision)
       (integral, ..fractional) = new-replacement.split(".")
     } else if type(replacement) == _int-type and spectype in ("x", "X", "b", "o", "x?", "X?") {
@@ -476,7 +478,7 @@ parameter := argument '$'
     }
 
     // Format with thousands AFTER zeroes, but BEFORE applying textual prefixes
-    if fmt-thousands-separator != "" and (type(replacement) != _float-type or not _float-is-nan(replacement) and not _float-is-infinite(replacement)) {
+    if fmt-thousands-separator != "" and not is-nan and not is-inf {
       integral = _arr-chunks(integral.codepoints().rev(), fmt-thousands-count)
         .join(fmt-thousands-separator.codepoints().rev())
         .rev()
diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index 03d8309..b0b6a0b 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -61,6 +61,15 @@
   assert.eq(strfmt("{:€>15}", "Ĺo͂řȩ5.5m̅"), "€€€€€Ĺo͂řȩ5.5m̅")
   assert.eq(strfmt("{:€>10}", "abc€d"), "€€€€€abc€d")
 }
+// Float edge cases
+#{
+  assert.eq(strfmt("{}", float("nan")), "NaN")
+  assert.eq(strfmt("{:05.10}", float("nan")), "00NaN")
+  assert.eq(strfmt("{:05e}", float("nan")), "00NaN")
+  assert.eq(strfmt("{:05e}", float("inf")), "00inf")
+  assert.eq(strfmt("{:+05e}", float("inf")), "+0inf")
+  assert.eq(strfmt("{:05e}", -float("inf")), "-0inf")
+}
 // Issue #5: Thousands
 #{
   // Test separator
@@ -91,11 +100,15 @@
   assert.eq(strfmt("{}", 1000, fmt-thousands-count: 2, fmt-thousands-separator: "_"), "10_00")
   assert.eq(strfmt("{}", 10000000.3231, fmt-thousands-count: 2, fmt-thousands-separator: "_"), "10_00_00_00.3231")
   assert.eq(strfmt("{}", float("nan"), fmt-thousands-count: 2, fmt-thousands-separator: "_"), "NaN")
+  assert.eq(strfmt("{}", float("inf"), fmt-thousands-count: 2, fmt-thousands-separator: "_"), "inf")
+  assert.eq(strfmt("{}", -float("inf"), fmt-thousands-count: 2, fmt-thousands-separator: "_"), "-inf")
   assert.eq(strfmt("{:010}", -23003, fmt-thousands-count: 4, fmt-thousands-separator: "|"), "-0|0002|3003")
   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")
 }
 // DOC TESTS
 #{

From c9d950ea6f0b0d1af369f5c65ec6109ff26cfafb Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 8 Oct 2024 22:43:40 -0300
Subject: [PATCH 38/60] optimize string split

---
 oxifmt.typ | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/oxifmt.typ b/oxifmt.typ
index 521433f..639efc6 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -171,19 +171,17 @@
 #let _strfmt_parse-fmt-name(name) = {
   // {a:b} => separate 'a' from 'b'
   // (also accepts {a}, {}, {0}, {:...})
-  let subparts = name.match(regex("^([^:]*)(?::(.*))?$")).captures
-  let name = subparts.at(0)
-  let extras = subparts.at(1)
+  let (name, ..extras) = name.split(":")
   let name = if type(name) != _str-type {
     name
   } else if name == "" {
     none
-  } else if regex("^\\d+$") in name {
+  } else if name.codepoints().all(x => x == "0" or x == "1" or x == "2" or x == "3" or x == "4" or x == "5" or x == "6" or x == "7" or x == "8" or x == "9") {
     int(name)
   } else {
     name
   }
-  (name, extras)
+  (name, extras.join())
 }
 
 #let _strfmt_is-numeric-type(obj) = {

From 2a4094fe06ad65c1b944cd8a72940ca9b539dae8 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 8 Oct 2024 23:58:03 -0300
Subject: [PATCH 39/60] fix inf string in 0.12.0

---
 oxifmt.typ | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/oxifmt.typ b/oxifmt.typ
index 639efc6..b712148 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -189,9 +189,16 @@
 }
 
 #let _strfmt_stringify(obj) = {
-  if type(obj) in (_int-type, _float-type) {
-    // Fix negative sign not being a hyphen
-    // for consistency with our rich formatting output
+  if type(obj) == _float-type {
+    if _float-is-infinite(obj) {
+      // Fix 0.12.0 inf string inconsistency
+      if obj < 0 { "-" } else { "" } + "inf"
+    } else {
+      // Fix negative sign not being a hyphen
+      // for consistency with our rich formatting output
+      str(obj).replace("\u{2212}", "-")
+    }
+  } else if type(obj) == _int-type {
     str(obj).replace("\u{2212}", "-")
   } else if type(obj) in (_label-type, _str-type) {
     str(obj)

From ffd108760b04c8ea7909911828fb31030a04ed2d Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Thu, 17 Oct 2024 01:43:27 -0300
Subject: [PATCH 40/60] bump ci to typst 0.12.0-rc2

---
 .github/workflows/tests-ci.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/tests-ci.yml b/.github/workflows/tests-ci.yml
index b4cdf8a..b04a1ca 100644
--- a/.github/workflows/tests-ci.yml
+++ b/.github/workflows/tests-ci.yml
@@ -22,9 +22,9 @@ jobs:
         # Test for the following Typst versions
         # 0.7.0 (earliest supported), 0.8.0,
         # 0.9.0 (first version with version checks), 0.10.0,
-        # 0.11.0, 0.11.1, 0.12-rc1 (latest supported)
+        # 0.11.0, 0.11.1, 0.12-rc2 (latest supported)
         typst-version:
-          [v0.7.0, v0.8.0, v0.9.0, v0.10.0, v0.11.0, v0.11.1, v0.12.0-rc1]
+          [v0.7.0, v0.8.0, v0.9.0, v0.10.0, v0.11.0, v0.11.1, v0.12.0-rc2]
 
     # Steps represent a sequence of tasks that will be executed as part of the job
     steps:

From 8a097d238430972832603d469467f75c6f2a9187 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sun, 9 Feb 2025 00:48:32 -0300
Subject: [PATCH 41/60] bump ci to typst 0.13.0-rc1

---
 .github/workflows/tests-ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/tests-ci.yml b/.github/workflows/tests-ci.yml
index b04a1ca..0ddea19 100644
--- a/.github/workflows/tests-ci.yml
+++ b/.github/workflows/tests-ci.yml
@@ -24,7 +24,7 @@ jobs:
         # 0.9.0 (first version with version checks), 0.10.0,
         # 0.11.0, 0.11.1, 0.12-rc2 (latest supported)
         typst-version:
-          [v0.7.0, v0.8.0, v0.9.0, v0.10.0, v0.11.0, v0.11.1, v0.12.0-rc2]
+          [v0.7.0, v0.8.0, v0.9.0, v0.10.0, v0.11.0, v0.11.1, v0.12.0, v0.13.0-rc1]
 
     # Steps represent a sequence of tasks that will be executed as part of the job
     steps:

From db4c8a4b93b18cdc7029f916c3503418efd636a4 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sun, 9 Feb 2025 00:54:01 -0300
Subject: [PATCH 42/60] fix type strings for 0.13.0

---
 oxifmt.typ | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/oxifmt.typ b/oxifmt.typ
index b712148..18a2947 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -348,7 +348,7 @@ parameter := argument '$'
       let arg = pos-replacements.at(i)
       assert(
         type(arg) == _int-type,
-        message: "String formatter error: Attempted to use positional argument " + str(i) + " for " + spec-part-name + ", but it was a(n) '" + type(arg) + "', not an integer (from '{" + fullname.replace("{", "{{").replace("}", "}}") + "}')."
+        message: "String formatter error: Attempted to use positional argument " + str(i) + " for " + spec-part-name + ", but it was a(n) '" + str(type(arg)) + "', not an integer (from '{" + fullname.replace("{", "{{").replace("}", "}}") + "}')."
       )
 
       int(arg)
@@ -364,7 +364,7 @@ parameter := argument '$'
       let arg = named-replacements.at(named)
       assert(
         type(arg) == _int-type,
-        message: "String formatter error: Attempted to use named argument '" + named + "' for " + spec-part-name + ", but it was a(n) '" + type(arg) + "', not an integer (from '{" + fullname.replace("{", "{{").replace("}", "}}") + "}')."
+        message: "String formatter error: Attempted to use named argument '" + named + "' for " + spec-part-name + ", but it was a(n) '" + str(type(arg)) + "', not an integer (from '{" + fullname.replace("{", "{{").replace("}", "}}") + "}')."
       )
 
       int(arg)
@@ -545,7 +545,7 @@ parameter := argument '$'
 
   assert(
     type(fmt-thousands-count) == _int-type,
-    message: "String formatter error: 'fmt-thousands-count' must be an integer, got '" + type(fmt-thousands-count) + "' instead."
+    message: "String formatter error: 'fmt-thousands-count' must be an integer, got '" + str(type(fmt-thousands-count)) + "' instead."
   )
   assert(
     fmt-thousands-count > 0,
@@ -553,7 +553,7 @@ parameter := argument '$'
   )
   assert(
     type(fmt-thousands-separator) == _str-type,
-    message: "String formatter error: 'fmt-thousands-separator' must be a string (or empty string, \"\", to disable), got '" + type(fmt-thousands-separator) + "' instead."
+    message: "String formatter error: 'fmt-thousands-separator' must be a string (or empty string, \"\", to disable), got '" + str(type(fmt-thousands-separator)) + "' instead."
   )
 
   let parts = ()

From d9f56b26d1863ffc2bffd7f8efa075b3f9eb742d Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sun, 25 May 2025 18:44:08 -0300
Subject: [PATCH 43/60] Add 0.12.0 decimal support (#14)

* initial decimal attempt

* proper exp syntax support for decimals

* support signed zero

* add more tests
---
 oxifmt.typ             | 92 +++++++++++++++++++++++++++++++++++++-----
 tests/strfmt-tests.typ | 28 ++++++++++++-
 2 files changed, 108 insertions(+), 12 deletions(-)

diff --git a/oxifmt.typ b/oxifmt.typ
index 18a2947..be8c2ce 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -6,9 +6,13 @@
 #let _str-type = type("")
 #let _label-type = type(<hello>)
 
+#let _minus-sign = "\u{2212}"
 #let using-080 = type(type(5)) != _str-type
-#let using-090 = using-080 and str(-1).codepoints().first() == "\u{2212}"
+#let using-090 = using-080 and str(-1).codepoints().first() == _minus-sign
 #let using-0110 = using-090 and sys.version >= version(0, 11, 0)
+#let using-0120 = using-090 and sys.version >= version(0, 12, 0)
+
+#let _decimal = if using-0120 { decimal } else { none }
 
 #let _arr-chunks = if using-0110 {
   array.chunks
@@ -185,7 +189,7 @@
 }
 
 #let _strfmt_is-numeric-type(obj) = {
-  type(obj) in (_int-type, _float-type)
+  type(obj) in (_int-type, _float-type, _decimal)
 }
 
 #let _strfmt_stringify(obj) = {
@@ -200,7 +204,7 @@
     }
   } else if type(obj) == _int-type {
     str(obj).replace("\u{2212}", "-")
-  } else if type(obj) in (_label-type, _str-type) {
+  } else if type(obj) in (_label-type, _str-type, _decimal) {
     str(obj)
   } else {
     repr(obj)
@@ -212,6 +216,8 @@
   if type(radix) != _int-type or num == 0 or radix <= 1 {
     return "0"
   }
+
+  // Note: only integers are accepted here, so no need to check for decimal signed zero
   let sign = if num < 0 and signed { "-" } else { "" }
   let num = calc.abs(num)
   let radix = calc.min(radix, 16)
@@ -237,7 +243,7 @@
   if precision == none {
     return _strfmt_stringify(num)
   }
-  let result = _strfmt_stringify(calc.round(float(num), digits: calc.min(50, precision)))
+  let result = _strfmt_stringify(calc.round(if type(num) == _decimal { num } else { float(num) }, digits: calc.min(50, precision)))
   let digits-match = result.match(regex("^\\d+\\.(\\d+)$"))
   let digits-len-diff = 0
   if digits-match != none and digits-match.captures.len() > 0 {
@@ -260,10 +266,56 @@
   result
 }
 
-#let _strfmt_exp-format(num, exponent-sign: "e", base: 10, precision: none) = {
+#let _strfmt_exp-format(num, exponent-sign: "e", precision: none) = {
   assert(_strfmt_is-numeric-type(num), message: "String formatter internal error: Cannot convert '" + repr(num) + "' to a number to obtain its scientific notation representation.")
+
+  if type(num) == _decimal {
+    // Normalize signed zero
+    let num = if num == 0 { _decimal("0") } else { num }
+    let (integral, ..fractional) = str(num).split(".")
+    // 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") }
+      assert(first-non-zero != none, message: "String formatter internal error: expected non-zero fractional digit")
+
+      // Integral part is zero
+      // Convert 0.00012345 -> 1.2345
+      // Position of first non-zero is the amount of zeroes - 1
+      // (e.g. above, position of 1 is 3 => 3 zeroes,
+      // so exponent is -3 - 1 = -4)
+      (
+        fractional.at(first-non-zero),
+        fractional.slice(first-non-zero + 1),
+        -first-non-zero - 1
+      )
+    } else {
+      // Number has non-zero integral part, or is zero
+      // Convert 12345.6789 -> 1.23456789
+      // Exponent is integral digits - 1
+      (
+        integral.at(0),
+        integral.slice(1) + fractional,
+        integral.len() - 1
+      )
+    }
+    return (
+      // mantissa
+      integral + if fractional != "" { "." + fractional } else { "" },
+      exponent-sign + _strfmt_stringify(exponent)
+    )
+  }
+
   let f = float(num)
-  let exponent = if f == 0 { 1 } else { calc.floor(calc.log(calc.abs(f), base: base)) }
+  let exponent = if f == 0 { 1 } else { calc.floor(calc.log(calc.abs(f), base: 10)) }
   let mantissa = f / calc.pow(10, exponent)
   let mantissa = _strfmt_with-precision(mantissa, precision)
 
@@ -297,7 +349,17 @@ parameter := argument '$'
       let is-nan = type(replacement) == _float-type and _float-is-nan(replacement)
       let is-inf = type(replacement) == _float-type and _float-is-infinite(replacement)
       let string-replacement = _strfmt_stringify(calc.abs(replacement))
-      let sign = if not is-nan and replacement < 0 { "-" } else { "" }
+      let sign = if (
+        not is-nan and replacement < 0
+        or replacement == 0 and type(replacement) == _decimal and (
+          // Preserve signed zero decimal
+          "-" in str(replacement) or _minus-sign in str(replacement)
+        )
+      ) {
+        "-"
+      } else {
+        ""
+      }
       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)
@@ -404,8 +466,7 @@ parameter := argument '$'
     spec-error()
   }
 
-  let is-numeric = _strfmt_is-numeric-type(replacement)
-  if is-numeric {
+  if _strfmt_is-numeric-type(replacement) {
     let is-nan = type(replacement) == _float-type and _float-is-nan(replacement)
     let is-inf = type(replacement) == _float-type and _float-is-infinite(replacement)
     if zero {
@@ -420,8 +481,17 @@ parameter := argument '$'
       align = right
     }
 
-    // if + is specified, + will appear before all numbers >= 0.
-    if sign == "+" and not is-nan and replacement >= 0 {
+    if replacement == 0 and type(replacement) == _decimal {
+      // Preserve signed zero.
+      if "-" in str(replacement) or _minus-sign in str(replacement) {
+        sign = "-"
+      } else if sign == "+" {
+        sign = "+"
+      } else {
+        sign = ""
+      }
+    } else if sign == "+" and not is-nan and replacement >= 0 {
+      // if + is specified, + will appear before all numbers >= 0.
       sign = "+"
     } else if not is-nan and replacement < 0 {
       sign = "-"
diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index b0b6a0b..e78d67d 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -1,4 +1,4 @@
-#import "../oxifmt.typ": strfmt
+#import "../oxifmt.typ": strfmt, using-0120
 
 #{
   // test basics (sequential args, named args, pos args)
@@ -110,6 +110,32 @@
   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")
 }
+// Issue #11: Decimals
+#if using-0120 {
+  assert.eq(strfmt("{}", decimal("1223.4350320000")), "1223.4350320000")
+  assert.eq(strfmt("{}", decimal("1223.435032")), "1223.435032")
+  assert.eq(strfmt("{}", decimal("-1223.435032")), "-1223.435032")
+  assert.eq(strfmt("{}", decimal("-1223.435032"), fmt-thousands-separator: "_"), "-1_223.435032")
+  assert.eq(strfmt("{}", decimal("0")), "0")
+  assert.eq(strfmt("{}", -decimal("0")), "-0")
+  assert.eq(strfmt("{:+}", decimal("0")), "+0")
+  assert.eq(strfmt("{:+}", -decimal("0")), "-0")
+  assert.eq(strfmt("{:+09}", decimal("1231422")), "+01231422")
+  assert.eq(strfmt("{:+09}", decimal("1234.5")), "+001234.5")
+  assert.eq(strfmt("{:+09}", decimal("1234.5"), fmt-thousands-separator: "_"), "+001_234.5")
+  assert.eq(strfmt("{:+09}", decimal("0.0001")), "+000.0001")
+  assert.eq(strfmt("{:011e}", decimal("1231422")), "01.231422e6")
+  assert.eq(strfmt("{:011e}", -decimal("1234.5")), "-001.2345e3")
+  assert.eq(strfmt("{:011e}", -decimal("1234.50000")), "-001.2345e3")
+  assert.eq(strfmt("{:011e}", -decimal("0.00012345")), "-01.2345e-4")
+  assert.eq(strfmt("{:011e}", decimal("0.0001")), "00000001e-4")
+  assert.eq(strfmt("{:e}", decimal("0.0001")), "1e-4")
+  assert.eq(strfmt("{:e}", decimal("0")), "0e0")
+  assert.eq(strfmt("{:e}", -decimal("0")), "-0e0")
+  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")
+}
 // DOC TESTS
 #{
   // --- Usage ---

From 07c94c9fcd96bf1cd5118fd4f33d20f807a4db76 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sun, 25 May 2025 18:46:41 -0300
Subject: [PATCH 44/60] add 0.13.1 to ci

---
 .github/workflows/tests-ci.yml | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/tests-ci.yml b/.github/workflows/tests-ci.yml
index 0ddea19..8763328 100644
--- a/.github/workflows/tests-ci.yml
+++ b/.github/workflows/tests-ci.yml
@@ -22,9 +22,19 @@ jobs:
         # Test for the following Typst versions
         # 0.7.0 (earliest supported), 0.8.0,
         # 0.9.0 (first version with version checks), 0.10.0,
-        # 0.11.0, 0.11.1, 0.12-rc2 (latest supported)
+        # 0.11.0, 0.11.1, 0.13.1 (latest supported)
         typst-version:
-          [v0.7.0, v0.8.0, v0.9.0, v0.10.0, v0.11.0, v0.11.1, v0.12.0, v0.13.0-rc1]
+          [
+            v0.7.0,
+            v0.8.0,
+            v0.9.0,
+            v0.10.0,
+            v0.11.0,
+            v0.11.1,
+            v0.12.0,
+            v0.13.0,
+            v0.13.1,
+          ]
 
     # Steps represent a sequence of tasks that will be executed as part of the job
     steps:

From 6722193e5f67bc5270536fd93b683043b8c7c088 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sun, 25 May 2025 19:07:52 -0300
Subject: [PATCH 45/60] Fix large numbers (#18)

* fix large numbers

* more cross-compatible infinite float
---
 oxifmt.typ             |  2 +-
 tests/strfmt-tests.typ | 17 +++++++++++++++++
 2 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/oxifmt.typ b/oxifmt.typ
index be8c2ce..6b8d9e7 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -316,7 +316,7 @@
 
   let f = float(num)
   let exponent = if f == 0 { 1 } else { calc.floor(calc.log(calc.abs(f), base: 10)) }
-  let mantissa = f / calc.pow(10, exponent)
+  let mantissa = f / calc.pow(10.0, exponent)
   let mantissa = _strfmt_with-precision(mantissa, precision)
 
   (mantissa, exponent-sign + _strfmt_stringify(exponent))
diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index e78d67d..6295c45 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -136,6 +136,23 @@
   assert.eq(strfmt("{:e}", decimal("-132423")), "-1.32423e5")
   assert.eq(strfmt("{:011.5}", decimal("1234.5")), "01234.50000")
 }
+// Issue #16: large numbers
+#{
+  assert.eq(strfmt("{0:e}",10000000000000000000.0), "1e19")
+  assert.eq(strfmt("{0:e}",10000000000000000000), "1e19")
+  assert.eq(strfmt("{0:e}",float("inf")), "inf")
+  assert.eq(strfmt("{0:e}",float("-inf")), "-inf")
+  assert.eq(strfmt("{0:e}",float("nan")), "NaN")
+  assert.eq(strfmt("{0:e}",1e50), "1e50")
+  assert.eq(strfmt("{0:e}",1e-50), "1.0000000000000002e-50")
+  assert.eq(strfmt("{0:.0e}",1e-50), "1e-50")
+  assert.eq(strfmt("{0:e}",1e300), "0.9999999999999994e300")
+  assert.eq(strfmt("{0:.0e}",1e300), "1e300")
+  assert.eq(strfmt("{0:.0e}",1e-300), "1e-300")
+  assert.eq(strfmt("{0:e}",2.2250738585072014e-308), "2.2250738585072027e-308")
+  assert.eq(strfmt("{0:e}",1.7976931348623157e+308), "1.7976931348623146e308")
+  assert.eq(strfmt("{0:e}",-1.7976931348623157e+308), "-1.7976931348623146e308")
+}
 // DOC TESTS
 #{
   // --- Usage ---

From 573e3a55b773cb16bec37165d9dd147ff69aa3f1 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sun, 25 May 2025 19:18:21 -0300
Subject: [PATCH 46/60] Reserve `fmt-` prefix for options (#19)

---
 oxifmt.typ             | 18 +++++++++++++++---
 tests/strfmt-tests.typ |  3 ---
 2 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/oxifmt.typ b/oxifmt.typ
index 6b8d9e7..c1be2b0 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -609,9 +609,21 @@ parameter := argument '$'
   let num-replacements = replacements.pos()
   let named-replacements = replacements.named()
   let unnamed-format-index = 0
-  let fmt-decimal-separator = if "fmt-decimal-separator" in named-replacements { named-replacements.at("fmt-decimal-separator") } else { auto }
-  let fmt-thousands-count = if "fmt-thousands-count" in named-replacements { named-replacements.at("fmt-thousands-count") } else { 3 }
-  let fmt-thousands-separator = if "fmt-thousands-separator" in named-replacements { named-replacements.at("fmt-thousands-separator") } else { "" }
+  let fmt-decimal-separator = auto
+  let fmt-thousands-count = 3
+  let fmt-thousands-separator = ""
+
+  for (name, value) in named-replacements {
+    if name == "fmt-decimal-separator" {
+      fmt-decimal-separator = named-replacements.remove(name)
+    } else if name == "fmt-thousands-count" {
+      fmt-thousands-count = named-replacements.remove(name)
+    } else if name == "fmt-thousands-separator" {
+      fmt-thousands-separator = named-replacements.remove(name)
+    } else if name.starts-with("fmt-") {
+      assert(false, message: "String formatter error: unknown format option '" + name + "'. Keys prefixed with 'fmt-' are reserved for future oxifmt options. Please use a different key name.")
+    }
+  }
 
   assert(
     type(fmt-thousands-count) == _int-type,
diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index 6295c45..b02503a 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -42,9 +42,6 @@
 
   // test custom decimal separators (II) - weird values
   assert.eq(strfmt("{}; {:015e}; {}; {}; {:?}", 1.532, 45000, -5.6, "a.b", "c.d", fmt-decimal-separator: (a: 5)), "1(a: 5)532; 000004(a: 5)5e4; -5(a: 5)6; a.b; \"c.d\"")
-
-  // test custom decimal separators (III) - ensure we can fetch it from inside
-  assert.eq(strfmt("5{fmt-decimal-separator}6", fmt-decimal-separator: "|"), "5|6")
 }
 // Issue #6: UTF-8
 #{

From f8a2c8ec511617f1afa475f5ca6d1f96fb2eb3f0 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sun, 25 May 2025 19:24:43 -0300
Subject: [PATCH 47/60] use named args for fmt- options

---
 oxifmt.typ             | 33 +++++++++++++++++----------------
 tests/strfmt-tests.typ |  2 +-
 2 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/oxifmt.typ b/oxifmt.typ
index c1be2b0..8300d5e 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -603,28 +603,23 @@ parameter := argument '$'
   replacement
 }
 
-#let strfmt(format, ..replacements) = {
+#let strfmt(
+  format,
+  ..replacements,
+  fmt-decimal-separator: auto,
+  fmt-thousands-count: 3,
+  fmt-thousands-separator: "",
+) = {
   if format == "" { return "" }
   let formats = _strfmt_formatparser(format)
   let num-replacements = replacements.pos()
   let named-replacements = replacements.named()
   let unnamed-format-index = 0
-  let fmt-decimal-separator = auto
-  let fmt-thousands-count = 3
-  let fmt-thousands-separator = ""
-
-  for (name, value) in named-replacements {
-    if name == "fmt-decimal-separator" {
-      fmt-decimal-separator = named-replacements.remove(name)
-    } else if name == "fmt-thousands-count" {
-      fmt-thousands-count = named-replacements.remove(name)
-    } else if name == "fmt-thousands-separator" {
-      fmt-thousands-separator = named-replacements.remove(name)
-    } else if name.starts-with("fmt-") {
-      assert(false, message: "String formatter error: unknown format option '" + name + "'. Keys prefixed with 'fmt-' are reserved for future oxifmt options. Please use a different key name.")
-    }
-  }
 
+  assert(
+    fmt-decimal-separator == auto or type(fmt-decimal-separator) == str,
+    message: "String formatter error: 'fmt-decimal-separator' must be a string, got '" + str(type(fmt-decimal-separator)) + "' instead."
+  )
   assert(
     type(fmt-thousands-count) == _int-type,
     message: "String formatter error: 'fmt-thousands-count' must be an integer, got '" + str(type(fmt-thousands-count)) + "' instead."
@@ -638,6 +633,12 @@ parameter := argument '$'
     message: "String formatter error: 'fmt-thousands-separator' must be a string (or empty string, \"\", to disable), got '" + str(type(fmt-thousands-separator)) + "' instead."
   )
 
+  for (name, _) in named-replacements {
+    if name.starts-with("fmt-") {
+      assert(false, message: "String formatter error: unknown format option '" + name + "'. Keys prefixed with 'fmt-' are reserved for future oxifmt options. Please use a different key name.")
+    }
+  }
+
   let parts = ()
   let last-span-end = 0
   for f in formats {
diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index b02503a..773e880 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -41,7 +41,7 @@
   assert.eq(strfmt("{}; {:07e}; {}; {}; {:?}", 1.532, 45000, -5.6, "a.b", "c.d", fmt-decimal-separator: ","), "1,532; 004,5e4; -5,6; a.b; \"c.d\"")
 
   // test custom decimal separators (II) - weird values
-  assert.eq(strfmt("{}; {:015e}; {}; {}; {:?}", 1.532, 45000, -5.6, "a.b", "c.d", fmt-decimal-separator: (a: 5)), "1(a: 5)532; 000004(a: 5)5e4; -5(a: 5)6; a.b; \"c.d\"")
+  assert.eq(strfmt("{}; {:015e}; {}; {}; {:?}", 1.532, 45000, -5.6, "a.b", "c.d", fmt-decimal-separator: repr((a: 5))), "1(a: 5)532; 000004(a: 5)5e4; -5(a: 5)6; a.b; \"c.d\"")
 }
 // Issue #6: UTF-8
 #{

From f1b9edc23fa85a4b8abb77f32e45338322653e97 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sun, 25 May 2025 19:27:20 -0300
Subject: [PATCH 48/60] proper fmt- option type checking

---
 oxifmt.typ | 43 +++++++++++++++++++++++++++----------------
 1 file changed, 27 insertions(+), 16 deletions(-)

diff --git a/oxifmt.typ b/oxifmt.typ
index 8300d5e..e85639a 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -616,22 +616,33 @@ parameter := argument '$'
   let named-replacements = replacements.named()
   let unnamed-format-index = 0
 
-  assert(
-    fmt-decimal-separator == auto or type(fmt-decimal-separator) == str,
-    message: "String formatter error: 'fmt-decimal-separator' must be a string, got '" + str(type(fmt-decimal-separator)) + "' instead."
-  )
-  assert(
-    type(fmt-thousands-count) == _int-type,
-    message: "String formatter error: 'fmt-thousands-count' must be an integer, got '" + str(type(fmt-thousands-count)) + "' instead."
-  )
-  assert(
-    fmt-thousands-count > 0,
-    message: "String formatter error: 'fmt-thousands-count' must be a positive integer, got " + str(fmt-thousands-count) + " instead."
-  )
-  assert(
-    type(fmt-thousands-separator) == _str-type,
-    message: "String formatter error: 'fmt-thousands-separator' must be a string (or empty string, \"\", to disable), got '" + str(type(fmt-thousands-separator)) + "' instead."
-  )
+  if fmt-decimal-separator != auto and type(fmt-decimal-separator) != str {
+    assert(
+      false,
+      message: "String formatter error: 'fmt-decimal-separator' must be a string or 'auto', got '" + str(type(fmt-decimal-separator)) + "' instead."
+    )
+  }
+
+  if type(fmt-thousands-count) != _int-type {
+    assert(
+      false,
+      message: "String formatter error: 'fmt-thousands-count' must be an integer, got '" + str(type(fmt-thousands-count)) + "' instead."
+    )
+  }
+
+  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."
+    )
+  }
+
+  if type(fmt-thousands-separator) != _str-type {
+    assert(
+      false,
+      message: "String formatter error: 'fmt-thousands-separator' must be a string (or empty string, \"\", to disable), got '" + str(type(fmt-thousands-separator)) + "' instead."
+    )
+  }
 
   for (name, _) in named-replacements {
     if name.starts-with("fmt-") {

From f3ec9bfdac7ac4d182c4a2fa5079fcc5b349eab0 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sun, 25 May 2025 19:28:55 -0300
Subject: [PATCH 49/60] use _str-type

---
 oxifmt.typ | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/oxifmt.typ b/oxifmt.typ
index e85639a..cf4928e 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -616,7 +616,7 @@ parameter := argument '$'
   let named-replacements = replacements.named()
   let unnamed-format-index = 0
 
-  if fmt-decimal-separator != auto and type(fmt-decimal-separator) != str {
+  if fmt-decimal-separator != auto and type(fmt-decimal-separator) != _str-type {
     assert(
       false,
       message: "String formatter error: 'fmt-decimal-separator' must be a string or 'auto', got '" + str(type(fmt-decimal-separator)) + "' instead."

From 05aaa3030c75d0f9c905f58393dcb343e173b3e2 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sun, 25 May 2025 22:39:57 -0300
Subject: [PATCH 50/60] fix typo

---
 oxifmt.typ | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/oxifmt.typ b/oxifmt.typ
index cf4928e..c12882e 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -436,7 +436,7 @@ parameter := argument '$'
   }
 
   if precision-lit == "*" {
-    panic("String formater error: Precision specification of type `.*` is not supported yet (from '{" + fullname.replace("{", "{{").replace("}", "}}") + "}'). Try specifying your desired precision directly on the format spec, e.g. `.5`, or through some argument, e.g. `.name$` to take it from the 'name' named argument.")
+    panic("String formatter error: Precision specification of type `.*` is not supported yet (from '{" + fullname.replace("{", "{{").replace("}", "}}") + "}'). Try specifying your desired precision directly on the format spec, e.g. `.5`, or through some argument, e.g. `.name$` to take it from the 'name' named argument.")
   }
 
   let align = if align == "" {

From c5a40664534f68cd26371170a276a31a012e048b Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Mon, 26 May 2025 09:49:49 -0300
Subject: [PATCH 51/60] Release 0.3.0 (#20)

---
 LICENSE                |   1 +
 README.md              | 101 +++++++++++++++++++++++++++++++++--------
 bin/package.sh         |  17 +++++++
 tests/strfmt-tests.typ |  47 +++++++++++++++++++
 typst.toml             |   2 +-
 5 files changed, 149 insertions(+), 19 deletions(-)
 create mode 100644 LICENSE
 create mode 100755 bin/package.sh

diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..03f646f
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1 @@
+MIT OR Apache-2.0
diff --git a/README.md b/README.md
index ac10e3c..c52e57f 100644
--- a/README.md
+++ b/README.md
@@ -1,16 +1,44 @@
-# typst-oxifmt (v0.2.1)
+# typst-oxifmt (v0.3.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.
+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.
 
-A few extras (beyond the Rust-like syntax) will be added over time, though (feel free to drop suggestions at the repository: https://github.com/PgBiel/typst-oxifmt). The first "extra" so far is the `fmt-decimal-separator: "string"` parameter, which lets you customize the decimal separator for decimal numbers (floats) inserted into strings. E.g. `strfmt("Result: {}", 5.8, fmt-decimal-separator: ",")` will return the string `"Result: 5,8"` (comma instead of dot). See more below.
+A few extras (beyond the Rust-like syntax) will be added over time, though (feel free to drop suggestions at the repository: https://github.com/PgBiel/typst-oxifmt). The first "extra" so far is the `fmt-decimal-separator: "string"` parameter, which lets you customize the decimal separator for decimal numbers (floats) inserted into strings. E.g. `strfmt("Result: {}", 5.8, fmt-decimal-separator: ",")` will return the string `"Result: 5,8"` (comma instead of dot). We also provide thousands separator support with `fmt-thousands-separator: "_"` for example. See more at ["Custom options"](#custom-options).
 
-**Compatible with:** [Typst](https://github.com/typst/typst) v0.4.0+
+**Compatible with:** [Typst](https://github.com/typst/typst) v0.7.0+
+
+## Quick examples
+
+```typ
+#import "@preview/oxifmt:0.3.0": strfmt
+
+// "User John has 10 apples."
+#strfmt("User {} has {} apples.", "John", 10)
+
+// "if exp > 100 { true }"
+#strfmt("if {var} > {num} {{ true }}", var: "exp", num: 100)
+
+// "1.10e2 meters"
+#strfmt("{:.2e} meters", 110.0)
+
+// "20_000 players have more than +002,300 points."
+#strfmt(
+  "{} players have more than {:+08.3} points.",
+  20000,
+  2.3,
+  fmt-decimal-separator: ",",
+  fmt-thousands-separator: "_"
+)
+
+// "The byte value is 0x8C or 10001100"
+#strfmt("The byte value is {:#02X} or {0:08b}", 140)
+```
 
 ## Table of Contents
 
 - [Usage](#usage)
     - [Formatting options](#formatting-options)
     - [Examples](#examples)
+    - [Custom options](#custom-options)
     - [Grammar](#grammar)
 - [Issues and Contributing](#issues-and-contributing)
 - [Testing](#testing)
@@ -22,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.2.1": strfmt
+#import "@preview/oxifmt:0.3.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):
@@ -36,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.2.1": strfmt
+#import "@preview/oxifmt:0.3.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}.")
@@ -67,6 +95,8 @@ You can use `{:spec}` to customize your output. See the Rust docs linked above f
     - Add `e` or `E` at the end of the `spec` to ensure the number is represented in scientific notation (with `e` or `E` as the exponent separator, respectively).
     - For decimal numbers (floats), you can specify `fmt-decimal-separator: ","` to `strfmt` to have the decimal separator be a comma instead of a dot, for example.
         - To have this be the default, you can alias `strfmt`, such as using `#let strfmt = strfmt.with(fmt-decimal-separator: ",")`.
+    - You can enable thousands separators for numbers with `fmt-thousands-separator: "_"` to separate with an underscore, for example.
+    - By default, thousands separators are inserted after every third digit from the end of the number. Use `fmt-thousands-count: 2` to change that to every second digit as an example.
     - Number spec arguments (such as `.5`) are ignored when the argument is not a number, but e.g. a string, even if it looks like a number (such as `"5"`).
 - Note that all spec arguments above **have to be specified in order** - if you mix up the order, it won't work properly!
     - Check the grammar below for the proper order, but, in summary: fill (character) with align (`<`, `>` or `^`) -> sign (`+` or `-`) -> `#` -> `0` (for 0 left-padding of numbers) -> width (e.g. `8` from `08` or `9` from `-<9`) -> `.precision` -> spec type (`?`, `x`, `X`, `b`, `o`, `e`, `E`)).
@@ -74,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.2.1": strfmt
+#import "@preview/oxifmt:0.3.0": strfmt
 
 #let s1 = strfmt("{0:?}, {test:+012e}, {1:-<#8x}", "hi", -74, test: 569.4)
 #assert.eq(s1, "\"hi\", +00005.694e2, -0x4a---")
@@ -90,7 +120,7 @@ Some examples:
 
 - **Inserting labels, text and numbers into strings:**
 ```typ
-#import "@preview/oxifmt:0.2.1": strfmt
+#import "@preview/oxifmt:0.3.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})")
@@ -98,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.2.1": strfmt
+#import "@preview/oxifmt:0.3.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>")
@@ -106,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.2.1": strfmt
+#import "@preview/oxifmt:0.3.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]")
@@ -114,7 +144,7 @@ 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.2.1": strfmt
+#import "@preview/oxifmt:0.3.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")
@@ -123,7 +153,7 @@ Some examples:
 
 - **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.2.1": strfmt
+#import "@preview/oxifmt:0.3.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")
@@ -131,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.2.1": strfmt
+#import "@preview/oxifmt:0.3.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
@@ -139,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.2.1": strfmt
+#import "@preview/oxifmt:0.3.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")
@@ -148,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.2.1": strfmt
+#import "@preview/oxifmt:0.3.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")
@@ -156,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.2.1": strfmt
+#import "@preview/oxifmt:0.3.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")
@@ -164,20 +194,40 @@ Some examples:
 
 - **Scientific notation:** Use `e` (lowercase) or `E` (uppercase) as specifier types (can be combined with precision):
 ```typ
-#import "@preview/oxifmt:0.2.1": strfmt
+#import "@preview/oxifmt:0.3.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")
 ```
 
+### Custom options
+
+Oxifmt has some additional formatting options laid on top of Rust's, listed below with examples:
+
 - **Customizing the decimal separator on floats:** Just specify `fmt-decimal-separator: ","` (comma as an example):
 ```typ
-#import "@preview/oxifmt:0.2.1": strfmt
+#import "@preview/oxifmt:0.3.0": strfmt
 
 #let s = strfmt("{0} {0:.6} {0:.5e}", 1.432, fmt-decimal-separator: ",")
 #assert.eq(s, "1,432 1,432000 1,43200e0")
 ```
 
+- **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
+
+#let s = strfmt("{}", 20000, fmt-thousands-separator: "_")
+#assert.eq(s, "20_000")
+```
+
+- **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
+
+#let s = strfmt("{}", 20000, fmt-thousands-count: 2, fmt-thousands-separator: "_")
+#assert.eq(s, "2_00_00")
+```
+
 ### Grammar
 
 Here's the grammar specification for valid format `spec`s (in `{name:spec}`), which is basically Rust's format:
@@ -214,6 +264,21 @@ The tests succeeded if you received no error messages from the last command (ple
 
 ## Changelog
 
+### v0.3.0
+
+- **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).
+- Added thousands separator support, configurable with `strfmt(format, fmt-thousands-count: 3, fmt-thousands-separator: "")`. The first option defines how many digits should appear between each separator, and the second option controls the separator itself (default is empty string, disabling it). ([Issue #5](https://github.com/PgBiel/typst-oxifmt/issues/5))
+  - For example, `strfmt("{}", 2000, fmt-thousands-separator: ",")` displays `"2,000"`.
+  - Within the same example, adding `fmt-thousands-count: 2` would display `20,00` instead.
+  - Numeric systems with irregular thousands separator distances will be supported in a future release.
+- Added support for numeric formatting of [fixed-point `decimal` numbers](https://typst.app/docs/reference/foundations/decimal/). They support the same format specifiers as floats, e.g. `{:e}` for exponential notation, `{:.3}` for a fixed precision and so on. ([Issue #11](https://github.com/PgBiel/typst-oxifmt/issues/11))
+- oxifmt is now dual-licensed as MIT or Apache-2.0 (previously just MIT).
+- Fixed some bugs when formatting `inf` and `NaN`.
+- Fixed a rare case of wrong usage of types in strings in internal code, which could cause oxifmt to generate an error in upcoming Typst v0.14. **It is recommended to upgrade oxifmt to avoid this problem.**
+  - 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
 
 - 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))
diff --git a/bin/package.sh b/bin/package.sh
new file mode 100755
index 0000000..93df95a
--- /dev/null
+++ b/bin/package.sh
@@ -0,0 +1,17 @@
+#!/bin/sh
+if [ $# -lt 1 ]; then
+    echo "Please specify the path to your fork of 'https://github.com/typst/packages'."
+    exit 1
+fi
+
+version=${OXIFMT_VERSION:-"$(grep "version = " typst.toml | sed -e 's/^version = "\|"$//g')"}
+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
+do
+    cp "${orig_dir}/${file}" -t "${dest_dir}"
+done
+
+echo "Copied files to ${dest_dir}"
diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index 773e880..25c5114 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -152,6 +152,44 @@
 }
 // DOC TESTS
 #{
+  // --- Quick examples ---
+  {
+    // "User John has 10 apples."
+    assert.eq(
+      "User John has 10 apples.",
+      strfmt("User {} has {} apples.", "John", 10)
+    )
+
+    // "if exp > 100 { true }"
+    assert.eq(
+      "if exp > 100 { true }",
+      strfmt("if {var} > {num} {{ true }}", var: "exp", num: 100)
+    )
+
+    // "1.10e2 meters"
+    assert.eq(
+      "1.10e2 meters",
+      strfmt("{:.2e} meters", 110.0)
+    )
+
+    // "20_000 players have more than +002,3 points."
+    assert.eq(
+      "20_000 players have more than +002,300 points.",
+      strfmt(
+        "{} players have more than {:+08.3} points.",
+        20000,
+        2.3,
+        fmt-decimal-separator: ",",
+        fmt-thousands-separator: "_"
+      )
+    )
+
+    // "The byte value is 0x8C or 10001100"
+    assert.eq(
+      "The byte value is 0x8C or 10001100",
+      strfmt("The byte value is {:#02X} or {0:08b}", 140)
+    )
+  }
   // --- Usage ---
   {
     let s = strfmt("I'm {}. I have {num} cars. I'm {0}. {} is {{cool}}.", "John", "Carl", num: 10)
@@ -205,8 +243,17 @@
     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")
   }
+  // Custom options
   {
     let s = strfmt("{0} {0:.6} {0:.5e}", 1.432, fmt-decimal-separator: ",")
     assert.eq(s, "1,432 1,432000 1,43200e0")
   }
+  {
+    let s = strfmt("{}", 20000, fmt-thousands-separator: "_")
+    assert.eq(s, "20_000")
+  }
+  {
+    let s = strfmt("{}", 20000, fmt-thousands-count: 2, fmt-thousands-separator: "_")
+    assert.eq(s, "2_00_00")
+  }
 }
diff --git a/typst.toml b/typst.toml
index 13fcdba..0174763 100644
--- a/typst.toml
+++ b/typst.toml
@@ -1,6 +1,6 @@
 [package]
 name = "oxifmt"
-version = "0.2.1"
+version = "0.3.0"
 authors = ["PgBiel <https://github.com/PgBiel>"]
 license = "MIT OR Apache-2.0"
 description = "Convenient Rust-like string formatting in Typst"

From ee7861846f1cbece30a33f8ab511719d32fde578 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 3 Jun 2025 18:39:56 -0300
Subject: [PATCH 52/60] Fix decimal scientific notation (#24)

---
 oxifmt.typ             | 10 +---------
 tests/strfmt-tests.typ |  3 +++
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/oxifmt.typ b/oxifmt.typ
index c12882e..cd774a8 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -276,15 +276,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
diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index 25c5114..a2065fb 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -132,6 +132,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
 #{

From 6b873871ae5e3844d24e101bbbbbcd6314c06831 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 3 Jun 2025 19:14:13 -0300
Subject: [PATCH 53/60] Close format specifiers eagerly on parsing (#22)

* close format specifiers eagerly

Plus error on stray } at the end

* remove unnecessary branch

* change rbracket check
---
 oxifmt.typ             | 65 ++++++++++++++++++------------------------
 tests/strfmt-tests.typ | 10 ++++++-
 2 files changed, 37 insertions(+), 38 deletions(-)

diff --git a/oxifmt.typ b/oxifmt.typ
index cd774a8..66d86f5 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -89,62 +89,50 @@
         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 in the middle of a larger span ({ ... { <-):
+        // error
+        excessive-lbracket()
       }
-      last-was-lbracket = true
     } 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 {
+        // { ... } <--- 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
     } 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
@@ -167,6 +155,9 @@
       // {abcd| <--- string ended with unclosed span
       missing-rbracket()
     }
+  } else if last-was-rbracket {
+    // } <--- unmatched and unescaped } at the very end
+    excessive-rbracket()
   }
 
   result
diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index a2065fb..fefcc33 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -11,7 +11,9 @@
   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")
@@ -153,6 +155,12 @@
   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("}}"), "}")
+}
 // DOC TESTS
 #{
   // --- Quick examples ---

From a0fa7c9f2c36a046131f50998b3793806cdab99c Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 3 Jun 2025 20:04:51 -0300
Subject: [PATCH 54/60] Variably-sized thousands grouping (#25)

---
 oxifmt.typ             | 68 ++++++++++++++++++++++++++++++++++++------
 tests/strfmt-tests.typ | 24 +++++++++++++--
 2 files changed, 80 insertions(+), 12 deletions(-)

diff --git a/oxifmt.typ b/oxifmt.typ
index 66d86f5..1914544 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 {
@@ -345,7 +379,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()
@@ -537,7 +576,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()
@@ -606,17 +650,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 fefcc33..a7a17e8 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -105,9 +105,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 {

From 11b87a1185f48ab0f6aeeeef33f7e1c8de3e510b Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 3 Jun 2025 20:08:54 -0300
Subject: [PATCH 55/60] New library entrypoint to hide private names (#26)

---
 lib.typ                | 1 +
 tests/strfmt-tests.typ | 3 ++-
 typst.toml             | 2 +-
 3 files changed, 4 insertions(+), 2 deletions(-)
 create mode 100644 lib.typ

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/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index a7a17e8..e7a37ff 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)
diff --git a/typst.toml b/typst.toml
index 0174763..e8fe9f0 100644
--- a/typst.toml
+++ b/typst.toml
@@ -4,5 +4,5 @@ version = "0.3.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"

From 48dc0d0a62cd6040cf34cb6b37daf5ba6afb5394 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 4 Jun 2025 01:29:26 -0300
Subject: [PATCH 56/60] Allow braces for padding (#30)

* allow braces for padding

* use lookahead

this case is so rare, it's not worth it to overcomplicate things

* undo the weird state changes

* aesthetic changes
---
 oxifmt.typ             | 28 ++++++++++++++++++++++++++--
 tests/strfmt-tests.typ | 11 +++++++++++
 2 files changed, 37 insertions(+), 2 deletions(-)

diff --git a/oxifmt.typ b/oxifmt.typ
index 1914544..29c3181 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -88,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 }
@@ -116,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
@@ -138,11 +141,19 @@
         // 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-fmt-colon = false
     } else if character == "}" {
       last-was-lbracket = false
       if current-fmt-span == none {
@@ -154,11 +165,18 @@
           // in case this is an escaped }
           last-was-rbracket = true
         }
+      } 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)
       }
+
+      last-was-fmt-colon = false
     } else {
       if last-was-rbracket {
         if current-fmt-span == none {
@@ -169,9 +187,13 @@
           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
@@ -179,12 +201,14 @@
 
     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()
diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index e7a37ff..f9168df 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -179,6 +179,17 @@
   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}")
 }
 // DOC TESTS
 #{

From e8ca90eccd219c6550af54d091178c283a52f444 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 4 Jun 2025 01:47:50 -0300
Subject: [PATCH 57/60] Match center align to Rust's (#31)

* match center align to Rust's

* update readme
---
 README.md              |  4 ++--
 oxifmt.typ             |  6 ++++--
 tests/strfmt-tests.typ | 21 +++++++++++++++++----
 3 files changed, 23 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index c52e57f..7c33ade 100644
--- a/README.md
+++ b/README.md
@@ -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.
@@ -147,7 +147,7 @@ Some examples:
 #import "@preview/oxifmt:0.3.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).
 ```
 
diff --git a/oxifmt.typ b/oxifmt.typ
index 29c3181..a26d651 100644
--- a/oxifmt.typ
+++ b/oxifmt.typ
@@ -645,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
       }
     }
   }
diff --git a/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index f9168df..bfec006 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -17,7 +17,7 @@
   // 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")
@@ -182,15 +182,28 @@
 
   // 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("{:{^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 ---
@@ -262,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)

From a0f0a9c5864d9a61e05764958dd6b530037251d9 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 4 Jun 2025 08:57:52 -0300
Subject: [PATCH 58/60] Release 1.0.0 (#27)

---
 README.md              | 62 ++++++++++++++++++++++++++++--------------
 bin/package.sh         |  2 +-
 tests/strfmt-tests.typ | 10 +++++--
 typst.toml             |  2 +-
 4 files changed, 51 insertions(+), 25 deletions(-)

diff --git a/README.md b/README.md
index 7c33ade..bff14d0 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}.")
@@ -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,7 +144,7 @@ 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")
@@ -153,7 +153,7 @@ Some examples:
 
 - **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,6 +272,20 @@ The tests succeeded if you received no error messages from the last command (ple
 
 ## Changelog
 
+### v1.0.0
+
+- **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-count: ",")`, 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
 
 - **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))
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/tests/strfmt-tests.typ b/tests/strfmt-tests.typ
index bfec006..d83ba22 100644
--- a/tests/strfmt-tests.typ
+++ b/tests/strfmt-tests.typ
@@ -220,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."
@@ -310,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 e8fe9f0..a1785e3 100644
--- a/typst.toml
+++ b/typst.toml
@@ -1,6 +1,6 @@
 [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"

From 9d4f488b47d6b194aadb5dc15c2a6925f5fc4f4b Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 4 Jun 2025 09:19:23 -0300
Subject: [PATCH 59/60] fix changelog

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index bff14d0..0ba7a66 100644
--- a/README.md
+++ b/README.md
@@ -281,7 +281,7 @@ The tests succeeded if you received no error messages from the last command (ple
 - **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-count: ",")`, which outputs `10,00,000` (note that groups go from right to left, similarly to the numbers themselves).
+  - 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))

From cd127911e8624e73e9c05541b3a283b954807c17 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 4 Jun 2025 12:55:55 -0300
Subject: [PATCH 60/60] add release dates to changelog

---
 README.md | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 0ba7a66..288a53f 100644
--- a/README.md
+++ b/README.md
@@ -272,7 +272,9 @@ The tests succeeded if you received no error messages from the last command (ple
 
 ## Changelog
 
-### v1.0.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.
@@ -286,7 +288,7 @@ The tests succeeded if you received no error messages from the last command (ple
 - 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
+### 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).
@@ -301,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.
@@ -315,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`.