agentlang 0.9.5 → 0.9.7

package/src/runtime/resolvers/sqldb/impl.ts

@@ -25,32 +25,96 @@ import {
 import { JoinInfo, Resolver, WhereClause } from '../interface.js';
 import { asColumnReference, asTableReference } from './dbutil.js';
 import {
-  getMany,
-  insertRow,
-  updateRow,
-  getAllConnected,
-  startDbTransaction,
+  addRowForFullTextSearch,
   commitDbTransaction,
-  rollbackDbTransaction,
-  hardDeleteRow,
   DbContext,
-  insertBetweenRow,
-  addRowForFullTextSearch,
-  vectorStoreSearch,
-  vectorStoreSearchEntryExists,
   deleteFullTextSearchEntry,
+  getAllConnected,
+  getMany,
+  getManyByJoin,
+  hardDeleteRow,
+  insertBetweenRow,
+  insertRow,
+  isVectorStoreSupported,
   JoinClause,
   JoinOn,
   makeJoinOn,
-  getManyByJoin,
   QuerySpec,
+  rollbackDbTransaction,
+  startDbTransaction,
+  updateRow,
+  vectorStoreSearch,
+  vectorStoreSearchEntryExists,
 } from './database.js';
 import { AggregateFunctionCall, Environment } from '../../interpreter.js';
-import { OpenAIEmbeddings } from '@langchain/openai';
-import { Embeddings } from '@langchain/core/embeddings';
-import { DeletedFlagAttributeName, ParentAttributeName, PathAttributeName } from '../../defs.js';
+import {
+  DeletedFlagAttributeName,
+  ParentAttributeName,
+  PathAttributeName,
+  TenantAttributeName,
+} from '../../defs.js';
 import { logger } from '../../logger.js';
 import { JoinSpec } from '../../../language/generated/ast.js';
+import { EmbeddingProvider, EmbeddingProviderConfig } from '../../embeddings/provider.js';
+import { embeddingProvider } from '../../embeddings/registry.js';
+import { TextChunker } from '../../embeddings/chunker.js';
+
+interface EmbeddingServiceConfig extends EmbeddingProviderConfig {
+  provider?: string;
+}
+
+export class EmbeddingService {
+  private provider: EmbeddingProvider;
+  private config: EmbeddingServiceConfig;
+  private chunker: TextChunker;
+
+  constructor(config?: EmbeddingServiceConfig) {
+    this.config = config || {};
+    const providerClass = embeddingProvider(this.config.provider || 'openai');
+    this.provider = new providerClass(this.config);
+    this.chunker = new TextChunker(this.getChunkSize(), this.getChunkOverlap());
+  }
+
+  private getChunkSize(): number {
+    return this.config.chunkSize || 1000;
+  }
+
+  private getChunkOverlap(): number {
+    return this.config.chunkOverlap || 200;
+  }
+
+  async embedText(text: string): Promise<number[]> {
+    const chunks = this.chunker.splitText(text);
+
+    if (chunks.length === 1) {
+      return await this.provider.embedText(chunks[0]);
+    }
+
+    const chunkEmbeddings = await Promise.all(
+      chunks.map((chunk: string) => this.provider.embedText(chunk))
+    );
+
+    return this.averageEmbeddings(chunkEmbeddings);
+  }
+
+  async embedQuery(query: string): Promise<number[]> {
+    return await this.provider.embedText(query);
+  }
+
+  private averageEmbeddings(embeddings: number[][]): number[] {
+    if (embeddings.length === 0) return [];
+    const dimension = embeddings[0].length;
+    const averaged = new Array(dimension).fill(0);
+
+    for (const embedding of embeddings) {
+      for (let i = 0; i < dimension; i++) {
+        averaged[i] += embedding[i];
+      }
+    }
+
+    return averaged.map((v: number) => v / embeddings.length);
+  }
+}
 
 function maybeFindIdAttributeName(inst: Instance): string | undefined {
   const attrEntry: AttributeEntry | undefined = findIdAttribute(inst);
@@ -62,12 +126,18 @@ function maybeFindIdAttributeName(inst: Instance): string | undefined {
 
 export class SqlDbResolver extends Resolver {
   private txnId: string | undefined;
-  private embeddings: Embeddings;
+  private _embeddingService: EmbeddingService | undefined;
 
   constructor(name: string) {
     super();
     this.name = name;
-    this.embeddings = new OpenAIEmbeddings();
+  }
+
+  private get embeddingService(): EmbeddingService {
+    if (!this._embeddingService) {
+      this._embeddingService = new EmbeddingService();
+    }
+    return this._embeddingService;
   }
 
   public override getName(): string {
@@ -93,6 +163,45 @@ export class SqlDbResolver extends Resolver {
     return entryName;
   }
 
+  private extractTextForEmbedding(rowObj: object, searchAttributes: string[] | undefined): string {
+    const obj = rowObj as Record<string, any>;
+    const ftsAttrs =
+      !searchAttributes || searchAttributes.length === 0 || searchAttributes[0] === '*'
+        ? Object.keys(obj).filter(k => this.shouldIncludeAttribute(k))
+        : searchAttributes;
+
+    const parts: string[] = [];
+    for (const attr of ftsAttrs) {
+      const value = obj[attr];
+      if (value !== undefined && value !== null) {
+        parts.push(this.valueToString(value));
+      }
+    }
+
+    return parts.join(' ');
+  }
+
+  private shouldIncludeAttribute(key: string): boolean {
+    const excludedAttrs = [
+      PathAttributeName,
+      DeletedFlagAttributeName,
+      TenantAttributeName,
+      '__tenant__',
+      '__is_deleted__',
+    ];
+    return !excludedAttrs.includes(key);
+  }
+
+  private valueToString(value: any): string {
+    if (Array.isArray(value)) {
+      return value.join(' ');
+    }
+    if (typeof value === 'object' && value !== null) {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  }
+
   private async insertInstance(inst: Instance, orUpdate = false): Promise<Instance> {
     const ctx = this.getDbContext(inst.getFqName());
     if (isBetweenRelationship(inst.name, inst.moduleName)) {
@@ -107,35 +216,43 @@ export class SqlDbResolver extends Resolver {
         ctx.activeEnv.isInDeleteMode()
       );
       return inst;
-    } else {
-      const idAttrName: string | undefined = maybeFindIdAttributeName(inst);
-      ensureOneToOneAttributes(inst);
-      const attrs: InstanceAttributes = inst.attributes;
-      const idAttrVal: any = idAttrName ? attrs.get(idAttrName) : crypto.randomUUID();
-      if (idAttrVal !== undefined) {
-        const pp: string | undefined = attrs.get(PathAttributeName);
-        const n: string = `${inst.moduleName}/${inst.name}`;
-        let p: string = '';
-        if (pp !== undefined) p = `${pp}/${escapeFqName(n)}/${idAttrVal}`;
-        else p = `${n.replace('/', '$')}/${idAttrVal}`;
-        attrs.set(PathAttributeName, p);
-      }
-      const n: string = asTableReference(inst.moduleName, inst.name);
-      const rowObj: object = inst.attributesWithStringifiedObjects();
-      await insertRow(n, rowObj, ctx, orUpdate);
-      if (inst.record.getFullTextSearchAttributes()) {
-        const path = attrs.get(PathAttributeName);
-        try {
-          if (!(await vectorStoreSearchEntryExists(n, path, ctx))) {
-            const res = await this.embeddings.embedQuery(JSON.stringify(rowObj));
-            await addRowForFullTextSearch(n, path, res, ctx);
-          }
-        } catch (reason: any) {
-          logger.warn(`Full text indexing failed for ${path} - ${reason}`);
+    }
+    const idAttrName: string | undefined = maybeFindIdAttributeName(inst);
+    ensureOneToOneAttributes(inst);
+    const attrs: InstanceAttributes = inst.attributes;
+    const idAttrVal: any = idAttrName ? attrs.get(idAttrName) : crypto.randomUUID();
+    if (idAttrVal !== undefined) {
+      const pp: string | undefined = attrs.get(PathAttributeName);
+      const n: string = `${inst.moduleName}/${inst.name}`;
+      let p: string = '';
+      if (pp !== undefined) p = `${pp}/${escapeFqName(n)}/${idAttrVal}`;
+      else p = `${n.replace('/', '$')}/${idAttrVal}`;
+      attrs.set(PathAttributeName, p);
+    }
+    const n: string = asTableReference(inst.moduleName, inst.name);
+    const rowObj: object = inst.attributesWithStringifiedObjects();
+    await insertRow(n, rowObj, ctx, orUpdate);
+    if (inst.record.getEmbeddingConfig() || inst.record.getFullTextSearchAttributes()) {
+      const path = attrs.get(PathAttributeName);
+      try {
+        if (
+          (await isVectorStoreSupported()) &&
+          !(await vectorStoreSearchEntryExists(n, path, ctx))
+        ) {
+          const ftsAttrs = inst.record.getFullTextSearchAttributes() || ['*'];
+          const textToEmbed = this.extractTextForEmbedding(rowObj, ftsAttrs);
+          const embeddingConfig = inst.record.getEmbeddingConfig();
+          const embeddingService = embeddingConfig
+            ? new EmbeddingService(embeddingConfig)
+            : this.embeddingService;
+          const res = await embeddingService.embedText(textToEmbed);
+          await addRowForFullTextSearch(n, path, res, ctx);
         }
+      } catch (reason: any) {
+        logger.warn(`Full text indexing failed for ${path} - ${reason}`);
       }
-      return inst;
     }
+    return inst;
   }
 
   public override async createInstance(inst: Instance): Promise<Instance> {
@@ -211,9 +328,42 @@ export class SqlDbResolver extends Resolver {
       : undefined;
     const orderByDesc = inst.orderByDesc ? 'DESC' : 'ASC';
     const aggregates = SqlDbResolver.normalizedAggregates(inst, tableName);
+
+    let vectorResult: Instance[] | undefined;
+    const embeddingConfig = inst.record.getEmbeddingConfig();
+    const ftsAttrs = inst.record.getFullTextSearchAttributes();
+    if (
+      (await isVectorStoreSupported()) &&
+      embeddingConfig &&
+      qattrs &&
+      (ftsAttrs || Object.keys(qattrs).some(k => k.endsWith('?')))
+    ) {
+      const vectorSearchAttr = Object.keys(qattrs).find(k => k.endsWith('?'));
+      if (vectorSearchAttr) {
+        const queryVal = qvals[vectorSearchAttr];
+        const searchString = this.valueToString(queryVal);
+        const embeddingService = new EmbeddingService(embeddingConfig);
+        const queryVec = await embeddingService.embedQuery(searchString);
+        const rslt: any = await vectorStoreSearch(tableName, queryVec, 10, ctx);
+        if (rslt instanceof Array) {
+          vectorResult = new Array<Instance>();
+          rslt.forEach((r: any) => {
+            const attrs: InstanceAttributes = maybeNormalizeAttributeNames(
+              tableName,
+              new Map(Object.entries(r))
+            );
+            attrs.delete(DeletedFlagAttributeName);
+            vectorResult!.push(Instance.newWithAttributes(inst, attrs));
+          });
+        }
+        delete qattrs[vectorSearchAttr];
+        delete qvals[vectorSearchAttr];
+      }
+    }
+
     const qspec: QuerySpec = {
-      queryObj: qattrs,
-      queryVals: qvals,
+      queryObj: Object.keys(qattrs || {}).length > 0 ? qattrs : undefined,
+      queryVals: Object.keys(qvals || {}).length > 0 ? qvals : undefined,
       distinct,
       groupBy,
       orderBy,
@@ -224,20 +374,47 @@ export class SqlDbResolver extends Resolver {
       whereClauses: undefined,
     };
     const readOnlyAttrs = inst.record.getWriteOnlyAttributes();
-    const rslt: any = await getMany(tableName, qspec, ctx);
+    const rslt: any =
+      vectorResult !== undefined && qspec.queryObj === undefined
+        ? vectorResult
+        : await getMany(tableName, qspec, ctx);
     if (rslt instanceof Array) {
-      result = new Array<Instance>();
-      rslt.forEach((r: object) => {
-        const attrs: InstanceAttributes = maybeNormalizeAttributeNames(
-          tableName,
-          new Map(Object.entries(r))
-        );
-        attrs.delete(DeletedFlagAttributeName);
-        readOnlyAttrs?.forEach((n: string) => {
-          attrs.delete(n);
+      if (vectorResult !== undefined && qspec.queryObj !== undefined) {
+        // Merge results if both vector and standard queries were performed
+        const vectorPaths = new Set(vectorResult.map(i => i.lookup(PathAttributeName)));
+        result = new Array<Instance>();
+        rslt.forEach((r: any) => {
+          const attrs: InstanceAttributes = maybeNormalizeAttributeNames(
+            tableName,
+            new Map(Object.entries(r))
+          );
+          if (vectorPaths.has(attrs.get(PathAttributeName))) {
+            attrs.delete(DeletedFlagAttributeName);
+            readOnlyAttrs?.forEach((n: string) => {
+              attrs.delete(n);
+            });
+            result.push(Instance.newWithAttributes(inst, attrs));
+          }
         });
-        result.push(Instance.newWithAttributes(inst, attrs));
-      });
+      } else {
+        result =
+          vectorResult !== undefined && qspec.queryObj === undefined
+            ? vectorResult
+            : new Array<Instance>();
+        if (vectorResult === undefined || qspec.queryObj !== undefined) {
+          rslt.forEach((r: any) => {
+            const attrs: InstanceAttributes = maybeNormalizeAttributeNames(
+              tableName,
+              new Map(Object.entries(r))
+            );
+            attrs.delete(DeletedFlagAttributeName);
+            readOnlyAttrs?.forEach((n: string) => {
+              attrs.delete(n);
+            });
+            result.push(Instance.newWithAttributes(inst, attrs));
+          });
+        }
+      }
     }
     return result;
   }
@@ -553,13 +730,13 @@ export class SqlDbResolver extends Resolver {
     entryName: string,
     moduleName: string,
     query: string,
-    options?: Map<string, any>
+    options?: any
   ): Promise<any> {
-    const queryVec = await this.embeddings.embedQuery(query);
+    const queryVec = await this.embeddingService.embedQuery(query);
     const ctx = this.getDbContext(makeFqName(moduleName, entryName));
     let limit = 5;
-    if (options && options.has('limit')) {
-      limit = options.get('limit') as number;
+    if (options && options.limit) {
+      limit = options.limit as number;
     }
     return await vectorStoreSearch(asTableReference(moduleName, entryName), queryVec, limit, ctx);
   }

package/src/runtime/state.ts

@@ -200,4 +200,8 @@ export class TtlCache<T> {
   delete(key: string) {
     this.store.delete(key);
   }
+
+  clear() {
+    this.store.clear();
+  }
 }

package/src/syntaxes/agentlang.monarch.ts

@@ -1,7 +1,7 @@
 // Monarch syntax highlighting for the agentlang language.
 export default {
     keywords: [
-        '@actions','@after','@as','@asc','@async','@before','@catch','@desc','@distinct','@enum','@expr','@from','@full_join','@groupBy','@inner_join','@into','@join','@left_join','@meta','@oneof','@orderBy','@public','@rbac','@ref','@right_join','@then','@upsert','@where','@with_unique','agent','agentlang/retry','allow','and','attempts','await','backoff','between','case','commitTransaction','contains','create','decision','delete','directive','else','entity','error','event','extends','false','flow','for','glossaryEntry','if','import','in','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','return','roles','rollbackTransaction','scenario','startTransaction','subscribe','throw','true','update','upsert','where','workflow'
+        '@actions','@after','@as','@asc','@async','@before','@catch','@desc','@distinct','@enum','@expr','@from','@full_join','@groupBy','@inner_join','@into','@join','@left_join','@meta','@oneof','@orderBy','@public','@rbac','@ref','@right_join','@then','@upsert','@where','@withRole','@with_unique','agent','agentlang/retry','allow','and','attempts','await','backoff','between','case','commitTransaction','contains','create','decision','delete','directive','else','entity','error','eval','event','extends','false','flow','for','glossaryEntry','if','import','in','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','return','roles','rollbackTransaction','scenario','startTransaction','subscribe','throw','true','update','upsert','where','workflow'
     ],
     operators: [
         '!=','*','+',',','-','-->','.','/',':',';','<','<=','<>','=','==','>','>=','?','@'

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"}