bare-x-to-pdf 0.3.0 → 0.4.0

package/README.md

@@ -47,17 +47,20 @@ npm install --os=ios --cpu=arm64
 ```js
 const converter = require('bare-x-to-pdf')
 
-const pdf = converter.convert(docxBytes, { to: 'pdf' })
+const pdf = await converter.convert(docxBytes, { to: 'pdf' })
 ```
 
-Input is a `Uint8Array` or `ArrayBuffer` and the result is a `Buffer`. Calls are
-synchronous and CPU bound; run them in a `Bare.Thread` when latency matters.
+Input is a `Uint8Array` or `ArrayBuffer` and the result is a `Buffer`. `convert()` runs on
+the libuv thread pool and does not block the JavaScript thread; `convertSync()` runs on the
+calling thread.
 
 ## API
 
-### `convert(input, options)`
+### `const pdf = await convert(input, options)`
 
-Convert `input` and return a `Buffer`.
+Convert `input` off the JavaScript thread and resolve with a `Buffer`. The input is copied,
+so it may be changed or transferred once the call returns. Invalid options and conversion
+errors reject the promise.
 
 - `options.to` — target format, `'pdf'`. Required.
 - `options.from` — source format; sniffed from the bytes when omitted. Markdown has no
@@ -65,6 +68,11 @@ Convert `input` and return a `Buffer`.
   URIs, since the input is bytes with no directory to resolve relative paths against.
 - `options.fontsDir` — a directory of fonts to use instead of the bundled set.
 
+### `const pdf = convertSync(input, options)`
+
+Convert `input` on the calling thread and return a `Buffer`. Takes the same options as
+`convert()`.
+
 ### `detect(input)`
 
 Sniff the format from the bytes and return `'docx'`, `'pptx'`, `'xlsx'`, `'doc'`, `'xls'`,
@@ -84,6 +92,33 @@ Return every supported pair as `{ from, to }`.
 
 Path to the bundled fonts directory.
 
+## Limits
+
+Documents are often untrusted, so the engine caps what a small file can make it allocate or
+lay out. A document past a hard limit is rejected with an error. One past a soft limit still
+converts, with the value clamped.
+
+Rejected:
+
+- An archive part larger than 128 MB uncompressed.
+- XML nested more than 512 elements deep.
+- A spreadsheet that would print more than 30,000 cells.
+
+Clamped:
+
+- Table spans: 1–1,000 columns.
+- Text columns: 1–64.
+- Pages: 72–14,400 pt on each side, with margins scaled to fit.
+- Lengths: NaN and infinity become 0; any other length is held within ±1,000,000 pt.
+- List counters: above 32,767, letter and Roman labels fall back to decimal.
+- Charts: up to 100,000 points per series (in .xls, 32,000 per series and 256,000 per chart).
+- Formulas: nesting depth up to 256.
+- Images: more than 50 megapixels, or ones that cannot be decoded, are drawn as blank
+  space.
+- Tables nested more than 12 deep: the inner tables are flattened into paragraphs.
+
+Spreadsheet pages with no content are not printed, as in LibreOffice Calc.
+
 ## Development
 
 The platform packages in `npm/` are npm workspaces, and each declares its own `os` and `cpu`

package/binding.c

@@ -6,13 +6,39 @@
 #include <stdlib.h>
 #include <string.h>
 #include <utf.h>
+#include <uv.h>
 
 #include "simple_converter.h"
 
+typedef struct {
+  const uint8_t *input;
+  size_t input_len;
+  uint8_t *owned_input;
+  char *from;
+  char *to;
+  char *fonts_dir;
+  sc_buffer_t out;
+  sc_buffer_t error;
+  int status;
+} simple_converter_job_t;
+
+typedef struct {
+  uv_work_t work;
+  js_env_t *env;
+  js_deferred_t *deferred;
+  js_deferred_teardown_t *teardown;
+  bool exiting;
+  simple_converter_job_t job;
+} simple_converter_req_t;
+
 static bool
 simple_converter__string(js_env_t *env, js_value_t *value, char **result) {
   int err;
 
+  bool is_string;
+  err = js_is_string(env, value, &is_string);
+  if (err != 0 || !is_string) return false;
+
   size_t len = 0;
   err = js_get_value_string_utf8(env, value, NULL, 0, &len);
   if (err != 0) return false;
@@ -27,14 +53,32 @@ simple_converter__string(js_env_t *env, js_value_t *value, char **result) {
   }
 
   str[len] = '\0';
+
+  if (strlen(str) != len) {
+    free(str);
+    return false;
+  }
+
   *result = str;
   return true;
 }
 
