agentlang 0.9.4 → 0.9.5

package/out/runtime/state.d.ts

@@ -4,122 +4,48 @@ export declare const ConfigSchema: z.ZodObject<{
         port: z.ZodNumber;
         host: z.ZodOptional<z.ZodString>;
         httpFileHandling: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        port: number;
-        httpFileHandling: boolean;
-        host?: string | undefined;
-    }, {
-        port: number;
-        host?: string | undefined;
-        httpFileHandling?: boolean | undefined;
-    }>>;
-    store: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    }, z.core.$strip>>;
+    store: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"postgres">;
         host: z.ZodDefault<z.ZodString>;
         username: z.ZodDefault<z.ZodString>;
         password: z.ZodDefault<z.ZodString>;
         dbname: z.ZodDefault<z.ZodString>;
         port: z.ZodDefault<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        type: "postgres";
-        port: number;
-        host: string;
-        username: string;
-        password: string;
-        dbname: string;
-    }, {
-        type: "postgres";
-        port?: number | undefined;
-        host?: string | undefined;
-        username?: string | undefined;
-        password?: string | undefined;
-        dbname?: string | undefined;
-    }>, z.ZodObject<{
+    }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"mysql">;
         host: z.ZodDefault<z.ZodString>;
         username: z.ZodDefault<z.ZodString>;
         password: z.ZodDefault<z.ZodString>;
         dbname: z.ZodDefault<z.ZodString>;
         port: z.ZodDefault<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        type: "mysql";
-        port: number;
-        host: string;
-        username: string;
-        password: string;
-        dbname: string;
-    }, {
-        type: "mysql";
-        port?: number | undefined;
-        host?: string | undefined;
-        username?: string | undefined;
-        password?: string | undefined;
-        dbname?: string | undefined;
-    }>, z.ZodObject<{
+    }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"sqlite">;
         dbname: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        type: "sqlite";
-        dbname?: string | undefined;
-    }, {
-        type: "sqlite";
-        dbname?: string | undefined;
-    }>]>>;
+    }, z.core.$strip>], "type">>;
     integrations: z.ZodOptional<z.ZodObject<{
         host: z.ZodString;
         username: z.ZodOptional<z.ZodString>;
         password: z.ZodOptional<z.ZodString>;
         connections: z.ZodRecord<z.ZodString, z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        host: string;
-        connections: Record<string, string>;
-        username?: string | undefined;
-        password?: string | undefined;
-    }, {
-        host: string;
-        connections: Record<string, string>;
-        username?: string | undefined;
-        password?: string | undefined;
-    }>>;
+    }, z.core.$strip>>;
     graphql: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        enabled: boolean;
-    }, {
-        enabled?: boolean | undefined;
-    }>>;
+    }, z.core.$strip>>;
     rbac: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
-        roles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        enabled: boolean;
-        roles?: string[] | undefined;
-    }, {
-        roles?: string[] | undefined;
-        enabled?: boolean | undefined;
-    }>>;
+        roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
     auth: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        enabled: boolean;
-    }, {
-        enabled?: boolean | undefined;
-    }>>;
+    }, z.core.$strip>>;
     auditTrail: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        enabled: boolean;
-    }, {
-        enabled?: boolean | undefined;
-    }>>;
+    }, z.core.$strip>>;
     monitoring: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        enabled: boolean;
