@lokascript/framework 7.0.0 → 7.1.0

package/src/languages/ko.ts

@@ -0,0 +1,50 @@
+/**
+ * Korean Grammar
+ *
+ * SOV word order, particles (을/를, 에, 에서, etc.), space-separated between words.
+ * Agglutinative language with particles attaching to words.
+ */
+
+import type { GrammarProfile } from './types';
+
+export const koreanGrammar = {
+  code: 'ko',
+  name: 'Korean',
+  nativeName: '한국어',
+  direction: 'ltr',
+  script: 'hangul',
+  wordOrder: 'SOV',
+  markingStrategy: 'particle',
+  usesSpaces: true, // Korean uses spaces between words, but particles attach
+  verb: {
+    position: 'end',
+    suffixes: ['다', '요', '니다', '세요'],
+    subjectDrop: true,
+  },
+  possessive: {
+    marker: '의', // Possessive particle
+    markerPosition: 'between',
+  },
+  roleMarkers: {
+    patient: { primary: '을', alternatives: ['를'], position: 'after' },
+    // 에서 is deliberately NOT a destination alternative: it is the SOURCE
+    // primary ("at/from"), and listing it here let an unconsumed wait-line
+    // tail (`문서 에서` — from document) satisfy the next SOV clause's
+    // optional destination group (behavior-draggable's add captured
+    // destination=문서 instead of the schema `me` default). A real Korean
+    // destination renders 에/으로/로/의.
+    destination: { primary: '에', alternatives: ['으로', '로', '의'], position: 'after' },
+    source: { primary: '에서', alternatives: ['부터'], position: 'after' },
+    style: { primary: '로', alternatives: ['으로'], position: 'after' },
+    event: { primary: '을', alternatives: ['를'], position: 'after' }, // Event as object marker
+  },
+  tokenization: {
+    particles: ['을', '를', '이', '가', '은', '는', '에', '에서', '으로', '로', '와', '과', '도'],
+    boundaryStrategy: 'space',
+  },
+  // Korean writes a particle onto its noun (`#out에`, `나를`; M2 N5).
+  attachedMarkers: {
+    markers: ['을', '를', '에', '으로', '로', '의', '에서', '부터', '에게'],
+    afterWords: 'all',
+  },
+} satisfies GrammarProfile;

package/src/languages/languages.test.ts

