format

Author: neverRare

src/parser/lexer.ts

@@ -66,7 +66,7 @@ const properWords = allAtLeastOnce(
   match(/[A-Z][a-zA-Z]*/, "proper word").skip(spaces),
 )
   .map((array) => array.join(" "))
-  .map((words) => ({ type: "proper word", words, kind: "latin" }) );
+  .map((words) => ({ type: "proper word", words, kind: "latin" }));
 
 const specificWord = memoize((thatWord: string) =>
   word.filter((thisWord) =>
@@ -76,7 +76,7 @@ const specificWord = memoize((thatWord: string) =>
 );
 const multipleA = specificWord("a")
   .with(count(allAtLeastOnce(specificWord("a"))))
-  .map((count) => ({ type: "multiple a", count: count + 1 }) );
+  .map((count) => ({ type: "multiple a", count: count + 1 }));
 const repeatingLetter = match(/[a-zA-Z]/, "latin letter")
   .then(memoize((letter) =>
     count(all(matchString(letter)))
@@ -87,15 +87,15 @@ const longWord = allAtLeastOnce(repeatingLetter)
   .map((letters) => {
     const word = letters.map(([letter]) => letter).join("");
     const length = sumOf(letters, ([_, count]) => count) - word.length + 1;
-    return { type: "long word", word, length } ;
+    return { type: "long word", word, length };
   })
   .filter(({ word, length }) => /^[a-z]/.test(word) && length > 1);
 
 const alaX = memoize((word: string) =>
   sequence(specificWord("ala"), specificWord(word)).map(() => word)
 );
 const xAlaX = lazy(() => settings.xAlaXPartialParsing ? empty : word.then(alaX))
-  .map((word) => ({ type: "x ala x", word }) );
+  .map((word) => ({ type: "x ala x", word }));
 const punctuation = choiceOnlyOne(
   allAtLeastOnce(
     match(SENTENCE_TERMINATOR, "punctuation")
@@ -105,7 +105,7 @@ const punctuation = choiceOnlyOne(
     .map((punctuation) => punctuation.join("").replaceAll("...", ELLIPSIS)),
   newline.map(() => "."),
 )
-  .map((punctuation) => ({ type: "punctuation", punctuation }) );
+  .map((punctuation) => ({ type: "punctuation", punctuation }));
 const cartoucheElement = choiceOnlyOne(
   singleUcsurWord
     .skip(match(NSK_COLON, "full width colon").skip(spaces)),
@@ -141,13 +141,11 @@ const cartouche = specificSpecialUcsur(START_OF_CARTOUCHE)
   );
 const cartouches = allAtLeastOnce(cartouche)
   .map((words) => words.join(" "))
-  .map((words) =>
-    ({
-      type: "proper word",
-      words,
-      kind: "cartouche",
-    }) 
-  );
+  .map((words) => ({
+    type: "proper word",
+    words,
+    kind: "cartouche",
+  }));
 const longSpaceContainer = specificSpecialUcsur(START_OF_LONG_GLYPH)
   .with(count(spacesWithoutNewline).filter((length) => length > 0))
   .skip(specificSpecialUcsur(END_OF_LONG_GLYPH))
@@ -160,36 +158,34 @@ const spaceLongGlyph = sequence(
   longGlyphHead,
   longSpaceContainer,
 )
-  .map(([words, spaceLength]) =>
-    ({
-      type: "space long glyph",
-      words,
-      spaceLength,
-    }) 
-  );
+  .map(([words, spaceLength]) => ({
+    type: "space long glyph",
+    words,
+    spaceLength,
+  }));
 const headedLongGlyphStart = longGlyphHead
   .skip(specificSpecialUcsur(START_OF_LONG_GLYPH))
   .skip(spaces)
-  .map((words) => ({ type: "headed long glyph start", words }) );
+  .map((words) => ({ type: "headed long glyph start", words }));
 const headlessLongGlyphEnd = specificSpecialUcsur(END_OF_LONG_GLYPH)
   .skip(spaces)
-  .map(() => ({ type: "headless long glyph end" }) );
+  .map(() => ({ type: "headless long glyph end" }));
 const headlessLongGlyphStart = specificSpecialUcsur(START_OF_REVERSE_LONG_GLYPH)
   .skip(spaces)
-  .map(() => ({ type: "headless long glyph end" }) );
+  .map(() => ({ type: "headless long glyph end" }));
 const headedLongGlyphEnd = specificSpecialUcsur(END_OF_REVERSE_LONG_GLYPH)
   .with(longGlyphHead)
   .skip(spaces)
-  .map((words) => ({ type: "headed long glyph start", words }) );
+  .map((words) => ({ type: "headed long glyph start", words }));
 const insideLongGlyph = specificSpecialUcsur(END_OF_REVERSE_LONG_GLYPH)
   .with(longGlyphHead)
   .skip(specificSpecialUcsur(START_OF_LONG_GLYPH))
   .skip(spaces)
-  .map((words) => ({ type: "inside long glyph", words }) );
+  .map((words) => ({ type: "inside long glyph", words }));
 const combinedGlyphsToken = combinedGlyphs
   .skip(spaces)
-  .map((words) => ({ type: "combined glyphs", words }) );
-const wordToken = word.map((word) => ({ type: "word", word }) );
+  .map((words) => ({ type: "combined glyphs", words }));
+const wordToken = word.map((word) => ({ type: "word", word }));
 
 export const token: Parser<Token> = choiceOnlyOne<Token>(
   xAlaX,

src/parser/ucsur.ts

@@ -30,7 +30,7 @@ export const SPECIAL_UCSUR_DESCRIPTIONS = {
   [END_OF_REVERSE_LONG_GLYPH]: "end of reverse long glyph",
   [UCSUR_MIDDLE_DOT]: "middle dot",
   [UCSUR_COLON]: "colon",
-} ;
+};
 
 export type SpecialUcsur = keyof typeof SPECIAL_UCSUR_DESCRIPTIONS;
 
@@ -183,8 +183,8 @@ export const KU_LILI = [
 ];
 export const UCSUR_TO_LATIN = new Map(
   [
-    { start: 0xF1900, words: [...PU, ...KU_SULI] } ,
-    { start: 0xF19A0, words: KU_LILI } ,
+    { start: 0xF1900, words: [...PU, ...KU_SULI] },
+    { start: 0xF19A0, words: KU_LILI },
   ]
     .flatMap(({ start, words }) =>
       words.map((latin, i) => [String.fromCodePoint(start + i), latin] as const)

src/settings_frontend.ts

@@ -77,7 +77,10 @@ function loadOneFromElements<const T extends keyof Settings>(key: T) {
   );
   setIgnoreError(key, UPDATERS[key].stringify(settings[key]));
 }
-function setElement<const T extends keyof Settings>(key: T, value: Settings[T]) {
+function setElement<const T extends keyof Settings>(
+  key: T,
+  value: Settings[T],
+) {
   UPDATERS[key].set(
     document.getElementById(toKebabCase(key)) as
       | HTMLInputElement

src/translator/modifier.ts

@@ -170,7 +170,7 @@ function modifier(modifier: TokiPona.Modifier) {
       return pi(modifier.phrase);
     case "nanpa":
       return nanpa(modifier)
-        .map((noun) => ({ type: "position phrase", noun }) );
+        .map((noun) => ({ type: "position phrase", noun }));
   }
 }
 export function multipleModifiers(

src/translator/word_unit.ts

@@ -38,7 +38,7 @@ function defaultWordUnit(
               definition,
               emphasis: emphasis != null,
             })
-              .map((noun) => ({ ...noun, type: "noun" }) );
+              .map((noun) => ({ ...noun, type: "noun" }));
           }
         case "personal pronoun":
           return new ArrayResult([
@@ -49,38 +49,34 @@ function defaultWordUnit(
                 emphasis: emphasis != null,
               }),
               type: "noun",
-            } ,
+            },
           ]);
         case "adjective":
           if (!includeGerund && definition.gerundLike) {
             return ArrayResult.empty();
           } else {
             return adjective({ ...options, definition })
-              .map((adjective) =>
-                ({
-                  type: "adjective",
-                  adjective,
-                }) 
-              );
+              .map((adjective) => ({
+                type: "adjective",
+                adjective,
+              }));
           }
         case "compound adjective":
           return compoundAdjective({
             ...options,
             adjectives: definition.adjective,
           })
-            .map((adjective) =>
-              ({
-                type: "adjective",
-                adjective,
-              }) 
-            );
+            .map((adjective) => ({
+              type: "adjective",
+              adjective,
+            }));
         case "verb":
           return partialVerb({
             ...options,
             definition,
             emphasis: emphasis != null,
           })
-            .map((verb) => ({ ...verb, type: "verb" }) );
+            .map((verb) => ({ ...verb, type: "verb" }));
         default:
           return ArrayResult.empty();
       }