@lokascript/semantic 1.0.0

package/src/patterns/languages/en/set.ts

@@ -0,0 +1,48 @@
+/**
+ * English Set Patterns
+ *
+ * Hand-crafted patterns for set command with possessive syntax support.
+ */
+
+import type { LanguagePattern } from '../../../types';
+
+/**
+ * English: "set {target} to {value}"
+ * Handles all set command variants including possessive syntax.
+ * Higher priority than generated setSchema to capture property-path types.
+ *
+ * Examples:
+ * - set x to 5 (simple variable)
+ * - set :localVar to 'hello' (local scope)
+ * - set #el's *opacity to 0.5 (possessive CSS property)
+ * - set my innerHTML to 'content' (possessive reference)
+ */
+export const setPossessiveEnglish: LanguagePattern = {
+  id: 'set-en-possessive',
+  language: 'en',
+  command: 'set',
+  priority: 100, // Higher than generated setSchema (80)
+  template: {
+    format: 'set {destination} to {patient}',
+    tokens: [
+      { type: 'literal', value: 'set' },
+      // Role token with property-path support for possessive syntax
+      {
+        type: 'role',
+        role: 'destination',
+        expectedTypes: ['property-path', 'selector', 'reference', 'expression'],
+      },
+      { type: 'literal', value: 'to' },
+      { type: 'role', role: 'patient', expectedTypes: ['literal', 'expression', 'reference'] },
+    ],
+  },
+  extraction: {
+    destination: { position: 1 },
+    patient: { marker: 'to' },
+  },
+};
+
+/**
+ * All English set patterns.
+ */
+export const setPatternsEn: LanguagePattern[] = [setPossessiveEnglish];

package/src/patterns/languages/en/swap.ts

@@ -0,0 +1,38 @@
+/**
+ * English Swap Patterns
+ *
+ * Hand-crafted patterns for swap command without prepositions.
+ */
+
+import type { LanguagePattern } from '../../../types';
+
+/**
+ * English: "swap <strategy> <target>" without prepositions.
+ * Examples:
+ * - swap delete #item
+ * - swap innerHTML #target
+ * - swap outerHTML me
+ */
+export const swapSimpleEnglish: LanguagePattern = {
+  id: 'swap-en-handcrafted',
+  language: 'en',
+  command: 'swap',
+  priority: 110, // Higher than generated patterns
+  template: {
+    format: 'swap {method} {destination}',
+    tokens: [
+      { type: 'literal', value: 'swap' },
+      { type: 'role', role: 'method' },
+      { type: 'role', role: 'destination' },
+    ],
+  },
+  extraction: {
+    method: { position: 1 },
+    destination: { position: 2 },
+  },
+};
+
+/**
+ * All English swap patterns.
+ */
+export const swapPatternsEn: LanguagePattern[] = [swapSimpleEnglish];

package/src/patterns/languages/en/temporal.ts

@@ -0,0 +1,57 @@
+/**
+ * English Temporal Expression Patterns
+ *
+ * Hand-crafted patterns for natural temporal delay idioms.
+ */
+
+import type { LanguagePattern } from '../../../types';
+
+/**
+ * English: "in 2s toggle .active" - Natural temporal delay
+ * Transforms to: wait 2s then toggle .active
+ *
+ * This is a beginner-friendly idiom for delayed execution.
+ * Supports: 2s, 500ms, 2 seconds, 500 milliseconds
+ */
+export const temporalInEnglish: LanguagePattern = {
+  id: 'temporal-en-in',
+  language: 'en',
+  command: 'wait',
+  priority: 95, // Lower than standard wait patterns
+  template: {
+    format: 'in {duration}',
+    tokens: [
+      { type: 'literal', value: 'in' },
+      { type: 'role', role: 'duration', expectedTypes: ['literal', 'expression'] },
+    ],
+  },
+  extraction: {
+    duration: { position: 1 },
+  },
+};
+
+/**
+ * English: "after 2s show #tooltip" - Natural temporal delay (alternative)
+ * Transforms to: wait 2s then show #tooltip
+ */
+export const temporalAfterEnglish: LanguagePattern = {
+  id: 'temporal-en-after',
+  language: 'en',
+  command: 'wait',
+  priority: 95, // Lower than standard wait patterns
+  template: {
+    format: 'after {duration}',
+    tokens: [
+      { type: 'literal', value: 'after' },
+      { type: 'role', role: 'duration', expectedTypes: ['literal', 'expression'] },
+    ],
+  },
+  extraction: {
+    duration: { position: 1 },
+  },
+};
+
+/**
+ * All English temporal patterns.
+ */
+export const temporalPatternsEn: LanguagePattern[] = [temporalInEnglish, temporalAfterEnglish];