@@ -0,0 +1,57 @@
+/**
+ * The language grammars: one data module per language, each reachable three
+ * ways that must agree — its file, the `languages` barrel, and a package
+ * export (`@lokascript/framework/languages/<code>`). tsup builds whatever the
+ * directory holds, so a module missing from package.json builds and ships
+ * unimportable; a barrel entry missing hides it from tooling.
+ */
+import { describe, it, expect } from 'vitest';
+import { readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+import * as languages from './index';
+import type { GrammarProfile } from './types';
+import type { GrammarProfileSlice } from '../multilingual';
+import { buildLanguageConfig } from '../multilingual';
+
+const DIR = __dirname;
+const codes = readdirSync(DIR)
+  .filter(
+    f => f.endsWith('.ts') && !f.endsWith('.test.ts') && !['index.ts', 'types.ts'].includes(f)
+  )
+  .map(f => f.slice(0, -3))
+  .sort();
+const grammars = Object.values(languages) as GrammarProfile[];
+
+describe('language grammars', () => {
+  it('exports each module from the barrel, under its own code', () => {
+    expect(grammars.map(g => g.code).sort()).toEqual(codes);
+  });
+
+  it('exports each module from the package, and nothing else under ./languages/', () => {
+    const pkg = JSON.parse(readFileSync(join(DIR, '../../package.json'), 'utf8'));
+    const exported = Object.keys(pkg.exports)
+      .filter(k => k.startsWith('./languages/'))
+      .map(k => k.slice('./languages/'.length))
+      .sort();
+    expect(exported).toEqual(codes);
+    // `require` too: semantic's dist/index.cjs requires each module.
+    for (const key of ['./languages', ...exported.map(code => `./languages/${code}`)]) {
+      expect(Object.keys(pkg.exports[key]), key).toEqual(['types', 'import', 'require']);
+    }
+  });
+
+  it.each(codes)('%s: is data (no imports but types)', code => {
+    const source = readFileSync(join(DIR, `${code}.ts`), 'utf8');
+    const imports = source.match(/^import .*$/gm) ?? [];
+    expect(imports).toEqual(["import type { GrammarProfile } from './types';"]);
+  });
+
+  it('injects into the bridge as a slice', () => {
+    for (const grammar of grammars) {
+      const slice: GrammarProfileSlice = grammar;
+      const config = buildLanguageConfig(slice, { keywords: { go: { primary: 'go' } } });
+      expect(config.code).toBe(grammar.code);
+      expect(config.patternProfile.wordOrder).toBe(grammar.wordOrder);
+    }
+  });
+});

package/src/languages/ms.ts

@@ -0,0 +1,33 @@
+/**
+ * Malay Grammar
+ *
+ * SVO word order, prepositions, space-separated.
+ */
+
+import type { GrammarProfile } from './types';
+
+export const malayGrammar = {
+  code: 'ms',
+  name: 'Malay',
+  nativeName: 'Melayu',
+  direction: 'ltr',
+  script: 'latin',
+  wordOrder: 'SVO',
+  markingStrategy: 'preposition',
+  usesSpaces: true,
+  defaultVerbForm: 'base',
+  verb: {
+    position: 'start',
+    subjectDrop: true,
+  },
+  possessive: {
+    marker: '', // Malay often uses suffix or juxtaposition
+    markerPosition: 'after-object',
+  },
+  roleMarkers: {
+    destination: { primary: 'ke', alternatives: ['pada'], position: 'before' },
+    source: { primary: 'dari', position: 'before' },
+    patient: { primary: '', position: 'before' },
+    style: { primary: 'dengan', position: 'before' },
+  },
+} satisfies GrammarProfile;

package/src/languages/pl.ts

@@ -0,0 +1,39 @@
+/**
+ * Polish Grammar
+ *
+ * SVO word order, prepositions, space-separated.
+ * Polish is a fusional language with rich verb conjugation.
+ * Unlike most languages, Polish software UI uses IMPERATIVE form.
+ */
+
+import type { GrammarProfile } from './types';
+
+export const polishGrammar = {
+  code: 'pl',
+  name: 'Polish',
+  nativeName: 'Polski',
+  direction: 'ltr',
+  script: 'latin',
+  wordOrder: 'SVO',
+  markingStrategy: 'preposition',
+  usesSpaces: true,
+  // Polish uses imperative form for commands in software UI
+  // (unlike most languages that use infinitive)
+  defaultVerbForm: 'imperative',
+  verb: {
+    position: 'start',
+    subjectDrop: true,
+    suffixes: ['ać', 'eć', 'ić', 'yć', 'ąć', 'ować'],
+  },
+  possessive: {
+    marker: '', // Polish uses genitive case, not a marker
+    markerPosition: 'after-object',
+    usePossessiveAdjectives: true,
+  },
+  roleMarkers: {
+    destination: { primary: 'do', alternatives: ['w', 'na', 'we'], position: 'before' },
+    source: { primary: 'z', alternatives: ['od', 'ze'], position: 'before' },
+    patient: { primary: '', position: 'before' },
+    style: { primary: 'z', alternatives: ['ze'], position: 'before' },
+  },
+} satisfies GrammarProfile;

package/src/languages/pt.ts

@@ -0,0 +1,34 @@
+/**
+ * Portuguese Grammar
+ *
+ * SVO word order, prepositions, space-separated.
+ * Features rich verb conjugation with pro-drop (subject omission).
+ */
+
+import type { GrammarProfile } from './types';
+
+export const portugueseGrammar = {
+  code: 'pt',
+  name: 'Portuguese',
+  nativeName: 'Português',
+  direction: 'ltr',
+  script: 'latin',
+  wordOrder: 'SVO',
+  markingStrategy: 'preposition',
+  usesSpaces: true,
+  verb: {
+    position: 'start',
+    subjectDrop: true,
+  },
+  possessive: {
+    marker: 'de', // Uses "de" for general possession
+    markerPosition: 'before-property',
+    usePossessiveAdjectives: true,
+  },
+  roleMarkers: {
+    destination: { primary: 'em', alternatives: ['para', 'a'], position: 'before' },
+    source: { primary: 'de', alternatives: ['desde'], position: 'before' },
+    patient: { primary: '', position: 'before' },
+    style: { primary: 'com', position: 'before' },
+  },
+} satisfies GrammarProfile;

package/src/languages/qu.ts

@@ -0,0 +1,34 @@
+/**
+ * Quechua Grammar
+ *
+ * SOV word order, postpositions (suffixes), polysynthetic/agglutinative.
+ * Indigenous language of the Andean region with rich morphology.
+ */
+
+import type { GrammarProfile } from './types';
+
+export const quechuaGrammar = {
+  code: 'qu',
+  name: 'Quechua',
+  nativeName: 'Runasimi',
+  direction: 'ltr',
+  script: 'latin',
+  wordOrder: 'SOV',
+  markingStrategy: 'postposition',
+  usesSpaces: true,
+  verb: {
+    position: 'end',
+    subjectDrop: true,
+  },
+  possessive: {
+    marker: '-pa', // Genitive suffix
+    markerPosition: 'after-object',
+  },
+  roleMarkers: {
+    patient: { primary: 'ta', position: 'after' },
+    destination: { primary: 'man', alternatives: ['pa'], position: 'after' },
+    source: { primary: 'manta', position: 'after' },
+    style: { primary: 'wan', position: 'after' },
+    event: { primary: 'pi', position: 'after' }, // Locative: event occurs "at" (pi)
+  },
+} satisfies GrammarProfile;

package/src/languages/ru.ts

@@ -0,0 +1,37 @@
+/**
+ * Russian Grammar
+ *
+ * SVO word order, prepositions, space-separated.
+ * Russian is a fusional language with rich verb conjugation.
+ * Uses infinitive form in software UI (industry standard).
+ */
+
+import type { GrammarProfile } from './types';
+
+export const russianGrammar = {
+  code: 'ru',
+  name: 'Russian',
+  nativeName: 'Русский',
+  direction: 'ltr',
+  script: 'cyrillic',
+  wordOrder: 'SVO',
+  markingStrategy: 'preposition',
+  usesSpaces: true,
+  defaultVerbForm: 'infinitive',
+  verb: {
+    position: 'start',
+    subjectDrop: true,
+    suffixes: ['ть', 'ться', 'ить', 'иться', 'ать', 'аться', 'еть', 'еться'],
+  },
+  possessive: {
+    marker: '',
+    markerPosition: 'after-object',
+    usePossessiveAdjectives: true,
+  },
+  roleMarkers: {
+    destination: { primary: 'в', alternatives: ['на', 'к', 'во', 'ко'], position: 'before' },
+    source: { primary: 'из', alternatives: ['от', 'с'], position: 'before' },
+    patient: { primary: '', position: 'before' },
+    style: { primary: 'с', alternatives: ['со'], position: 'before' },
+  },
+} satisfies GrammarProfile;

package/src/languages/sw.ts

@@ -0,0 +1,34 @@
+/**
+ * Swahili Grammar
+ *
+ * SVO word order, prepositions, space-separated, agglutinative.
+ * Features noun class system (18 classes) and verb agreement prefixes.
+ */
+
+import type { GrammarProfile } from './types';
+
+export const swahiliGrammar = {
+  code: 'sw',
+  name: 'Swahili',
+  nativeName: 'Kiswahili',
+  direction: 'ltr',
+  script: 'latin',
+  wordOrder: 'SVO',
+  markingStrategy: 'preposition',
+  usesSpaces: true,
+  verb: {
+    position: 'start',
+    subjectDrop: true,
+  },
+  possessive: {
+    marker: '', // Swahili uses possessive pronouns
+    markerPosition: 'after-object',
+    usePossessiveAdjectives: true,
+  },
+  roleMarkers: {
+    destination: { primary: 'kwenye', alternatives: ['kwa'], position: 'before' },
+    source: { primary: 'kutoka', position: 'before' },
+    patient: { primary: '', position: 'before' },
+    style: { primary: 'na', position: 'before' },
+  },
+} satisfies GrammarProfile;

package/src/languages/th.ts

@@ -0,0 +1,44 @@
+/**
+ * Thai Grammar
+ *
+ * SVO word order, prepositions, Thai script.
+ * Isolating language (like Chinese) with no inflection.
+ */
+
+import type { GrammarProfile } from './types';
+
+export const thaiGrammar = {
+  code: 'th',
+  name: 'Thai',
+  nativeName: 'ไทย',
+  direction: 'ltr',
+  script: 'thai',
+  wordOrder: 'SVO',
+  markingStrategy: 'preposition',
+  usesSpaces: false, // Thai doesn't use spaces between words
+  defaultVerbForm: 'base',
+  verb: {
+    position: 'second',
+    subjectDrop: true,
+  },
+  possessive: {
+    marker: 'ของ',
+    markerPosition: 'between',
+  },
+  roleMarkers: {
+    patient: { primary: '', position: 'before' }, // Thai is isolating - no case markers
+    destination: { primary: 'ใน', alternatives: ['ไปยัง'], position: 'before' },
+    source: { primary: 'จาก', position: 'before' },
+    style: { primary: 'ด้วย', position: 'before' },
+    // No `event` role marker: a command's event argument (`trigger foo` /
+    // `send foo`) is an UNMARKED object in Thai, like every other SVO profile
+    // (es/zh/id/…). `เมื่อ` is the temporal "when/on" marker and belongs only on
+    // the event-HANDLER head — which uses `eventHandler.eventMarker` (below),
+    // not this role marker. Carrying it here generated `ทริกเกอร์ เมื่อ {event}`,
+    // which never matched the transformer's `ทริกเกอร์ {event}` → trigger/send
+    // dropped (th behavior-draggable/removable/resizable/sortable lossy).
+  },
+  tokenization: {
+    boundaryStrategy: 'character', // Character-based like Chinese/Japanese
+  },
+} satisfies GrammarProfile;

package/src/languages/tl.ts

@@ -0,0 +1,37 @@
+/**
+ * Tagalog Grammar
+ *
+ * VSO word order, prepositions, space-separated.
+ */
+
+import type { GrammarProfile } from './types';
+
+export const tagalogGrammar = {
+  code: 'tl',
+  name: 'Tagalog',
+  nativeName: 'Tagalog',
+  direction: 'ltr',
+  script: 'latin',
+  wordOrder: 'VSO',
+  markingStrategy: 'preposition',
+  usesSpaces: true,
+  defaultVerbForm: 'base',
+  verb: {
+    position: 'start',
+    subjectDrop: true,
+  },
+  possessive: {
+    marker: 'ng', // Linker used in possessive constructions
+    markerPosition: 'between',
+  },
+  roleMarkers: {
+    // `bago` (before) / `matapos` (after) are positional destination markers for
+    // `put X before/after Y`, mirroring how Arabic lists قبل/بعد as destination
+    // alternatives. Without them the generated put pattern can't match a
+    // before/after target.
+    destination: { primary: 'sa', alternatives: ['bago', 'matapos'], position: 'before' }, // "to/into"
+    source: { primary: 'mula_sa', position: 'before' }, // "from"
+    patient: { primary: '', position: 'before' },
+    style: { primary: 'nang', position: 'before' }, // manner marker
+  },
+} satisfies GrammarProfile;

package/src/languages/tr.ts

@@ -0,0 +1,76 @@
+/**
+ * Turkish Grammar
+ *
+ * SOV word order, case suffixes (agglutinative), space-separated.
+ * Features vowel harmony and extensive suffixation.
+ */
+
+import type { GrammarProfile } from './types';
+
+export const turkishGrammar = {
+  code: 'tr',
+  name: 'Turkish',
+  nativeName: 'Türkçe',
+  direction: 'ltr',
+  script: 'latin',
+  wordOrder: 'SOV',
+  markingStrategy: 'case-suffix',
+  usesSpaces: true,
+  verb: {
+    position: 'end',
+    suffixes: ['mek', 'mak', 'yor', 'di', 'miş'],
+    subjectDrop: true,
+  },
+  // The locative written onto a Turkish word, in the form its harmony gives
+  // (`tıklamada`, `değişiklikte`; M2 N4). Code keeps its suffix apart
+  // (`keyup da`) until a reviewer picks a code word's harmony (FUSED_FORMS.md
+  // Q2); the other case suffixes stay apart on code for the same reason.
+  attachedMarkers: { markers: ['da', 'de', 'ta', 'te'] },
+  possessive: {
+    // Genitive suffix, spaced for tokenization like Turkish's other case
+    // markers (i/e/de). i18n renders `#picker ın değer`; the parser matches
+    // `ın` as the possessive marker. Vowel-harmony variants (in/un/ün) are not
+    // distinguished — the generator emits the `ın` form for all owners.
+    marker: 'ın',
+    markerPosition: 'after-object',
+    usePossessiveAdjectives: true,
+  },
+  roleMarkers: {
+    patient: {
+      primary: 'i',
+      alternatives: ['ı', 'u', 'ü', 'yi', 'yı', 'yu', 'yü', 'ni', 'nı', 'nu', 'nü'],
+      position: 'after',
+    }, // Accusative (with buffer consonants y/n)
+    destination: {
+      primary: 'e',
+      // Include both dative (e/a) and genitive (ın/in/un/ün) for possessive patterns
+      // Genitive is used in "X's Y" patterns: #button ın .active = "#button's .active"
+      alternatives: [
+        'a',
+        'ye',
+        'ya',
+        'ne',
+        'na',
+        'de',
+        'da',
+        'te',
+        'ta',
+        'ın',
+        'in',
+        'un',
+        'ün',
+        'nın',
+        'nin',
+        'nun',
+        'nün',
+      ],
+      position: 'after',
+    }, // Dative/Locative + Genitive (with buffer consonants)
+    source: { primary: 'den', alternatives: ['dan', 'ten', 'tan'], position: 'after' }, // Ablative
+    // `ile` is the free-standing instrumental the transformer actually emits
+    // for with-phrases (`getir method:"POST" body:form ile`); the suffix
+    // forms cover hand-written agglutinated variants.
+    style: { primary: 'le', alternatives: ['la', 'yle', 'yla', 'ile'], position: 'after' }, // Instrumental
+    event: { primary: 'i', alternatives: ['ı', 'u', 'ü'], position: 'after' }, // Event as accusative
+  },
+} satisfies GrammarProfile;

package/src/languages/types.ts

@@ -0,0 +1,145 @@
+/**
+ * A language's grammar: the facts that hold for it whatever a DSL says in it.
+ *
+ * `@lokascript/semantic`'s `LanguageProfile` spreads one of these and adds
+ * hyperscript's vocabulary (keywords, references, event-handler words); a
+ * domain injects one into the bridge builders (`./multilingual`) with its own
+ * vocabulary. Each `languages/<code>` module exports one, as data: no
+ * registration, no side effects.
+ */
+
+/**
+ * Word order in a language (for declarative statements).
+ */
+export type WordOrder = 'SVO' | 'SOV' | 'VSO' | 'VOS' | 'OSV' | 'OVS';
+
+/**
+ * How grammatical relationships are marked.
+ */
+export type MarkingStrategy = 'preposition' | 'postposition' | 'particle' | 'case-suffix';
+
+/**
+ * Writing system used by a language.
+ * Non-latin scripts require AsciiIdentifierExtractor in their tokenizer
+ * to handle mixed-script input (e.g., Arabic verb + CSS property name).
+ */
+export type ScriptType =
+  'latin' | 'cyrillic' | 'arabic' | 'cjk' | 'devanagari' | 'hangul' | 'bengali' | 'thai' | 'hebrew';
+
+/**
+ * A grammatical marker (preposition, particle, etc.) for a semantic role.
+ */
+export interface RoleMarker {
+  /** Primary marker for this role */
+  readonly primary: string;
+  /** Alternative markers that also work */
+  readonly alternatives?: string[];
+  /** Position relative to the role value */
+  readonly position: 'before' | 'after';
+}
+
+/**
+ * Verb form configuration for a language.
+ */
+export interface VerbConfig {
+  /** Position of verb in the sentence */
+  readonly position: 'start' | 'end' | 'second';
+  /** Common verb suffixes/conjugations to recognize */
+  readonly suffixes?: string[];
+  /** Whether the language commonly drops subjects */
+  readonly subjectDrop?: boolean;
+}
+
+/**
+ * Verb form used for command keywords.
+ *
+ * Based on software localization research:
+ * - 'infinitive': Standard for most languages (Spanish, French, German, Russian)
+ *   Example: "Guardar", "Enregistrer", "Speichern"
+ * - 'imperative': Used by some languages (Polish)
+ *   Example: "Zapisz", "Otwórz"
+ * - 'base': For languages where forms are identical (English, Japanese, Korean)
+ *   or where the distinction doesn't apply
+ */
+export type VerbForm = 'infinitive' | 'imperative' | 'base';
+
+/**
+ * Special tokenization configuration.
+ */
+export interface TokenizationConfig {
+  /** Particles to recognize (for particle languages) */
+  readonly particles?: string[];
+  /** Prefixes to recognize (for prefixing languages) */
+  readonly prefixes?: string[];
+  /** Word boundary detection strategy */
+  readonly boundaryStrategy?: 'space' | 'particle' | 'character';
+}
+
+/**
+ * How "X's Y" is built in a language. The possessive WORDS (my, your, its)
+ * are vocabulary, and stay with the DSL that names the references.
+ */
+export interface PossessiveGrammar {
+  /** Possessive marker (e.g., "'s" in English, "の" in Japanese) */
+  readonly marker: string;
+  /** Position of marker: 'after-object' (X's Y), 'between' (X の Y), 'before-property' */
+  readonly markerPosition: 'after-object' | 'between' | 'before-property';
+  /** Whether to use possessive adjectives instead of marker (e.g., Spanish mi/tu/su) */
+  readonly usePossessiveAdjectives?: boolean;
+}
+
+/**
+ * Role markers written onto the word before them, as the language writes its
+ * case particles (M2 N5): ko `#out에`, ja `#outに`, bn `#outকে`. `markers`
+ * attach after code (a selector, a variable, a string); `afterWords` also
+ * after a word of the language, where its spelling does not change the
+ * marker (`'all'`; bn lists `কে`, and its locative takes the word's form by
+ * its own rule: `ক্লিকে`, `জমাতে`). ko picks each particle's form by the
+ * word's final consonant (`나를`).
+ */
+export interface AttachedMarkers {
+  readonly markers: readonly string[];
+  readonly afterWords?: 'all' | readonly string[];
+}
+
+/**
+ * One language's grammar. A structural superset of the bridge's
+ * `GrammarProfileSlice`, so it injects into the builders as is.
+ */
+export interface GrammarProfile {
+  /** ISO 639-1 or BCP 47 language code (e.g., 'es' or 'en-US') */
+  readonly code: string;
+  /** Human-readable language name */
+  readonly name: string;
+  /** Native name */
+  readonly nativeName: string;
+  /** Text direction */
+  readonly direction: 'ltr' | 'rtl';
+  /** Writing system — non-latin scripts require AsciiIdentifierExtractor in their tokenizer */
+  readonly script: ScriptType;
+  /** Primary word order */
+  readonly wordOrder: WordOrder;
+  /** How this language marks grammatical roles */
+  readonly markingStrategy: MarkingStrategy;
+  /** Whether the language uses spaces between words */
+  readonly usesSpaces: boolean;
+  /** Markers for each semantic role */
+  readonly roleMarkers: { readonly [role: string]: RoleMarker | undefined };
+  /** Verb configuration */
+  readonly verb: VerbConfig;
+  /** Special tokenization notes */
+  readonly tokenization?: TokenizationConfig;
+  /**
+   * Default verb form for command keywords. Defaults to 'infinitive'.
+   *
+   * Based on software UI localization research:
+   * - 'infinitive': Spanish, French, German, Portuguese, Russian (industry standard)
+   * - 'imperative': Polish
+   * - 'base': English, Japanese, Korean (no distinction or same form)
+   */
+  readonly defaultVerbForm?: VerbForm;
+  /** Role markers the language writes onto the word before them */
+  readonly attachedMarkers?: AttachedMarkers;
+  /** How the language builds "X's Y" */
+  readonly possessive?: PossessiveGrammar;
+}

package/src/languages/uk.ts

@@ -0,0 +1,37 @@
+/**
+ * Ukrainian Grammar
+ *
+ * SVO word order, prepositions, space-separated.
+ * Ukrainian is a fusional language with rich verb conjugation.
+ * Uses infinitive form in software UI (industry standard).
+ */
+
+import type { GrammarProfile } from './types';
+
+export const ukrainianGrammar = {
+  code: 'uk',
+  name: 'Ukrainian',
+  nativeName: 'Українська',
+  direction: 'ltr',
+  script: 'cyrillic',
+  wordOrder: 'SVO',
+  markingStrategy: 'preposition',
+  usesSpaces: true,
+  defaultVerbForm: 'infinitive',
+  verb: {
+    position: 'start',
+    subjectDrop: true,
+    suffixes: ['ти', 'тися', 'ити', 'итися', 'ати', 'атися', 'іти', 'ітися'],
+  },
+  possessive: {
+    marker: '',
+    markerPosition: 'after-object',
+    usePossessiveAdjectives: true,
+  },
+  roleMarkers: {
+    destination: { primary: 'в', alternatives: ['на', 'до'], position: 'before' },
+    source: { primary: 'з', alternatives: ['від', 'із'], position: 'before' },
+    patient: { primary: '', position: 'before' },
+    style: { primary: 'з', alternatives: ['із'], position: 'before' },
+  },
+} satisfies GrammarProfile;