agentlang 0.3.1 → 0.3.2

package/src/runtime/module.ts

@@ -20,9 +20,6 @@ import {
   RbacSpecEntries,
   RbacOpr,
   WorkflowHeader,
-  ScenarioDefinition,
-  DirectiveDefinition,
-  GlossaryEntryDefinition,
 } from '../language/generated/ast.js';
 import {
   Path,
@@ -1596,54 +1593,55 @@ export class Flow extends ModuleEntry {
   }
 }
 
-class Scenario extends ModuleEntry {
-  private def: ScenarioDefinition;
+export class Scenario extends ModuleEntry {
+  def: AgentScenario;
 
-  constructor(def: ScenarioDefinition, moduleName: string) {
-    super(def.name, moduleName);
-    this.def = def;
+  constructor(name: string, moduleName: string, scn: AgentScenario) {
+    super(name, moduleName);
+    this.def = scn;
   }
 
   override toString(): string {
-    const s = this.def.$cstNode?.text;
-    if (s) {
-      return s;
-    }
-    throw new Error(`failed to generate code for scenario ${this.moduleName}/${this.name}`);
+    const obj: any = {
+      user: this.def.user,
+      ai: this.def.ai,
+    };
+    return `scenario ${this.name} ${JSON.stringify(obj)}`;
   }
 }
 
-class Directive extends ModuleEntry {
-  private def: DirectiveDefinition;
+export class Directive extends ModuleEntry {
+  private def: AgentCondition;
 
-  constructor(def: DirectiveDefinition, moduleName: string) {
-    super(def.name, moduleName);
+  constructor(name: string, moduleName: string, def: AgentCondition) {
+    super(name, moduleName);
     this.def = def;
   }
 
   override toString(): string {
-    const s = this.def.$cstNode?.text;
-    if (s) {
-      return s;
-    }
-    throw new Error(`failed to generate code for directive ${this.moduleName}/${this.name}`);
+    const obj: any = {
+      if: this.def.if,
+      then: this.def.then,
+    };
+    return `directive ${this.name} ${JSON.stringify(obj)}`;
   }
 }
 
-class GlossaryEntry extends ModuleEntry {
-  private def: GlossaryEntryDefinition;
+export class GlossaryEntry extends ModuleEntry {
+  private def: AgentGlossaryEntry;
 
-  constructor(def: GlossaryEntryDefinition, moduleName: string) {
-    super(def.name, moduleName);
+  constructor(name: string, moduleName: string, def: AgentGlossaryEntry) {
+    super(name, moduleName);
     this.def = def;
   }
 
   override toString(): string {
-    const s = this.def.$cstNode?.text;
-    if (s) {
-      return s;
-    }
-    throw new Error(`failed to generate code for glossaryEntry ${this.moduleName}/${this.name}`);
+    const obj: any = {
+      name: this.def.name,
+      meaning: this.def.meaning,
+      synonyms: this.def.synonyms,
+    };
+    return `glossaryEntry ${this.name} ${JSON.stringify(obj)}`;
   }
 }
 
@@ -1802,66 +1800,119 @@ export class Module {
     return undefined;
   }
 
-  addScenario(scn: ScenarioDefinition): Scenario {
-    const entry = new Scenario(scn, this.name);
+  getAllDecisions(): Decision[] {
+    return this.entries.filter((e: ModuleEntry) => {
+      return e instanceof Decision;
+    });
+  }
+
+  removeDecision(name: string): boolean {
+    for (let i = 0; i < this.entries.length; ++i) {
+      const entry = this.entries[i];
+      if (entry.name === name && entry instanceof Decision) {
+        this.entries.splice(i, 1);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  addScenario(name: string, scn: AgentScenario): Scenario {
+    const entry = new Scenario(name, this.name, scn);
     this.addEntry(entry);
     return entry;
   }
 
+  getScenario(name: string): Scenario | undefined {
+    if (this.hasEntry(name)) {
+      const e = this.getEntry(name);
+      if (e instanceof Scenario) {
+        return e as Scenario;
+      }
+    }
+    return undefined;
+  }
+
+  getAllScenarios(): Scenario[] {
+    return this.entries.filter((e: ModuleEntry) => {
+      return e instanceof Scenario;
+    });
+  }
+
   removeScenario(name: string): Module {
-    let idx = -1;
     for (let i = 0; i < this.entries.length; ++i) {
       const entry = this.entries[i];
       if (entry.name === name && entry instanceof Scenario) {
-        idx = i;
+        this.entries.splice(i, 1);
         break;
       }
     }
-    if (idx >= 0) {
-      this.entries.splice(idx, 1);
-    }
     return this;
   }
 
-  addDirective(dd: DirectiveDefinition): Directive {
-    const entry = new Directive(dd, this.name);
+  addDirective(name: string, cond: AgentCondition): Directive {
+    const entry = new Directive(name, this.name, cond);
     this.addEntry(entry);
     return entry;
   }
 
+  getDirective(name: string): Directive | undefined {
+    if (this.hasEntry(name)) {
+      const e = this.getEntry(name);
+      if (e instanceof Directive) {
+        return e as Directive;
+      }
+    }
+    return undefined;
+  }
+
+  getAllDirectives(): Directive[] {
+    return this.entries.filter((e: ModuleEntry) => {
+      return e instanceof Directive;
+    });
+  }
+
   removeDirective(name: string): Module {
-    let idx = -1;
     for (let i = 0; i < this.entries.length; ++i) {
       const entry = this.entries[i];
       if (entry.name === name && entry instanceof Directive) {
-        idx = i;
+        this.entries.splice(i, 1);
         break;
       }
     }
-    if (idx >= 0) {
-      this.entries.splice(idx, 1);
-    }
     return this;
   }
 
-  addGlossaryEntry(ge: GlossaryEntryDefinition): GlossaryEntry {
-    const entry = new GlossaryEntry(ge, this.name);
+  addGlossaryEntry(name: string, ge: AgentGlossaryEntry): GlossaryEntry {
+    const entry = new GlossaryEntry(name, this.name, ge);
     this.addEntry(entry);
     return entry;
   }
 
+  getGlossaryEntry(name: string): GlossaryEntry | undefined {
+    if (this.hasEntry(name)) {
+      const e = this.getEntry(name);
+      if (e instanceof GlossaryEntry) {
+        return e as GlossaryEntry;
+      }
+    }
+    return undefined;
+  }
+
+  getAllGlossaryEntries(): GlossaryEntry[] {
+    return this.entries.filter((e: ModuleEntry) => {
+      return e instanceof GlossaryEntry;
+    });
+  }
+
   removeGlossaryEntry(name: string): Module {
-    let idx = -1;
     for (let i = 0; i < this.entries.length; ++i) {
       const entry = this.entries[i];
       if (entry.name === name && entry instanceof GlossaryEntry) {
-        idx = i;
+        this.entries.splice(i, 1);
         break;
       }
     }
-    if (idx >= 0) {
-      this.entries.splice(idx, 1);
-    }
     return this;
   }
 
@@ -3443,6 +3494,10 @@ export function defineAgentEvent(moduleName: string, agentName: string, instruct
     So make sure to pass all relevant information in the 'message' attribute of this event.`
     );
   }
+  const agent = module.getAgent(agentName);
+  if (agent && agent.isPublic()) {
+    event.setPublic(true);
+  }
   module.addEntry(event);
 }
 

package/src/runtime/modules/ai.ts

@@ -229,7 +229,7 @@ export class AgentInstance {
         '\nUse the following guidelines to take more accurate decisions in relevant scenarios.\n'
       );
       conds.forEach((ac: AgentCondition) => {
-        ss.push(`if ${ac.cond}, then ${ac.then}`);
+        ss.push(`if ${ac.if}, then ${ac.then}`);
       });
       return `${ss.join('\n')}\n`;
     }

package/out/runtime/modules/files.d.ts

@@ -1,18 +0,0 @@
-import { Result, Environment } from '../interpreter.js';
-import { ActiveSessionInfo } from '../auth/defs.js';
-export declare const CoreFilesModuleName: string;
-declare const _default: string;
-export default _default;
-export declare function createFileRecord(fileInfo: {
-    filename: string;
-    originalName: string;
-    mimetype: string;
-    size: number;
-    path: string;
-    uploadedBy?: string;
-}, sessionInfo?: ActiveSessionInfo, callback?: (result: Result) => void, env?: Environment): Promise<Result>;
-export declare function findFileByFilename(filename: string, sessionInfo?: ActiveSessionInfo, callback?: (result: Result) => void, env?: Environment): Promise<Result>;
-export declare function deleteFileRecord(filename: string, sessionInfo?: ActiveSessionInfo, callback?: (result: Result) => void, env?: Environment): Promise<Result>;
-export declare function listAllFiles(sessionInfo?: ActiveSessionInfo, callback?: (result: Result) => void, env?: Environment): Promise<Result>;
-export declare function listUserFiles(userId: string, sessionInfo?: ActiveSessionInfo, callback?: (result: Result) => void, env?: Environment): Promise<Result>;
-//# sourceMappingURL=files.d.ts.map

package/out/runtime/modules/files.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../../src/runtime/modules/files.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,WAAW,EAAY,MAAM,mBAAmB,CAAC;AAIlE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEpD,eAAO,MAAM,mBAAmB,QAA8B,CAAC;;AAE/D,wBA2DE;AAEF,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE;IACR,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,EACD,WAAW,CAAC,EAAE,iBAAiB,EAC/B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EACnC,GAAG,CAAC,EAAE,WAAW,GAChB,OAAO,CAAC,MAAM,CAAC,CAqBjB;AAED,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,iBAAiB,EAC/B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EACnC,GAAG,CAAC,EAAE,WAAW,GAChB,OAAO,CAAC,MAAM,CAAC,CAcjB;AAED,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,iBAAiB,EAC/B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EACnC,GAAG,CAAC,EAAE,WAAW,GAChB,OAAO,CAAC,MAAM,CAAC,CAcjB;AAED,wBAAsB,YAAY,CAChC,WAAW,CAAC,EAAE,iBAAiB,EAC/B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EACnC,GAAG,CAAC,EAAE,WAAW,GAChB,OAAO,CAAC,MAAM,CAAC,CAYjB;AAED,wBAAsB,aAAa,CACjC,MAAM,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,iBAAiB,EAC/B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EACnC,GAAG,CAAC,EAAE,WAAW,GAChB,OAAO,CAAC,MAAM,CAAC,CAcjB"}

package/out/runtime/modules/files.js

@@ -1,116 +0,0 @@
-import { evaluate } from '../interpreter.js';
-import { makeCoreModuleName } from '../util.js';
-import { makeInstance, objectAsInstanceAttributes } from '../module.js';
-import crypto from 'crypto';
-export const CoreFilesModuleName = makeCoreModuleName('files');
-export default `module ${CoreFilesModuleName}
-
-entity File {
-    id String @id,
-    filename String @unique @indexed,
-    originalName String @optional,
-    mimetype String @default("application/octet-stream"),
-    size Int @optional,
-    uploadedBy String @optional,
-    uploadedAt DateTime @default(now()),
-    path String @optional,
-    @rbac [(roles: [*], allow: [create])
-           (allow: [read, delete], where: auth.user = this.uploadedBy)]
-}
-
-workflow CreateFile {
-  {File {id CreateFile.id,
-         filename CreateFile.filename,
-         originalName CreateFile.originalName,
-         mimetype CreateFile.mimetype,
-         size CreateFile.size,
-         uploadedBy CreateFile.uploadedBy,
-         uploadedAt CreateFile.uploadedAt,
-         path CreateFile.path},
-  @upsert}
-}
-
-workflow FindFile {
-  {File {id? FindFile.id}} @as [file];
-  file
-}
-
-workflow FindFileByFilename {
-  {File {filename? FindFileByFilename.filename}} @as [file];
-  file
-}
-
-workflow ListFiles {
-  {File? {}}
-}
-
-workflow ListUserFiles {
-  {File {uploadedBy? ListUserFiles.userId}}
-}
-
-workflow DeleteFile {
-  delete {File {id? DeleteFile.id}}
-}
-
-workflow DeleteFileByFilename {
-  delete {File {filename? DeleteFileByFilename.filename}}
-}
-
-workflow UpdateFile {
-  {File {id? UpdateFile.id,
-         originalName UpdateFile.originalName,
-         mimetype UpdateFile.mimetype,
-         size UpdateFile.size}}
-}
-`;
-export async function createFileRecord(fileInfo, sessionInfo, callback, env) {
-    let inst = makeInstance(CoreFilesModuleName, 'CreateFile', objectAsInstanceAttributes({
-        id: crypto.randomUUID(),
-        filename: fileInfo.filename,
-        originalName: fileInfo.originalName,
-        mimetype: fileInfo.mimetype,
-        size: fileInfo.size,
-        path: fileInfo.path,
-        uploadedBy: fileInfo.uploadedBy || '',
-        uploadedAt: new Date().toISOString(),
-    }));
-    if (sessionInfo) {
-        inst = inst.setAuthContext(sessionInfo);
-    }
-    return await evaluate(inst, callback, env);
-}
-export async function findFileByFilename(filename, sessionInfo, callback, env) {
-    let inst = makeInstance(CoreFilesModuleName, 'FindFileByFilename', objectAsInstanceAttributes({
-        filename: filename,
-    }));
-    if (sessionInfo) {
-        inst = inst.setAuthContext(sessionInfo);
-    }
-    return await evaluate(inst, callback, env);
-}
-export async function deleteFileRecord(filename, sessionInfo, callback, env) {
-    let inst = makeInstance(CoreFilesModuleName, 'DeleteFileByFilename', objectAsInstanceAttributes({
-        filename: filename,
-    }));
-    if (sessionInfo) {
-        inst = inst.setAuthContext(sessionInfo);
-    }
-    return await evaluate(inst, callback, env);
-}
-export async function listAllFiles(sessionInfo, callback, env) {
-    let inst = makeInstance(CoreFilesModuleName, 'ListFiles', objectAsInstanceAttributes({}));
-    if (sessionInfo) {
-        inst = inst.setAuthContext(sessionInfo);
-    }
-    return await evaluate(inst, callback, env);
-}
-export async function listUserFiles(userId, sessionInfo, callback, env) {
-    let inst = makeInstance(CoreFilesModuleName, 'ListUserFiles', objectAsInstanceAttributes({
-        userId: userId,
-    }));
-    if (sessionInfo) {
-        inst = inst.setAuthContext(sessionInfo);
-    }
-    return await evaluate(inst, callback, env);
-}
-//# sourceMappingURL=files.js.map

package/out/runtime/modules/files.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"files.js","sourceRoot":"","sources":["../../../src/runtime/modules/files.ts"],"names":[],"mappings":"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"}

package/out/setupClassic.d.ts

@@ -1,98 +0,0 @@
-export declare const setupConfigClassic: () => {
-    $type: string;
-    editorAppConfig: {
-        codeResources: {
-            modified: {
-                uri: string;
-                text: string;
-            };
-        };
-        useDiffEditor: boolean;
-        languageDef: {
-            languageExtensionConfig: {
-                id: string;
-            };
-            monarchLanguage: {
-                keywords: string[];
-                operators: string[];
-                symbols: RegExp;
-                tokenizer: {
-                    initial: ({
-                        regex: RegExp;
-                        action: {
-                            cases: {
-                                '@keywords': {
-                                    token: string;
-                                };
-                                '@default': {
-                                    token: string;
-                                };
-                                '@operators'?: undefined;
-                            };
-                            token?: undefined;
-                        };
-                        include?: undefined;
-                    } | {
-                        regex: RegExp;
-                        action: {
-                            token: string;
-                            cases?: undefined;
-                        };
-                        include?: undefined;
-                    } | {
-                        include: string;
-                        regex?: undefined;
-                        action?: undefined;
-                    } | {
-                        regex: RegExp;
-                        action: {
-                            cases: {
-                                '@operators': {
-                                    token: string;
-                                };
-                                '@default': {
-                                    token: string;
-                                };
-                                '@keywords'?: undefined;
-                            };
-                            token?: undefined;
-                        };
-                        include?: undefined;
-                    })[];
-                    whitespace: ({
-                        regex: RegExp;
-                        action: {
-                            token: string;
-                            next?: undefined;
-                        };
-                    } | {
-                        regex: RegExp;
-                        action: {
-                            token: string;
-                            next: string;
-                        };
-                    })[];
-                    comment: ({
-                        regex: RegExp;
-                        action: {
-                            token: string;
-                            next?: undefined;
-                        };
-                    } | {
-                        regex: RegExp;
-                        action: {
-                            token: string;
-                            next: string;
-                        };
-                    })[];
-                };
-            };
-        };
-        editorOptions: {
-            'semanticHighlighting.enabled': boolean;
-            theme: string;
-        };
-    };
-};
-export declare const executeClassic: (htmlElement: HTMLElement) => Promise<void>;
-//# sourceMappingURL=setupClassic.d.ts.map

package/out/setupClassic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setupClassic.d.ts","sourceRoot":"","sources":["../src/setupClassic.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqB9B,CAAC;AAEF,eAAO,MAAM,cAAc,GAAU,aAAa,WAAW,kBAgB5D,CAAC"}

package/out/setupClassic.js

@@ -1,38 +0,0 @@
-import { MonacoEditorLanguageClientWrapper } from 'monaco-editor-wrapper';
-import monarchSyntax from './syntaxes/agentlang.monarch.js';
-export const setupConfigClassic = () => {
-    return {
-        $type: 'classic',
-        editorAppConfig: {
-            codeResources: {
-                modified: {
-                    uri: '/workspace/example.al',
-                    text: `// Agentlang is running in the web!`,
-                },
-            },
-            useDiffEditor: false,
-            languageDef: {
-                languageExtensionConfig: { id: 'agentlang' },
-                monarchLanguage: monarchSyntax,
-            },
-            editorOptions: {
-                'semanticHighlighting.enabled': true,
-                theme: 'vs-dark',
-            },
-        },
-    };
-};
-export const executeClassic = async (htmlElement) => {
-    try {
-        const config = setupConfigClassic();
-        const wrapper = new MonacoEditorLanguageClientWrapper();
-        // Add the HTML container to the config
-        const wrapperConfig = Object.assign(Object.assign({}, config), { htmlContainer: htmlElement });
-        // Initialize and start the wrapper
-        await wrapper.initAndStart(wrapperConfig);
-    }
-    catch (error) {
-        console.error('Error initializing monaco editor:', error);
-    }
-};
-//# sourceMappingURL=setupClassic.js.map

package/out/setupClassic.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"setupClassic.js","sourceRoot":"","sources":["../src/setupClassic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iCAAiC,EAAsB,MAAM,uBAAuB,CAAC;AAC9F,OAAO,aAAa,MAAM,iCAAiC,CAAC;AAE5D,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,EAAE;IACrC,OAAO;QACL,KAAK,EAAE,SAAS;QAChB,eAAe,EAAE;YACf,aAAa,EAAE;gBACb,QAAQ,EAAE;oBACR,GAAG,EAAE,uBAAuB;oBAC5B,IAAI,EAAE,qCAAqC;iBAC5C;aACF;YACD,aAAa,EAAE,KAAK;YACpB,WAAW,EAAE;gBACX,uBAAuB,EAAE,EAAE,EAAE,EAAE,WAAW,EAAE;gBAC5C,eAAe,EAAE,aAAa;aAC/B;YACD,aAAa,EAAE;gBACb,8BAA8B,EAAE,IAAI;gBACpC,KAAK,EAAE,SAAS;aACjB;SACF;KACF,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG,KAAK,EAAE,WAAwB,EAAE,EAAE;IAC/D,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,kBAAkB,EAAE,CAAC;QACpC,MAAM,OAAO,GAAG,IAAI,iCAAiC,EAAE,CAAC;QAExD,uCAAuC;QACvC,MAAM,aAAa,GAAG,gCACjB,MAAM,KACT,aAAa,EAAE,WAAW,GACV,CAAC;QAEnB,mCAAmC;QACnC,MAAM,OAAO,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IAC5C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,mCAAmC,EAAE,KAAK,CAAC,CAAC;IAC5D,CAAC;AACH,CAAC,CAAC"}

package/out/setupCommon.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=setupCommon.d.ts.map

package/out/setupCommon.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setupCommon.d.ts","sourceRoot":"","sources":["../src/setupCommon.ts"],"names":[],"mappings":""}

package/out/setupCommon.js

@@ -1,33 +0,0 @@
-// This file is kept for reference but is not used directly anymore
-// The monaco-editor-wrapper API has changed significantly in v6+
-export {};
-// These functions are kept for reference but not used directly anymore
-/*
-export const defineUserServices = () => {
-  return {
-    userServices: {
-      // This API has changed in the latest version
-    },
-    debugLogging: true,
-  };
-};
-
-export const configureMonacoWorkers = () => {
-  // This function is kept for compatibility, but implementation has changed
-  // Use configureDefaultWorkerFactory from monaco-editor-wrapper/workers/workerLoaders in newer code
-};
-
-export const configureWorker = () => {
-  // vite does not extract the worker properly if it is URL is a variable
-  const lsWorker = new Worker(new URL('./language/main-browser', import.meta.url), {
-    type: 'module',
-    name: 'Agentlang Language Server',
-  });
-
-  return {
-    type: 'WorkerDirect',
-    worker: lsWorker,
-  };
-};
-*/
-//# sourceMappingURL=setupCommon.js.map

package/out/setupCommon.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"setupCommon.js","sourceRoot":"","sources":["../src/setupCommon.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,iEAAiE;;AAEjE,uEAAuE;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BE"}

package/out/setupExtended.d.ts

@@ -1,40 +0,0 @@
-export declare const setupConfigExtended: () => {
-    $type: string;
-    editorAppConfig: {
-        codeResources: {
-            modified: {
-                uri: string;
-                text: string;
-            };
-        };
-        useDiffEditor: boolean;
-        extensions: {
-            config: {
-                name: string;
-                publisher: string;
-                version: string;
-                engines: {
-                    vscode: string;
-                };
-                contributes: {
-                    languages: {
-                        id: string;
-                        extensions: string[];
-                        configuration: string;
-                    }[];
-                    grammars: {
-                        language: string;
-                        scopeName: string;
-                        path: string;
-                    }[];
-                };
-            };
-            filesOrContents: Map<any, any>;
-        }[];
-        userConfiguration: {
-            json: string;
-        };
-    };
-};
-export declare const executeExtended: (htmlElement: HTMLElement) => Promise<void>;
-//# sourceMappingURL=setupExtended.d.ts.map

package/out/setupExtended.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setupExtended.d.ts","sourceRoot":"","sources":["../src/setupExtended.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0D/B,CAAC;AAEF,eAAO,MAAM,eAAe,GAAU,aAAa,WAAW,kBAgB7D,CAAC"}