package/src/patterns/put/ar.ts

@@ -0,0 +1,74 @@
+/**
+ * Arabic Put Patterns
+ *
+ * Tree-shakeable: Only included when Arabic is imported.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+/**
+ * Get Arabic put patterns.
+ */
+export function getPutPatternsAr(): LanguagePattern[] {
+  return [
+    {
+      id: 'put-ar-full',
+      language: 'ar',
+      command: 'put',
+      priority: 100,
+      template: {
+        format: 'ضع {patient} في {destination}',
+        tokens: [
+          { type: 'literal', value: 'ضع', alternatives: ['اضع', 'يضع'] },
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'في', alternatives: ['إلى', 'الى'] },
+          { type: 'role', role: 'destination' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { marker: 'في', markerAlternatives: ['إلى', 'الى'] },
+      },
+    },
+    {
+      id: 'put-ar-before',
+      language: 'ar',
+      command: 'put',
+      priority: 95,
+      template: {
+        format: 'ضع {patient} قبل {destination}',
+        tokens: [
+          { type: 'literal', value: 'ضع' },
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'قبل' },
+          { type: 'role', role: 'destination' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { marker: 'قبل' },
+        manner: { default: { type: 'literal', value: 'before' } },
+      },
+    },
+    {
+      id: 'put-ar-after',
+      language: 'ar',
+      command: 'put',
+      priority: 95,
+      template: {
+        format: 'ضع {patient} بعد {destination}',
+        tokens: [
+          { type: 'literal', value: 'ضع' },
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'بعد' },
+          { type: 'role', role: 'destination' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { marker: 'بعد' },
+        manner: { default: { type: 'literal', value: 'after' } },
+      },
+    },
+  ];
+}

package/src/patterns/put/bn.ts

@@ -0,0 +1,53 @@
+/**
+ * Bengali Put Patterns
+ *
+ * Patterns for parsing "put" command in Bengali.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+export function getPutPatternsBn(): LanguagePattern[] {
+  return [
+    // Full pattern: 'hello' কে #output এ রাখুন
+    {
+      id: 'put-bn-full',
+      language: 'bn',
+      command: 'put',
+      priority: 100,
+      template: {
+        format: '{patient} কে {destination} এ রাখুন',
+        tokens: [
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'কে' },
+          { type: 'role', role: 'destination' },
+          { type: 'literal', value: 'এ', alternatives: ['তে'] },
+          { type: 'literal', value: 'রাখুন', alternatives: ['রাখ'] },
+        ],
+      },
+      extraction: {
+        patient: { position: 0 },
+        destination: { marker: 'এ', position: 2 },
+      },
+    },
+    // Simple pattern: রাখুন 'hello' #output এ
+    {
+      id: 'put-bn-simple',
+      language: 'bn',
+      command: 'put',
+      priority: 90,
+      template: {
+        format: 'রাখুন {patient} {destination} এ',
+        tokens: [
+          { type: 'literal', value: 'রাখুন', alternatives: ['রাখ'] },
+          { type: 'role', role: 'patient' },
+          { type: 'role', role: 'destination' },
+          { type: 'literal', value: 'এ', alternatives: ['তে'] },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { position: 2 },
+      },
+    },
+  ];
+}

package/src/patterns/put/en.ts

@@ -0,0 +1,74 @@
+/**
+ * English Put Patterns
+ *
+ * Tree-shakeable: Only included when English is imported.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+/**
+ * Get English put patterns.
+ */
+export function getPutPatternsEn(): LanguagePattern[] {
+  return [
+    {
+      id: 'put-en-into',
+      language: 'en',
+      command: 'put',
+      priority: 100,
+      template: {
+        format: 'put {patient} into {destination}',
+        tokens: [
+          { type: 'literal', value: 'put' },
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'into', alternatives: ['in', 'to'] },
+          { type: 'role', role: 'destination' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { marker: 'into', markerAlternatives: ['in', 'to'] },
+      },
+    },
+    {
+      id: 'put-en-before',
+      language: 'en',
+      command: 'put',
+      priority: 95,
+      template: {
+        format: 'put {patient} before {destination}',
+        tokens: [
+          { type: 'literal', value: 'put' },
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'before' },
+          { type: 'role', role: 'destination' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { marker: 'before' },
+        manner: { default: { type: 'literal', value: 'before' } },
+      },
+    },
+    {
+      id: 'put-en-after',
+      language: 'en',
+      command: 'put',
+      priority: 95,
+      template: {
+        format: 'put {patient} after {destination}',
+        tokens: [
+          { type: 'literal', value: 'put' },
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'after' },
+          { type: 'role', role: 'destination' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { marker: 'after' },
+        manner: { default: { type: 'literal', value: 'after' } },
+      },
+    },
+  ];
+}

package/src/patterns/put/es.ts

@@ -0,0 +1,74 @@
+/**
+ * Spanish Put Patterns
+ *
+ * Tree-shakeable: Only included when Spanish is imported.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+/**
+ * Get Spanish put patterns.
+ */
+export function getPutPatternsEs(): LanguagePattern[] {
+  return [
+    {
+      id: 'put-es-full',
+      language: 'es',
+      command: 'put',
+      priority: 100,
+      template: {
+        format: 'poner {patient} en {destination}',
+        tokens: [
+          { type: 'literal', value: 'poner', alternatives: ['pon', 'colocar', 'put'] },
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'en', alternatives: ['dentro de', 'a'] },
+          { type: 'role', role: 'destination' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { marker: 'en', markerAlternatives: ['dentro de', 'a'] },
+      },
+    },
+    {
+      id: 'put-es-before',
+      language: 'es',
+      command: 'put',
+      priority: 95,
+      template: {
+        format: 'poner {patient} antes de {destination}',
+        tokens: [
+          { type: 'literal', value: 'poner', alternatives: ['pon', 'colocar'] },
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'antes de', alternatives: ['antes'] },
+          { type: 'role', role: 'destination' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { marker: 'antes de', markerAlternatives: ['antes'] },
+        manner: { default: { type: 'literal', value: 'before' } },
+      },
+    },
+    {
+      id: 'put-es-after',
+      language: 'es',
+      command: 'put',
+      priority: 95,
+      template: {
+        format: 'poner {patient} después de {destination}',
+        tokens: [
+          { type: 'literal', value: 'poner', alternatives: ['pon', 'colocar'] },
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'después de', alternatives: ['despues de', 'después'] },
+          { type: 'role', role: 'destination' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { marker: 'después de', markerAlternatives: ['despues de', 'después'] },
+        manner: { default: { type: 'literal', value: 'after' } },
+      },
+    },
+  ];
+}

package/src/patterns/put/hi.ts

@@ -0,0 +1,69 @@
+/**
+ * Hindi Put Patterns
+ *
+ * Patterns for parsing "put" command in Hindi.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+export function getPutPatternsHi(): LanguagePattern[] {
+  return [
+    // Full pattern: "text" को #element में रखें
+    {
+      id: 'put-hi-full',
+      language: 'hi',
+      command: 'put',
+      priority: 100,
+      template: {
+        format: '{patient} को {destination} में रखें',
+        tokens: [
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'को' },
+          { type: 'role', role: 'destination' },
+          { type: 'literal', value: 'में' },
+          { type: 'literal', value: 'रखें', alternatives: ['रख', 'डालें', 'डाल'] },
+        ],
+      },
+      extraction: {
+        patient: { position: 0 },
+        destination: { marker: 'में', position: 3 },
+      },
+    },
+    // Simple pattern: "text" रखें
+    {
+      id: 'put-hi-simple',
+      language: 'hi',
+      command: 'put',
+      priority: 90,
+      template: {
+        format: '{patient} रखें',
+        tokens: [
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'रखें', alternatives: ['रख', 'डालें', 'डाल'] },
+        ],
+      },
+      extraction: {
+        patient: { position: 0 },
+        destination: { default: { type: 'reference', value: 'me' } },
+      },
+    },
+    // Bare pattern: रखें "text"
+    {
+      id: 'put-hi-bare',
+      language: 'hi',
+      command: 'put',
+      priority: 80,
+      template: {
+        format: 'रखें {patient}',
+        tokens: [
+          { type: 'literal', value: 'रखें', alternatives: ['रख', 'डालें', 'डाल'] },
+          { type: 'role', role: 'patient' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { default: { type: 'reference', value: 'me' } },
+      },
+    },
+  ];
+}

package/src/patterns/put/id.ts

@@ -0,0 +1,96 @@
+/**
+ * Indonesian Put Patterns
+ *
+ * Hand-crafted patterns for "put" command.
+ * Indonesian: taruh "halo" ke dalam #output
+ *
+ * Note: Indonesian uses two-word preposition "ke dalam" (into)
+ * We support both the full form and simplified forms.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+/**
+ * Get Indonesian put patterns.
+ */
+export function getPutPatternsId(): LanguagePattern[] {
+  return [
+    {
+      id: 'put-id-full',
+      language: 'id',
+      command: 'put',
+      priority: 100,
+      template: {
+        // Two-word preposition: "ke dalam"
+        format: 'taruh {patient} ke dalam {destination}',
+        tokens: [
+          {
+            type: 'literal',
+            value: 'taruh',
+            alternatives: ['letakkan', 'masukkan', 'tempatkan', 'put'],
+          },
+          {
+            type: 'role',
+            role: 'patient',
+            expectedTypes: ['literal', 'selector', 'reference', 'expression'],
+          },
+          { type: 'literal', value: 'ke' },
+          { type: 'literal', value: 'dalam', alternatives: ['di'] },
+          { type: 'role', role: 'destination', expectedTypes: ['selector', 'reference'] },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { position: 4 },
+      },
+    },
+    {
+      id: 'put-id-simple-ke',
+      language: 'id',
+      command: 'put',
+      priority: 95,
+      template: {
+        // Simplified: just "ke" without "dalam"
+        format: 'taruh {patient} ke {destination}',
+        tokens: [
+          { type: 'literal', value: 'taruh', alternatives: ['letakkan', 'masukkan', 'tempatkan'] },
+          {
+            type: 'role',
+            role: 'patient',
+            expectedTypes: ['literal', 'selector', 'reference', 'expression'],
+          },
+          { type: 'literal', value: 'ke', alternatives: ['di', 'pada'] },
+          { type: 'role', role: 'destination', expectedTypes: ['selector', 'reference'] },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { position: 3 },
+      },
+    },
+    {
+      id: 'put-id-di',
+      language: 'id',
+      command: 'put',
+      priority: 90,
+      template: {
+        // Alternative with "di"
+        format: 'taruh {patient} di {destination}',
+        tokens: [
+          { type: 'literal', value: 'taruh', alternatives: ['letakkan', 'masukkan'] },
+          {
+            type: 'role',
+            role: 'patient',
+            expectedTypes: ['literal', 'selector', 'reference', 'expression'],
+          },
+          { type: 'literal', value: 'di' },
+          { type: 'role', role: 'destination', expectedTypes: ['selector', 'reference'] },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { position: 3 },
+      },
+    },
+  ];
+}

package/src/patterns/put/index.ts

@@ -0,0 +1,99 @@
+/**
+ * Put Command Patterns
+ *
+ * Hand-crafted patterns for "put" command across languages.
+ *
+ * @generated This file is auto-generated. Do not edit manually.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+import { getPutPatternsAr } from './ar';
+import { getPutPatternsBn } from './bn';
+import { getPutPatternsEn } from './en';
+import { getPutPatternsEs } from './es';
+import { getPutPatternsHi } from './hi';
+import { getPutPatternsId } from './id';
+import { getPutPatternsIt } from './it';
+import { getPutPatternsJa } from './ja';
+import { getPutPatternsKo } from './ko';
+import { getPutPatternsMs } from './ms';
+import { getPutPatternsPl } from './pl';
+import { getPutPatternsRu } from './ru';
+import { getPutPatternsTh } from './th';
+import { getPutPatternsTl } from './tl';
+import { getPutPatternsTr } from './tr';
+import { getPutPatternsUk } from './uk';
+import { getPutPatternsVi } from './vi';
+import { getPutPatternsZh } from './zh';
+
+/**
+ * Get put patterns for a specific language.
+ */
+export function getPutPatternsForLanguage(language: string): LanguagePattern[] {
+  switch (language) {
+    case 'ar':
+      return getPutPatternsAr();
+    case 'bn':
+      return getPutPatternsBn();
+    case 'en':
+      return getPutPatternsEn();
+    case 'es':
+      return getPutPatternsEs();
+    case 'hi':
+      return getPutPatternsHi();
+    case 'id':
+      return getPutPatternsId();
+    case 'it':
+      return getPutPatternsIt();
+    case 'ja':
+      return getPutPatternsJa();
+    case 'ko':
+      return getPutPatternsKo();
+    case 'ms':
+      return getPutPatternsMs();
+    case 'pl':
+      return getPutPatternsPl();
+    case 'ru':
+      return getPutPatternsRu();
+    case 'th':
+      return getPutPatternsTh();
+    case 'tl':
+      return getPutPatternsTl();
+    case 'tr':
+      return getPutPatternsTr();
+    case 'uk':
+      return getPutPatternsUk();
+    case 'vi':
+      return getPutPatternsVi();
+    case 'zh':
+      return getPutPatternsZh();
+    default:
+      return [];
+  }
+}
+
+// Re-export language-specific getters for tree-shaking
+export { getPutPatternsAr } from './ar';
+export { getPutPatternsBn } from './bn';
+export { getPutPatternsEn } from './en';
+export { getPutPatternsEs } from './es';
+export { getPutPatternsHi } from './hi';
+export { getPutPatternsId } from './id';
+export { getPutPatternsIt } from './it';
+export { getPutPatternsJa } from './ja';
+export { getPutPatternsKo } from './ko';
+export { getPutPatternsMs } from './ms';
+export { getPutPatternsPl } from './pl';
+export { getPutPatternsRu } from './ru';
+export { getPutPatternsTh } from './th';
+export { getPutPatternsTl } from './tl';
+export { getPutPatternsTr } from './tr';
+export { getPutPatternsUk } from './uk';
+export { getPutPatternsVi } from './vi';
+export { getPutPatternsZh } from './zh';
+
+/**
+ * Languages that have hand-crafted put patterns.
+ */
+export const putPatternLanguages = ['ar', 'bn', 'en', 'es', 'hi', 'id', 'it', 'ja', 'ko', 'ms', 'pl', 'ru', 'th', 'tl', 'tr', 'uk', 'vi', 'zh'];