-    }, {
-        enabled?: boolean | undefined;
-    }>>;
-    authentication: z.ZodOptional<z.ZodDiscriminatedUnion<"service", [z.ZodObject<{
+    }, z.core.$strip>>;
+    authentication: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         service: z.ZodLiteral<"okta">;
         superuserEmail: z.ZodString;
         domain: z.ZodString;
@@ -135,39 +61,7 @@ export declare const ConfigSchema: z.ZodObject<{
         roleClaim: z.ZodDefault<z.ZodString>;
         defaultRole: z.ZodDefault<z.ZodString>;
         clientId: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        service: "okta";
-        superuserEmail: string;
-        domain: string;
-        authServer: string;
-        clientSecret: string;
-        apiToken: string;
-        scope: string;
-        cookieTtlMs: number;
-        introspect: boolean;
-        authorizeRedirectUrl: string;
-        clientUrl: string;
-        roleClaim: string;
-        defaultRole: string;
-        clientId: string;
-        cookieDomain?: string | undefined;
-    }, {
-        service: "okta";
-        superuserEmail: string;
-        domain: string;
-        clientSecret: string;
-        apiToken: string;
-        authorizeRedirectUrl: string;
-        clientUrl: string;
-        clientId: string;
-        cookieDomain?: string | undefined;
-        authServer?: string | undefined;
-        scope?: string | undefined;
-        cookieTtlMs?: number | undefined;
-        introspect?: boolean | undefined;
-        roleClaim?: string | undefined;
-        defaultRole?: string | undefined;
-    }>, z.ZodObject<{
+    }, z.core.$strip>, z.ZodObject<{
         service: z.ZodLiteral<"cognito">;
         superuserEmail: z.ZodString;
         superuserPassword: z.ZodOptional<z.ZodString>;
@@ -176,264 +70,39 @@ export declare const ConfigSchema: z.ZodObject<{
         clientId: z.ZodString;
         whitelistEnabled: z.ZodDefault<z.ZodBoolean>;
         disableUserSessions: z.ZodDefault<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        service: "cognito";
-        superuserEmail: string;
-        clientId: string;
-        isIdentityStore: boolean;
-        userPoolId: string;
-        whitelistEnabled: boolean;
-        disableUserSessions: boolean;
-        superuserPassword?: string | undefined;
-    }, {
-        service: "cognito";
-        superuserEmail: string;
-        clientId: string;
-        userPoolId: string;
-        superuserPassword?: string | undefined;
-        isIdentityStore?: boolean | undefined;
-        whitelistEnabled?: boolean | undefined;
-        disableUserSessions?: boolean | undefined;
-    }>]>>;
+    }, z.core.$strip>], "service">>;
     openapi: z.ZodOptional<z.ZodArray<z.ZodObject<{
         specUrl: z.ZodString;
         baseUrl: z.ZodOptional<z.ZodString>;
         name: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        specUrl: string;
-        baseUrl?: string | undefined;
-    }, {
-        name: string;
-        specUrl: string;
-        baseUrl?: string | undefined;
-    }>, "many">>;
+    }, z.core.$strip>>>;
     logging: z.ZodOptional<z.ZodObject<{
-        level: z.ZodDefault<z.ZodEnum<["error", "warn", "info", "debug"]>>;
-    }, "strip", z.ZodTypeAny, {
-        level: "error" | "info" | "warn" | "debug";
-    }, {
-        level?: "error" | "info" | "warn" | "debug" | undefined;
-    }>>;
+        level: z.ZodDefault<z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warn: "warn";
+            debug: "debug";
+        }>>;
+    }, z.core.$strip>>;
     retry: z.ZodOptional<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         attempts: z.ZodNumber;
         backoff: z.ZodObject<{
-            strategy: z.ZodEnum<["linear", "exponential", "constant"]>;
+            strategy: z.ZodEnum<{
+                linear: "linear";
+                exponential: "exponential";
+                constant: "constant";
+            }>;
             delay: z.ZodNumber;
-            magnitude: z.ZodEnum<["seconds", "milliSeconds", "minutes"]>;
+            magnitude: z.ZodEnum<{
+                seconds: "seconds";
+                milliSeconds: "milliSeconds";
+                minutes: "minutes";
+            }>;
             factor: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            strategy: "linear" | "exponential" | "constant";
-            delay: number;
-            magnitude: "seconds" | "milliSeconds" | "minutes";
-            factor: number;
-        }, {
-            strategy: "linear" | "exponential" | "constant";
-            delay: number;
-            magnitude: "seconds" | "milliSeconds" | "minutes";
-            factor: number;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        attempts: number;
-        backoff: {
-            strategy: "linear" | "exponential" | "constant";
-            delay: number;
-            magnitude: "seconds" | "milliSeconds" | "minutes";
-            factor: number;
-        };
-        name: string;
-    }, {
-        attempts: number;
-        backoff: {
-            strategy: "linear" | "exponential" | "constant";
-            delay: number;
-            magnitude: "seconds" | "milliSeconds" | "minutes";
-            factor: number;
-        };
-        name: string;
-    }>, "many">>;
-}, "strip", z.ZodTypeAny, {
-    service: {
-        port: number;
-        httpFileHandling: boolean;
-        host?: string | undefined;
-    };
-    store?: {
-        type: "postgres";
-        port: number;
-        host: string;
-        username: string;
-        password: string;
-        dbname: string;
-    } | {
-        type: "mysql";
-        port: number;
-        host: string;
-        username: string;
-        password: string;
-        dbname: string;
-    } | {
-        type: "sqlite";
-        dbname?: string | undefined;
-    } | undefined;
-    integrations?: {
-        host: string;
-        connections: Record<string, string>;
-        username?: string | undefined;
-        password?: string | undefined;
-    } | undefined;
-    graphql?: {
-        enabled: boolean;
-    } | undefined;
-    rbac?: {
-        enabled: boolean;
-        roles?: string[] | undefined;
-    } | undefined;
-    auth?: {
-        enabled: boolean;
-    } | undefined;
-    auditTrail?: {
-        enabled: boolean;
-    } | undefined;
-    monitoring?: {
-        enabled: boolean;
-    } | undefined;
-    authentication?: {
-        service: "okta";
-        superuserEmail: string;
-        domain: string;
-        authServer: string;
-        clientSecret: string;
-        apiToken: string;
-        scope: string;
-        cookieTtlMs: number;
-        introspect: boolean;
-        authorizeRedirectUrl: string;
-        clientUrl: string;
-        roleClaim: string;
-        defaultRole: string;
-        clientId: string;
-        cookieDomain?: string | undefined;
-    } | {
-        service: "cognito";
-        superuserEmail: string;
-        clientId: string;
-        isIdentityStore: boolean;
-        userPoolId: string;
-        whitelistEnabled: boolean;
-        disableUserSessions: boolean;
-        superuserPassword?: string | undefined;
-    } | undefined;
-    openapi?: {
-        name: string;
-        specUrl: string;
-        baseUrl?: string | undefined;
-    }[] | undefined;
-    logging?: {
-        level: "error" | "info" | "warn" | "debug";
-    } | undefined;
-    retry?: {
-        attempts: number;
-        backoff: {
-            strategy: "linear" | "exponential" | "constant";
-            delay: number;
-            magnitude: "seconds" | "milliSeconds" | "minutes";
-            factor: number;
-        };
-        name: string;
-    }[] | undefined;
-}, {
-    service?: {
-        port: number;
-        host?: string | undefined;
-        httpFileHandling?: boolean | undefined;
-    } | undefined;
-    store?: {
-        type: "postgres";
-        port?: number | undefined;
-        host?: string | undefined;
-        username?: string | undefined;
-        password?: string | undefined;
-        dbname?: string | undefined;
-    } | {
-        type: "mysql";
-        port?: number | undefined;
-        host?: string | undefined;
-        username?: string | undefined;
-        password?: string | undefined;
-        dbname?: string | undefined;
-    } | {
-        type: "sqlite";
-        dbname?: string | undefined;
-    } | undefined;
-    integrations?: {
-        host: string;
-        connections: Record<string, string>;
-        username?: string | undefined;
-        password?: string | undefined;
-    } | undefined;
-    graphql?: {
-        enabled?: boolean | undefined;
-    } | undefined;
-    rbac?: {
-        roles?: string[] | undefined;
-        enabled?: boolean | undefined;
-    } | undefined;
-    auth?: {
-        enabled?: boolean | undefined;
-    } | undefined;
-    auditTrail?: {
-        enabled?: boolean | undefined;
-    } | undefined;
-    monitoring?: {
-        enabled?: boolean | undefined;
-    } | undefined;
-    authentication?: {
-        service: "okta";
-        superuserEmail: string;
-        domain: string;
-        clientSecret: string;
-        apiToken: string;
-        authorizeRedirectUrl: string;
-        clientUrl: string;
-        clientId: string;
-        cookieDomain?: string | undefined;
-        authServer?: string | undefined;
-        scope?: string | undefined;
-        cookieTtlMs?: number | undefined;
-        introspect?: boolean | undefined;
-        roleClaim?: string | undefined;
-        defaultRole?: string | undefined;
-    } | {
-        service: "cognito";
-        superuserEmail: string;
-        clientId: string;
-        userPoolId: string;
-        superuserPassword?: string | undefined;
-        isIdentityStore?: boolean | undefined;
-        whitelistEnabled?: boolean | undefined;
-        disableUserSessions?: boolean | undefined;
-    } | undefined;
-    openapi?: {
-        name: string;
-        specUrl: string;
-        baseUrl?: string | undefined;
-    }[] | undefined;
-    logging?: {
-        level?: "error" | "info" | "warn" | "debug" | undefined;
-    } | undefined;
-    retry?: {
-        attempts: number;
-        backoff: {
-            strategy: "linear" | "exponential" | "constant";
-            delay: number;
-            magnitude: "seconds" | "milliSeconds" | "minutes";
-            factor: number;
-        };
-        name: string;
-    }[] | undefined;
-}>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 export type Config = z.infer<typeof ConfigSchema>;
 export declare let AppConfig: Config | undefined;
 export declare function setAppConfig(config: Config): Config;

