@lokascript/compilation-service 2.11.1 → 3.1.0

package/dist/index.js

@@ -11,7 +11,7 @@ import {
   extractOperations,
   generateCacheKey,
   scoreNodes
-} from "./chunk-HRUSP6F2.js";
+} from "./chunk-5CZBYL6A.js";
 import "./chunk-GBPMR66W.js";
 
 // src/input/json-schema.ts

package/dist/multilingual-VYI3FTN7.js

@@ -0,0 +1,485 @@
+import "./chunk-GBPMR66W.js";
+
+// ../core/dist/multilingual/index.mjs
+import { getSchema } from "@lokascript/semantic";
+
+// ../intent/dist/index.js
+function inferRolesFromSchema(schema, args, modifiers, target, adapter) {
+  const roles = {};
+  const skipTokens = new Set(schema.argSkipTokens ?? []);
+  const usedArgIndices = /* @__PURE__ */ new Set();
+  for (const role of schema.roles) {
+    const markers = englishMarkers(role);
+    if (markers.length === 0) continue;
+    let matched = tryModifierMarkers(role, markers, modifiers, adapter);
+    if (!matched) {
+      matched = tryArgMarkers(role, markers, args, skipTokens, usedArgIndices, adapter);
+    }
+    if (matched) {
+      roles[role.role] = matched.value;
+      if (role.methodCarrier) {
+        roles[role.methodCarrier] = adapter.createLiteralValue(matched.matchedMarker);
+      }
+    }
+  }
+  if (target !== void 0) {
+    const tgtRole = schema.targetRole ?? "destination";
+    if (roles[tgtRole] === void 0) {
+      roles[tgtRole] = adapter.convertValue(target);
+    }
+  }
+  const positionalRoles = schema.roles.filter((r) => englishMarkers(r).length === 0 && roles[r.role] === void 0).sort((a, b) => (a.svoPosition ?? 99) - (b.svoPosition ?? 99));
+  let cursor = 0;
+  for (const role of positionalRoles) {
+    while (cursor < args.length) {
+      if (usedArgIndices.has(cursor)) {
+        cursor++;
+        continue;
+      }
+      const name = adapter.getIdentifierName(args[cursor]);
+      if (name !== void 0 && skipTokens.has(name)) {
+        cursor++;
+        continue;
+      }
+      roles[role.role] = adapter.convertValue(args[cursor]);
+      usedArgIndices.add(cursor);
+      cursor++;
+      break;
+    }
+  }
+  return roles;
+}
+function englishMarkers(role) {
+  const primary = role.markerOverride?.en;
+  const variants = role.markerVariants?.en ?? [];
+  const out = [];
+  if (typeof primary === "string" && primary !== "") out.push(primary);
+  for (const v of variants) if (v !== "") out.push(v);
+  return out;
+}
+function tryModifierMarkers(_role, markers, modifiers, adapter) {
+  if (!modifiers) return void 0;
+  for (const m of markers) {
+    if (!(m in modifiers)) continue;
+    const raw = modifiers[m];
+    if (raw === void 0 || raw === null) continue;
+    if (typeof raw === "string") {
+      return { value: adapter.createLiteralValue(raw), matchedMarker: m };
+    }
+    if (typeof raw === "object" && "type" in raw) {
+      return { value: adapter.convertValue(raw), matchedMarker: m };
+    }
+  }
+  return void 0;
+}
+function tryArgMarkers(_role, markers, args, skipTokens, usedArgIndices, adapter) {
+  const sorted = [...markers].sort((a, b) => b.split(/\s+/).length - a.split(/\s+/).length);
+  for (const marker of sorted) {
+    const words = marker.split(/\s+/).filter((w) => w.length > 0);
+    if (words.length === 0) continue;
+    for (let i = 0; i + words.length <= args.length; i++) {
+      let allMatch = true;
+      for (let w = 0; w < words.length; w++) {
+        if (usedArgIndices.has(i + w)) {
+          allMatch = false;
+          break;
+        }
+        const name = adapter.getIdentifierName(args[i + w]);
+        if (name !== words[w]) {
+          allMatch = false;
+          break;
+        }
+      }
+      if (!allMatch) continue;
+      for (let v = i + words.length; v < args.length; v++) {
+        if (usedArgIndices.has(v)) continue;
+        const name = adapter.getIdentifierName(args[v]);
+        if (name !== void 0 && skipTokens.has(name)) continue;
+        for (let w = 0; w < words.length; w++) usedArgIndices.add(i + w);
+        usedArgIndices.add(v);
+        return { value: adapter.convertValue(args[v]), matchedMarker: marker };
+      }
+    }
+  }
+  return void 0;
+}
+
+// ../core/dist/multilingual/index.mjs
+var DEFAULT_CONFIDENCE_THRESHOLD = 0.5;
+function checkDebugEnabled() {
+  if (typeof localStorage !== "undefined") {
+    try {
+      const ls = localStorage;
+      const setting = ls.getItem("hyperfixi:debug") || ls.getItem("lokascript:debug");
+      if (setting === "*" || setting === "true")
+        return true;
+    } catch {
+    }
+  }
+  if (typeof window !== "undefined" && window.__HYPERFIXI_DEBUG__) {
+    return true;
+  }
+  if (typeof process !== "undefined" && process.env?.HYPERFIXI_DEBUG === "true") {
+    return true;
+  }
+  return false;
+}
+var isDebugEnabled = checkDebugEnabled();
+var DEBUG = {
+  commands: isDebugEnabled,
+  events: isDebugEnabled,
+  parsing: isDebugEnabled,
+  expressions: isDebugEnabled,
+  styles: isDebugEnabled,
+  runtime: isDebugEnabled,
+  loops: isDebugEnabled,
+  async: isDebugEnabled
+};
+var debug = {
+  command: (...args) => {
+    if (DEBUG.commands)
+      console.log("\u{1F527}", ...args);
+  },
+  event: (...args) => {
+    if (DEBUG.events)
+      console.log("\u{1F3AF}", ...args);
+  },
+  parse: (...args) => {
+    if (DEBUG.parsing)
+      console.log("\u{1F4DD}", ...args);
+  },
+  expr: (...args) => {
+    if (DEBUG.expressions)
+      console.log("\u{1F50D}", ...args);
+  },
+  expressions: (...args) => {
+    if (DEBUG.expressions)
+      console.log("\u{1F50D}", ...args);
+  },
+  style: (...args) => {
+    if (DEBUG.styles)
+      console.log("\u{1F3A8}", ...args);
+  },
+  runtime: (...args) => {
+    if (DEBUG.runtime)
+      console.log("\u{1F680}", ...args);
+  },
+  loop: (...args) => {
+    if (DEBUG.loops)
+      console.log("\u{1F501}", ...args);
+  },
+  async: (...args) => {
+    if (DEBUG.async)
+      console.log("\u23F3", ...args);
+  }
+};
+function unconsumedInputWarnings(node) {
+  const diagnostics = node.diagnostics;
+  if (!diagnostics?.length)
+    return [];
+  return diagnostics.filter((d) => d.code === "unconsumed-input").map((d) => d.message);
+}
+var _semanticModule = null;
+async function getSemanticModule() {
+  if (!_semanticModule) {
+    _semanticModule = await import("@lokascript/semantic");
+  }
+  return _semanticModule;
+}
+var SemanticGrammarBridge = class {
+  constructor(config = {}) {
+    this._initialized = false;
+    this.config = {
+      confidenceThreshold: config.confidenceThreshold ?? DEFAULT_CONFIDENCE_THRESHOLD,
+      fallbackOnLowConfidence: config.fallbackOnLowConfidence ?? true
+    };
+  }
+  async initialize() {
+    await getSemanticModule();
+    this._initialized = true;
+  }
+  isInitialized() {
+    return this._initialized;
+  }
+  async transform(input, sourceLang, targetLang) {
+    if (!this.isInitialized()) {
+      await this.initialize();
+    }
+    if (sourceLang === targetLang) {
+      return {
+        output: input,
+        usedSemantic: false,
+        confidence: 1,
+        sourceLang,
+        targetLang
+      };
+    }
+    const semantic = await getSemanticModule();
+    try {
+      const output = semantic.translate(input, sourceLang, targetLang);
+      if (output !== input) {
+        return {
+          output,
+          usedSemantic: true,
+          confidence: 0.9,
+          sourceLang,
+          targetLang
+        };
+      }
+    } catch {
+    }
+    return {
+      output: input,
+      usedSemantic: false,
+      confidence: 0,
+      sourceLang,
+      targetLang
+    };
+  }
+  async parse(input, lang) {
+    if (!this.isInitialized()) {
+      await this.initialize();
+    }
+    const semantic = await getSemanticModule();
+    const result = semantic.parseSemantic(input, lang);
+    return result.node ?? null;
+  }
+  async render(node, targetLang) {
+    const semantic = await getSemanticModule();
+    return semantic.render(node, targetLang);
+  }
+  async parseToAST(input, lang) {
+    if (!this.isInitialized()) {
+      await this.initialize();
+    }
+    const semantic = await getSemanticModule();
+    const result = semantic.parseSemantic(input, lang);
+    if (result.confidence >= this.config.confidenceThreshold && result.node) {
+      try {
+        const buildResult = semantic.buildAST(result.node);
+        return buildResult.ast;
+      } catch (error) {
+        debug.runtime("[SemanticGrammarBridge] AST build failed, using fallback:", error);
+      }
+    }
+    return null;
+  }
+  async parseToASTWithDetails(input, lang) {
+    if (!this.isInitialized()) {
+      await this.initialize();
+    }
+    const semantic = await getSemanticModule();
+    const result = semantic.parseSemantic(input, lang);
+    if (result.confidence >= this.config.confidenceThreshold && result.node) {
+      try {
+        const buildResult = semantic.buildAST(result.node);
+        return {
+          ast: buildResult.ast,
+          usedDirectPath: true,
+          confidence: result.confidence,
+          lang,
+          fallbackText: null,
+          warnings: [...buildResult.warnings ?? [], ...unconsumedInputWarnings(result.node)]
+        };
+      } catch {
+      }
+    }
+    if (result.node && this.config.fallbackOnLowConfidence) {
+      const englishText = semantic.render(result.node, "en");
+      return {
+        ast: null,
+        usedDirectPath: false,
+        confidence: result.confidence,
+        lang,
+        fallbackText: englishText
+      };
+    }
+    return {
+      ast: null,
+      usedDirectPath: false,
+      confidence: result.confidence,
+      lang,
+      fallbackText: null
+    };
+  }
+  async getAllTranslations(input, sourceLang) {
+    const semantic = await getSemanticModule();
+    const languages = semantic.getSupportedLanguages();
+    const results = {};
+    for (const lang of languages) {
+      results[lang] = await this.transform(input, sourceLang, lang);
+    }
+    return results;
+  }
+};
+var _defaultBridge = null;
+async function getDefaultBridge() {
+  if (!_defaultBridge) {
+    _defaultBridge = new SemanticGrammarBridge();
+    await _defaultBridge.initialize();
+  }
+  return _defaultBridge;
+}
+async function translate(input, sourceLang, targetLang) {
+  const bridge = await getDefaultBridge();
+  const result = await bridge.transform(input, sourceLang, targetLang);
+  return result.output;
+}
+var INTERCHANGE_ADAPTER = {
+  getIdentifierName(node) {
+    if (node.type !== "identifier")
+      return void 0;
+    const ident = node;
+    if (typeof ident.name === "string" && ident.name !== "")
+      return ident.name;
+    if (typeof ident.value === "string")
+      return ident.value;
+    return void 0;
+  },
+  convertValue(node) {
+    return node;
+  },
+  createLiteralValue(text) {
+    return { type: "literal", value: text };
+  }
+};
+var schemaRoleInferrer = (name, args, modifiers, target) => {
+  const schema = getSchema(name);
+  if (!schema)
+    return null;
+  const inferred = inferRolesFromSchema(schema, args, modifiers, target, INTERCHANGE_ADAPTER);
+  const declared = schema.ast?.modifiers;
+  if (declared && modifiers) {
+    for (const [key, role] of Object.entries(declared)) {
+      const value = modifiers[key];
+      const isNode = !!value && typeof value === "object" && "type" in value;
+      if (isNode && inferred[role] === void 0) {
+        inferred[role] = value;
+      }
+    }
+  }
+  return Object.keys(inferred).length > 0 ? inferred : null;
+};
+var MultilingualHyperscript = class {
+  constructor(config = {}) {
+    this.initialized = false;
+    this.bridge = new SemanticGrammarBridge(config);
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    await this.bridge.initialize();
+    this.initialized = true;
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+  async parse(input, lang = "en") {
+    await this.ensureInitialized();
+    return this.bridge.parse(input, lang);
+  }
+  async parseToAST(input, lang = "en") {
+    await this.ensureInitialized();
+    return this.bridge.parseToAST(input, lang);
+  }
+  async parseToASTWithDetails(input, lang = "en") {
+    await this.ensureInitialized();
+    return this.bridge.parseToASTWithDetails(input, lang);
+  }
+  async translate(input, from, to) {
+    await this.ensureInitialized();
+    const result = await this.bridge.transform(input, from, to);
+    return result.output;
+  }
+  async translateWithDetails(input, from, to) {
+    await this.ensureInitialized();
+    return this.bridge.transform(input, from, to);
+  }
+  async render(node, lang) {
+    await this.ensureInitialized();
+    return this.bridge.render(node, lang);
+  }
+  async getAllTranslations(input, from) {
+    await this.ensureInitialized();
+    const all = await this.bridge.getAllTranslations(input, from);
+    const supported = new Set(this.getSupportedLanguages());
+    return Object.fromEntries(Object.entries(all).filter(([lang]) => supported.has(lang)));
+  }
+  getSupportedLanguages() {
+    return [
+      "en",
+      "ja",
+      "ar",
+      "es",
+      "ko",
+      "zh",
+      "tr",
+      "pt",
+      "fr",
+      "de",
+      "id",
+      "qu",
+      "sw"
+    ];
+  }
+  isLanguageSupported(lang) {
+    return this.getSupportedLanguages().includes(lang);
+  }
+  getLanguageInfo(lang) {
+    return LANGUAGE_INFO[lang];
+  }
+  getAllLanguageInfo() {
+    return { ...LANGUAGE_INFO };
+  }
+};
+var LANGUAGE_INFO = {
+  en: { code: "en", name: "English", nativeName: "English", direction: "ltr", wordOrder: "SVO" },
+  ja: { code: "ja", name: "Japanese", nativeName: "\u65E5\u672C\u8A9E", direction: "ltr", wordOrder: "SOV" },
+  ar: { code: "ar", name: "Arabic", nativeName: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629", direction: "rtl", wordOrder: "VSO" },
+  es: { code: "es", name: "Spanish", nativeName: "Espa\xF1ol", direction: "ltr", wordOrder: "SVO" },
+  ko: { code: "ko", name: "Korean", nativeName: "\uD55C\uAD6D\uC5B4", direction: "ltr", wordOrder: "SOV" },
+  zh: { code: "zh", name: "Chinese", nativeName: "\u4E2D\u6587", direction: "ltr", wordOrder: "SVO" },
+  tr: { code: "tr", name: "Turkish", nativeName: "T\xFCrk\xE7e", direction: "ltr", wordOrder: "SOV" },
+  pt: {
+    code: "pt",
+    name: "Portuguese",
+    nativeName: "Portugu\xEAs",
+    direction: "ltr",
+    wordOrder: "SVO"
+  },
+  fr: { code: "fr", name: "French", nativeName: "Fran\xE7ais", direction: "ltr", wordOrder: "SVO" },
+  de: { code: "de", name: "German", nativeName: "Deutsch", direction: "ltr", wordOrder: "SVO" },
+  id: {
+    code: "id",
+    name: "Indonesian",
+    nativeName: "Bahasa Indonesia",
+    direction: "ltr",
+    wordOrder: "SVO"
+  },
+  qu: { code: "qu", name: "Quechua", nativeName: "Runasimi", direction: "ltr", wordOrder: "SOV" },
+  sw: { code: "sw", name: "Swahili", nativeName: "Kiswahili", direction: "ltr", wordOrder: "SVO" }
+};
+var _defaultInstance = null;
+async function getMultilingual() {
+  if (!_defaultInstance) {
+    _defaultInstance = new MultilingualHyperscript();
+    await _defaultInstance.initialize();
+  }
+  return _defaultInstance;
+}
+var multilingual = new MultilingualHyperscript();
+export {
+  MultilingualHyperscript,
+  SemanticGrammarBridge,
+  getDefaultBridge,
+  getMultilingual,
+  multilingual,
+  schemaRoleInferrer,
+  translate
+};
+//# sourceMappingURL=multilingual-VYI3FTN7.js.map