-static js_value_t *
-simple_converter_convert(js_env_t *env, js_callback_info_t *info) {
+static void
+simple_converter__job_release(simple_converter_job_t *job) {
+  free(job->owned_input);
+  free(job->from);
+  free(job->to);
+  free(job->fonts_dir);
+  sc_free(&job->out);
+  sc_free(&job->error);
+}
+
+static bool
+simple_converter__job_init(js_env_t *env, js_callback_info_t *info, bool copy_input, simple_converter_job_t *job) {
   int err;
 
+  memset(job, 0, sizeof(*job));
+
   size_t argc = 4;
   js_value_t *argv[4];
 
@@ -44,68 +88,219 @@ simple_converter_convert(js_env_t *env, js_callback_info_t *info) {
   if (argc < 4) {
     err = js_throw_error(env, NULL, "convert expects (bytes, from, to, fontsDir)");
     assert(err == 0);
-    return NULL;
+    return false;
   }
 
-  uint8_t *input;
-  size_t input_len;
-  err = js_get_typedarray_info(env, argv[0], NULL, (void **) &input, &input_len, NULL, NULL);
-  if (err != 0) {
+  bool is_typedarray;
+  err = js_is_typedarray(env, argv[0], &is_typedarray);
+  assert(err == 0);
+
+  js_typedarray_type_t type = js_int8array;
+  uint8_t *input = NULL;
+  size_t input_len = 0;
+  if (is_typedarray) {
+    err = js_get_typedarray_info(env, argv[0], &type, (void **) &input, &input_len, NULL, NULL);
+  }
+  if (!is_typedarray || err != 0 || type != js_uint8array) {
     err = js_throw_error(env, NULL, "input must be a Uint8Array");
     assert(err == 0);
-    return NULL;
+    return false;
   }
 
-  char *from = NULL;
-  char *to = NULL;
-  char *fonts_dir = NULL;
-
-  bool ok = simple_converter__string(env, argv[1], &from) &&
-            simple_converter__string(env, argv[2], &to) &&
-            simple_converter__string(env, argv[3], &fonts_dir);
+  bool ok = simple_converter__string(env, argv[1], &job->from) &&
+            simple_converter__string(env, argv[2], &job->to) &&
+            simple_converter__string(env, argv[3], &job->fonts_dir);
 
   if (!ok) {
-    free(from);
-    free(to);
-    free(fonts_dir);
-    err = js_throw_error(env, NULL, "from, to and fontsDir must be strings");
+    simple_converter__job_release(job);
+    err = js_throw_error(env, NULL, "from, to and fontsDir must be strings without NUL characters");
     assert(err == 0);
-    return NULL;
+    return false;
+  }
+
+  job->input = input;
+  job->input_len = input_len;
+
+  if (copy_input && input_len > 0) {
+    job->owned_input = malloc(input_len);
+    if (job->owned_input == NULL) {
+      simple_converter__job_release(job);
+      err = js_throw_error(env, NULL, "out of memory");
+      assert(err == 0);
+      return false;
+    }
+    memcpy(job->owned_input, input, input_len);
+    job->input = job->owned_input;
   }
 
-  sc_buffer_t out = {NULL, 0};
-  sc_buffer_t error = {NULL, 0};
+  return true;
+}
+
+static void
+simple_converter__run(simple_converter_job_t *job) {
+  job->status = sc_convert(job->input, job->input_len, job->from, job->to, job->fonts_dir, &job->out, &job->error);
+}
+
+static void
+simple_converter__finalize_output(js_env_t *env, void *data, void *finalize_hint) {
+  sc_buffer_t *buffer = finalize_hint;
+  sc_free(buffer);
+  free(buffer);
+}
 
-  int status = sc_convert(input, input_len, from, to, fonts_dir, &out, &error);
+static js_value_t *
+simple_converter__output(js_env_t *env, simple_converter_job_t *job) {
+  int err;
 
-  free(from);
-  free(to);
-  free(fonts_dir);
+  js_value_t *result;
+
+  sc_buffer_t *owned = job->out.len > 0 ? malloc(sizeof(sc_buffer_t)) : NULL;
 
-  if (status != 0) {
-    char *message = malloc(error.len + 1);
-    if (message != NULL) {
-      memcpy(message, error.data, error.len);
-      message[error.len] = '\0';
+  if (owned != NULL) {
+    *owned = job->out;
+    err = js_create_external_arraybuffer(env, owned->data, owned->len, simple_converter__finalize_output, owned, &result);
+    if (err == 0) {
+      job->out.data = NULL;
+      job->out.len = 0;
+      return result;
     }
-    sc_free(&error);
-    err = js_throw_error(env, NULL, message ? message : "conversion failed");
-    assert(err == 0);
-    free(message);
-    return NULL;
+    free(owned);
   }
 
-  js_value_t *result;
   void *data;
-  err = js_create_arraybuffer(env, out.len, &data, &result);
+  err = js_create_arraybuffer(env, job->out.len, &data, &result);
+  assert(err == 0);
+
+  if (job->out.len > 0) memcpy(data, job->out.data, job->out.len);
+
+  return result;
+}
+
+static js_value_t *
+simple_converter__error(js_env_t *env, simple_converter_job_t *job) {
+  int err;
+
+  js_value_t *message;
+  if (job->error.len > 0) {
+    err = js_create_string_utf8(env, (utf8_t *) job->error.data, job->error.len, &message);
+  } else {
+    err = js_create_string_utf8(env, (utf8_t *) "conversion failed", (size_t) -1, &message);
+  }
+  assert(err == 0);
+
+  js_value_t *error;
+  err = js_create_error(env, NULL, message, &error);
   assert(err == 0);
 
-  if (out.len > 0) memcpy(data, out.data, out.len);
-  sc_free(&out);
+  return error;
+}
+
+static js_value_t *
+simple_converter_convert_sync(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  simple_converter_job_t job;
+  if (!simple_converter__job_init(env, info, false, &job)) return NULL;
+
+  simple_converter__run(&job);
+
+  js_value_t *result = NULL;
+
+  if (job.status == 0) {
+    result = simple_converter__output(env, &job);
+  } else {
+    err = js_throw(env, simple_converter__error(env, &job));
+    assert(err == 0);
+  }
+
+  simple_converter__job_release(&job);
 
   return result;
 }
 
+static void
+simple_converter__on_work(uv_work_t *work) {
+  simple_converter_req_t *req = (simple_converter_req_t *) work;
+
+  simple_converter__run(&req->job);
+}
+
+static void
+simple_converter__on_after_work(uv_work_t *work, int status) {
+  int err;
+
+  simple_converter_req_t *req = (simple_converter_req_t *) work;
+
+  js_env_t *env = req->env;
+
+  if (!req->exiting) {
+    js_handle_scope_t *scope;
+    err = js_open_handle_scope(env, &scope);
+    assert(err == 0);
+
+    if (status == 0 && req->job.status == 0) {
+      err = js_resolve_deferred(env, req->deferred, simple_converter__output(env, &req->job));
+    } else {
+      err = js_reject_deferred(env, req->deferred, simple_converter__error(env, &req->job));
+    }
+    assert(err == 0);
+
+    err = js_close_handle_scope(env, scope);
+    assert(err == 0);
+  }
+
+  err = js_finish_deferred_teardown_callback(req->teardown);
+  assert(err == 0);
+
+  simple_converter__job_release(&req->job);
+  free(req);
+}
+
+static void
+simple_converter__on_teardown(js_deferred_teardown_t *teardown, void *data) {
+  simple_converter_req_t *req = data;
+
+  req->exiting = true;
+
+  uv_cancel((uv_req_t *) &req->work);
+}
+
+static js_value_t *
+simple_converter_convert(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  simple_converter_req_t *req = malloc(sizeof(simple_converter_req_t));
+  if (req == NULL) {
+    err = js_throw_error(env, NULL, "out of memory");
+    assert(err == 0);
+    return NULL;
+  }
+
+  if (!simple_converter__job_init(env, info, true, &req->job)) {
+    free(req);
+    return NULL;
+  }
+
+  req->env = env;
+  req->exiting = false;
+
+  js_value_t *promise;
+  err = js_create_promise(env, &req->deferred, &promise);
+  assert(err == 0);
+
+  uv_loop_t *loop;
+  err = js_get_env_loop(env, &loop);
+  assert(err == 0);
+
+  err = uv_queue_work(loop, &req->work, simple_converter__on_work, simple_converter__on_after_work);
+  assert(err == 0);
+
+  err = js_add_deferred_teardown_callback(env, simple_converter__on_teardown, req, &req->teardown);
+  assert(err == 0);
+
+  return promise;
+}
+
 static js_value_t *
 simple_converter_exports(js_env_t *env, js_value_t *exports) {
   int err;
@@ -120,6 +315,7 @@ simple_converter_exports(js_env_t *env, js_value_t *exports) {
   }
 
   V("convert", simple_converter_convert)
+  V("convertSync", simple_converter_convert_sync)
 #undef V
 
   return exports;

package/cmake/rust.cmake

@@ -1,6 +1,6 @@
 include_guard(GLOBAL)
 
-set(CORROSION_VERSION "v0.6.1" CACHE STRING "Corrosion release tag")
+set(CORROSION_COMMIT "1499b14e4906a2890f5cee1547c8848db261753d" CACHE STRING "Corrosion commit (v0.6.1)")
 
 bare_platform(_sys)
 bare_arch(_arch)
@@ -49,7 +49,7 @@ endif()
 
 set(Rust_CARGO_TARGET "${_triple}" CACHE STRING "Rust target triple")
 
-fetch_package("github:corrosion-rs/corrosion#${CORROSION_VERSION}")
+fetch_package("github:corrosion-rs/corrosion#${CORROSION_COMMIT}")
 
 corrosion_import_crate(
   MANIFEST_PATH "${CMAKE_CURRENT_SOURCE_DIR}/core/Cargo.toml"

package/core/src/doc/mod.rs

@@ -34,6 +34,8 @@ pub fn read(bytes: &[u8]) -> Result<Document, Error> {
         chpx_fkps: file.fkps(file.fib.fc_lcb(12))?,
         papx_fkps: file.fkps(file.fib.fc_lcb(13))?,
         counters: std::cell::RefCell::new(HashMap::new()),
+        extracted: std::cell::Cell::new(0),
+        image_bytes: std::cell::Cell::new(0),
     };
 
     let main_end = file.fib.ccp_text;
@@ -369,7 +371,7 @@ impl File {
         let (fc_clx, lcb_clx) = self.fib.fc_lcb(33);
         let clx = self
             .table
-            .get(fc_clx as usize..(fc_clx + lcb_clx) as usize)
+            .get(fc_clx as usize..fc_clx.saturating_add(lcb_clx) as usize)
             .ok_or_else(|| Error::new("piece table is out of range"))?;
         let mut pos = 0;
         while pos < clx.len() {
@@ -380,7 +382,7 @@ impl File {
                 }
                 2 => {
                     let lcb = u32_at(clx, pos + 1) as usize;
-                    let plc = &clx[pos + 5..(pos + 5 + lcb).min(clx.len())];
+                    let plc = clx.get(pos + 5..pos.saturating_add(5).saturating_add(lcb).min(clx.len())).unwrap_or(&[]);
                     let n = (plc.len().saturating_sub(4)) / 12;
                     let mut pieces = Vec::with_capacity(n);
                     for i in 0..n {
@@ -402,7 +404,7 @@ impl File {
 
     fn fonts(&self) -> Vec<String> {
         let (fc, lcb) = self.fib.fc_lcb(15);
-        let Some(sttb) = self.table.get(fc as usize..(fc + lcb) as usize) else { return Vec::new() };
+        let Some(sttb) = self.table.get(fc as usize..fc.saturating_add(lcb) as usize) else { return Vec::new() };
         let mut fonts = Vec::new();
         let mut pos = 0;
         if u16_at(sttb, 0) == 0xFFFF {
@@ -441,10 +443,10 @@ impl File {
         let (fc, lcb) = self.fib.fc_lcb(1);
         let stsh = self
             .table
-            .get(fc as usize..(fc + lcb) as usize)
+            .get(fc as usize..fc.saturating_add(lcb) as usize)
             .ok_or_else(|| Error::new("stylesheet is out of range"))?;
         let cb_stshi = u16_at(stsh, 0) as usize;
-        let stshi = &stsh[2..(2 + cb_stshi).min(stsh.len())];
+        let stshi = stsh.get(2..(2 + cb_stshi).min(stsh.len())).unwrap_or(&[]);
         let cstd = u16_at(stshi, 0) as usize;
         let cb_std_base = u16_at(stshi, 2) as usize;
         let default_ftc = u16_at(stshi, 12) as usize;
@@ -634,7 +636,7 @@ impl File {
 }
 
 fn parse_fkp(page: &[u8]) -> Fkp {
-    let crun = page[511] as usize;
+    let crun = (page.get(511).copied().unwrap_or(0) as usize).min(101);
     let mut fcs = Vec::with_capacity(crun + 1);
     for i in 0..=crun {
         fcs.push(u32_at(page, i * 4));
@@ -643,15 +645,15 @@ fn parse_fkp(page: &[u8]) -> Fkp {
     let mut entries = Vec::with_capacity(crun);
     let mut istds = Vec::with_capacity(crun);
     for i in 0..crun {
-        let offset_byte = page[base + i];
+        let offset_byte = page.get(base + i).copied().unwrap_or(0);
         if offset_byte == 0 {
             entries.push(Vec::new());
             istds.push(0);
             continue;
         }
         let at = offset_byte as usize * 2;
-        let cb = page[at] as usize;
-        let grpprl = &page[at + 1..(at + 1 + cb).min(512)];
+        let cb = page.get(at).copied().unwrap_or(0) as usize;
+        let grpprl = page.get(at + 1..(at + 1 + cb).min(page.len())).unwrap_or(&[]);
         entries.push(grpprl.to_vec());
         istds.push(0);
     }
@@ -659,7 +661,7 @@ fn parse_fkp(page: &[u8]) -> Fkp {
 }
 
 fn parse_papx_fkp(page: &[u8]) -> Fkp {
-    let cpara = page[511] as usize;
+    let cpara = (page.get(511).copied().unwrap_or(0) as usize).min(29);
     let mut fcs = Vec::with_capacity(cpara + 1);
     for i in 0..=cpara {
         fcs.push(u32_at(page, i * 4));
@@ -668,22 +670,22 @@ fn parse_papx_fkp(page: &[u8]) -> Fkp {
     let mut entries = Vec::with_capacity(cpara);
     let mut istds = Vec::with_capacity(cpara);
     for i in 0..cpara {
-        let bx = page[base + i * 13];
+        let bx = page.get(base + i * 13).copied().unwrap_or(0);
         if bx == 0 {
             entries.push(Vec::new());
             istds.push(0);
             continue;
         }
         let at = bx as usize * 2;
-        let mut cb = page[at] as usize;
+        let mut cb = page.get(at).copied().unwrap_or(0) as usize;
         let mut start = at + 1;
         if cb == 0 {
-            cb = page[at + 1] as usize * 2;
+            cb = page.get(at + 1).copied().unwrap_or(0) as usize * 2;
             start = at + 2;
         } else {
             cb = cb * 2 - 1;
         }
-        let body = &page[start..(start + cb).min(512)];
+        let body = page.get(start..(start + cb).min(page.len())).unwrap_or(&[]);
         let istd = u16_at(body, 0);
         entries.push(body.get(2..).map(|b| b.to_vec()).unwrap_or_default());
         istds.push(istd);
@@ -729,6 +731,8 @@ struct Reader<'a> {
     chpx_fkps: Vec<(u32, u32, Fkp)>,
     papx_fkps: Vec<(u32, u32, Fkp)>,
     counters: std::cell::RefCell<HashMap<u32, Vec<i64>>>,
+    extracted: std::cell::Cell<usize>,
+    image_bytes: std::cell::Cell<usize>,
 }
 
 #[derive(Debug, Clone)]
@@ -745,7 +749,11 @@ impl Reader<'_> {
 
     fn text(&self, start: u32, end: u32) -> Vec<Char> {
         let mut out = Vec::new();
+        let budget = self.file.word.len().saturating_mul(4);
         for piece in self.pieces {
+            if self.extracted.get() + out.len() > budget {
+                break;
+            }
             if piece.cp_end <= start || piece.cp_start >= end {
                 continue;
             }
@@ -780,6 +788,7 @@ impl Reader<'_> {
                 }
             }
         }
+        self.extracted.set(self.extracted.get() + out.len());
         out
     }
 
@@ -1209,9 +1218,9 @@ impl Reader<'_> {
         let values = counters.entry(lsid).or_insert_with(|| vec![0; 9]);
         let ilvl = ilvl.min(8) as usize;
         if values[ilvl] == 0 {
-            values[ilvl] = level.start - 1;
+            values[ilvl] = i64::from(level.start).saturating_sub(1);
         }
-        values[ilvl] += 1;
+        values[ilvl] = values[ilvl].saturating_add(1);
         for deeper in ilvl + 1..9 {
             values[deeper] = 0;
         }
@@ -1258,6 +1267,10 @@ impl Reader<'_> {
         }
         let body = data.get(at + cb_header..(at + lcb).min(data.len()))?;
         let content = find_blip(body)
+            .filter(|bytes| {
+                self.image_bytes.set(self.image_bytes.get() + bytes.len());
+                self.image_bytes.get() <= crate::limits::MAX_IMAGE_BYTES
+            })
             .and_then(|bytes| ImageFormat::sniff(bytes).map(|format| ImageData { data: bytes.to_vec(), format }))
             .map(DrawingContent::Image)
             .unwrap_or(DrawingContent::Placeholder(None));

package/core/src/docx/mod.rs

@@ -193,7 +193,7 @@ fn build_section<R: Read + std::io::Seek>(
         ..Section::default()
     };
     if let Some(cols) = sect.child("cols") {
-        section.columns = cols.attr("num").and_then(|n| n.parse().ok()).unwrap_or(1).max(1);
+        section.columns = cols.attr("num").and_then(|n| n.parse().ok()).unwrap_or(1).clamp(1, crate::limits::MAX_TEXT_COLUMNS);
         if let Some(space) = cols.attr("space").and_then(twips) {
             section.column_gap = space;
         }
@@ -267,8 +267,7 @@ fn entry<R: Read + std::io::Seek>(
 ) -> Result<Option<Vec<u8>>, Error> {
     match archive.by_name(name) {
         Ok(mut file) => {
-            let mut data = Vec::new();
-            file.read_to_end(&mut data)?;
+            let data = crate::limits::read_entry(&mut file)?;
             Ok(Some(data))
         }
         Err(zip::result::ZipError::FileNotFound) => Ok(None),
@@ -810,8 +809,7 @@ impl Reader<'_> {
                         .child("gridSpan")
                         .and_then(|s| s.attr("val"))
                         .and_then(|v| v.parse().ok())
-                        .unwrap_or(1)
-                        .max(1);
+                        .map_or(1, crate::limits::span);
                     cell.width = pr
                         .child("tcW")
                         .filter(|w| w.attr("type") != Some("pct"))

package/core/src/docx/numbering.rs

@@ -147,18 +147,18 @@ impl Counters {
         let values = self
             .values
             .entry(key)
-            .or_insert_with(|| all.iter().map(|l| l.start - 1).collect());
+            .or_insert_with(|| all.iter().map(|l| l.start.saturating_sub(1)).collect());
 
         let first_use = self.started.insert((num_id.to_string(), ilvl));
         if first_use {
             if let Some(start) = instance.overrides.get(&ilvl).and_then(|o| o.start) {
-                values[ilvl] = start - 1;
+                values[ilvl] = start.saturating_sub(1);
             }
         }
 
-        values[ilvl] += 1;
+        values[ilvl] = values[ilvl].saturating_add(1);
         for deeper in ilvl + 1..values.len() {
-            values[deeper] = all[deeper].start - 1;
+            values[deeper] = all[deeper].start.saturating_sub(1);
         }
 
         let text = if level.format == "bullet" {
@@ -203,6 +203,10 @@ fn bullet_text(text: &str) -> String {
 }
 
 pub fn format_number(value: i64, format: &str) -> String {
+    let format = match format {
+        "lowerLetter" | "upperLetter" | "lowerRoman" | "upperRoman" if value > crate::limits::MAX_LIST_VALUE => "decimal",
+        other => other,
+    };
     match format {
         "none" => String::new(),
         "lowerLetter" => letters(value).to_lowercase(),