package/out/runtime/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/runtime/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiIvB,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD,eAAO,IAAI,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;AAEzC,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGnD;AAID,wBAAgB,wBAAwB,SAEvC;AAED,wBAAgB,yBAAyB,SAExC;AAED,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C;AAOD,qBAAa,QAAQ,CAAC,CAAC;IACrB,OAAO,CAAC,KAAK,CAAgC;IAC7C,OAAO,CAAC,KAAK,CAAS;gBAEV,KAAK,EAAE,MAAM;IAKzB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,CAAC;IAiBvD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAW/B,MAAM,CAAC,GAAG,EAAE,MAAM;CAGnB"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/runtime/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiIvB,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD,eAAO,IAAI,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;AAEzC,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGnD;AAID,wBAAgB,wBAAwB,SAEvC;AAED,wBAAgB,yBAAyB,SAExC;AAED,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C;AAOD,qBAAa,QAAQ,CAAC,CAAC;IACrB,OAAO,CAAC,KAAK,CAAgC;IAC7C,OAAO,CAAC,KAAK,CAAS;gBAEV,KAAK,EAAE,MAAM;IAKzB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,CAAC;IAiBvD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAW/B,MAAM,CAAC,GAAG,EAAE,MAAM;CAGnB"}

package/out/setupClassic.d.ts

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1 @@
+{"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

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

package/out/setupCommon.d.ts.map

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

package/out/setupCommon.js

@@ -0,0 +1,33 @@
+// 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

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