windmill-cli 0.0.1

package/esm/script_common.js

@@ -0,0 +1,50 @@
+export function inferContentTypeFromFilePath(contentPath, defaultTs) {
+    if (contentPath.endsWith(".py")) {
+        return "python3";
+    }
+    else if (contentPath.endsWith("fetch.ts")) {
+        return "nativets";
+    }
+    else if (contentPath.endsWith("bun.ts")) {
+        return "bun";
+    }
+    else if (contentPath.endsWith("deno.ts")) {
+        return "deno";
+    }
+    else if (contentPath.endsWith(".ts")) {
+        return defaultTs ?? "bun";
+    }
+    else if (contentPath.endsWith(".go")) {
+        return "go";
+    }
+    else if (contentPath.endsWith(".my.sql")) {
+        return "mysql";
+    }
+    else if (contentPath.endsWith(".bq.sql")) {
+        return "bigquery";
+    }
+    else if (contentPath.endsWith(".sf.sql")) {
+        return "snowflake";
+    }
+    else if (contentPath.endsWith(".ms.sql")) {
+        return "mssql";
+    }
+    else if (contentPath.endsWith(".pg.sql")) {
+        return "postgresql";
+    }
+    else if (contentPath.endsWith(".gql")) {
+        return "graphql";
+    }
+    else if (contentPath.endsWith(".sh")) {
+        return "bash";
+    }
+    else if (contentPath.endsWith(".ps1")) {
+        return "powershell";
+    }
+    else if (contentPath.endsWith("php")) {
+        return "php";
+    }
+    else {
+        throw new Error("Invalid language: " + contentPath.substring(contentPath.lastIndexOf(".")));
+    }
+}

package/esm/settings.d.ts

@@ -0,0 +1,24 @@
+export interface SimplifiedSettings {
+    auto_invite_enabled: boolean;
+    auto_invite_as: string;
+    auto_invite_mode: string;
+    webhook?: string;
+    deploy_to?: string;
+    error_handler?: string;
+    error_handler_extra_args?: any;
+    error_handler_muted_on_cancel?: boolean;
+    openai_resource_path?: string;
+    code_completion_enabled: boolean;
+    large_file_storage?: any;
+    git_sync?: any;
+    default_app?: string;
+    default_scripts?: any;
+    name: string;
+}
+export declare function pushWorkspaceSettings(workspace: string, _path: string, settings: SimplifiedSettings | undefined, localSettings: SimplifiedSettings): Promise<void>;
+export declare function pushWorkspaceKey(workspace: string, _path: string, key: string | undefined, localKey: string): Promise<void>;
+export declare function pullInstanceSettings(preview?: boolean): Promise<number | undefined>;
+export declare function pushInstanceSettings(preview?: boolean, baseUrl?: string): Promise<number | undefined>;
+export declare function pullInstanceConfigs(preview?: boolean): Promise<number | undefined>;
+export declare function pushInstanceConfigs(preview?: boolean): Promise<number | undefined>;
+//# sourceMappingURL=settings.d.ts.map

package/esm/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../src/settings.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,kBAAkB;IAKjC,mBAAmB,EAAE,OAAO,CAAC;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,wBAAwB,CAAC,EAAE,GAAG,CAAC;IAC/B,6BAA6B,CAAC,EAAE,OAAO,CAAC;IACxC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,uBAAuB,EAAE,OAAO,CAAC;IACjC,kBAAkB,CAAC,EAAE,GAAG,CAAC;IACzB,QAAQ,CAAC,EAAE,GAAG,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,GAAG,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAsB,qBAAqB,CACzC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,kBAAkB,GAAG,SAAS,EACxC,aAAa,EAAE,kBAAkB,iBA2LlC;AAED,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,QAAQ,EAAE,MAAM,iBA0BjB;AAED,wBAAsB,oBAAoB,CAAC,OAAO,UAAQ,+BA4BzD;AAED,wBAAsB,oBAAoB,CACxC,OAAO,GAAE,OAAe,EACxB,OAAO,CAAC,EAAE,MAAM,+BA4DjB;AAED,wBAAsB,mBAAmB,CAAC,OAAO,UAAQ,+BA2BxD;AAED,wBAAsB,mBAAmB,CAAC,OAAO,GAAE,OAAe,+BA8CjE"}

package/esm/settings.js

@@ -0,0 +1,327 @@
+import * as dntShim from "./_dnt.shims.js";
+import { SettingService } from "./deps.js";
+import { yamlStringify } from "./deps.js";
+import { Confirm } from "./deps.js";
+import { colors } from "./deps.js";
+import { ConfigService } from "./deps.js";
+import { yamlParse } from "./deps.js";
+import { WorkspaceService, log } from "./deps.js";
+import { compareInstanceObjects } from "./instance.js";
+import { isSuperset } from "./types.js";
+import { deepEqual } from "./utils.js";
+export async function pushWorkspaceSettings(workspace, _path, settings, localSettings) {
+    try {
+        const remoteSettings = await WorkspaceService.getSettings({
+            workspace,
+        });
+        const workspaceName = await WorkspaceService.getWorkspaceName({
+            workspace,
+        });
+        settings = {
+            // slack_team_id: remoteSettings.slack_team_id,
+            // slack_name: remoteSettings.slack_name,
+            // slack_command_script: remoteSettings.slack_command_script,
+            // slack_email: remoteSettings.slack_email,
+            auto_invite_enabled: remoteSettings.auto_invite_domain !== null,
+            auto_invite_as: remoteSettings.auto_invite_operator
+                ? "operator"
+                : "developer",
+            auto_invite_mode: remoteSettings.auto_add ? "add" : "invite",
+            webhook: remoteSettings.webhook,
+            deploy_to: remoteSettings.deploy_to,
+            error_handler: remoteSettings.error_handler,
+            error_handler_extra_args: remoteSettings.error_handler_extra_args,
+            error_handler_muted_on_cancel: remoteSettings.error_handler_muted_on_cancel,
+            openai_resource_path: remoteSettings.openai_resource_path,
+            code_completion_enabled: remoteSettings.code_completion_enabled,
+            large_file_storage: remoteSettings.large_file_storage,
+            git_sync: remoteSettings.git_sync,
+            default_app: remoteSettings.default_app,
+            default_scripts: remoteSettings.default_scripts,
+            name: workspaceName,
+        };
+    }
+    catch (err) {
+        throw new Error(`Failed to get workspace settings: ${err}`);
+    }
+    if (isSuperset(localSettings, settings)) {
+        log.debug(`Workspace settings are up to date`);
+        return;
+    }
+    log.debug(`Workspace settings are not up-to-date, updating...`);
+    if (localSettings.webhook !== settings.webhook) {
+        log.debug(`Updateing webhook...`);
+        await WorkspaceService.editWebhook({
+            workspace,
+            requestBody: {
+                webhook: localSettings.webhook,
+            },
+        });
+    }
+    if (localSettings.auto_invite_as !== settings.auto_invite_as ||
+        localSettings.auto_invite_enabled !== settings.auto_invite_enabled ||
+        localSettings.auto_invite_mode !== settings.auto_invite_mode) {
+        log.debug(`Updating auto invite...`);
+        if (!["operator", "developer"].includes(settings.auto_invite_as)) {
+            throw new Error(`Invalid value for auto_invite_as. Valid values are "operator" and "developer"`);
+        }
+        if (!["add", "invite"].includes(settings.auto_invite_mode)) {
+            throw new Error(`Invalid value for auto_invite_mode. Valid values are "invite" and "add"`);
+        }
+        try {
+            await WorkspaceService.editAutoInvite({
+                workspace,
+                requestBody: localSettings.auto_invite_enabled
+                    ? {
+                        operator: localSettings.auto_invite_as === "operator",
+                        invite_all: true,
+                        auto_add: localSettings.auto_invite_mode === "add",
+                    }
+                    : {},
+            });
+        }
+        catch (_) {
+            // on cloud
+            log.debug(`Auto invite is not possible on cloud, only auto-inviting same domain...`);
+            await WorkspaceService.editAutoInvite({
+                workspace,
+                requestBody: localSettings.auto_invite_enabled
+                    ? {
+                        operator: localSettings.auto_invite_as === "operator",
+                        invite_all: false,
+                        auto_add: localSettings.auto_invite_mode === "add",
+                    }
+                    : {},
+            });
+        }
+    }
+    if (localSettings.openai_resource_path !== settings.openai_resource_path ||
+        localSettings.code_completion_enabled !== settings.code_completion_enabled) {
+        log.debug(`Updating openai settings...`);
+        await WorkspaceService.editCopilotConfig({
+            workspace,
+            requestBody: {
+                openai_resource_path: localSettings.openai_resource_path,
+                code_completion_enabled: localSettings.code_completion_enabled,
+            },
+        });
+    }
+    if (localSettings.error_handler !== settings.error_handler ||
+        !deepEqual(localSettings.error_handler_extra_args, settings.error_handler_extra_args) ||
+        localSettings.error_handler_muted_on_cancel !==
+            settings.error_handler_muted_on_cancel) {
+        log.debug(`Updating error handler...`);
+        await WorkspaceService.editErrorHandler({
+            workspace,
+            requestBody: {
+                error_handler: localSettings.error_handler,
+                error_handler_extra_args: localSettings.error_handler_extra_args,
+                error_handler_muted_on_cancel: localSettings.error_handler_muted_on_cancel,
+            },
+        });
+    }
+    if (localSettings.deploy_to !== settings.deploy_to) {
+        log.debug(`Updating deploy to...`);
+        await WorkspaceService.editDeployTo({
+            workspace,
+            requestBody: {
+                deploy_to: localSettings.deploy_to,
+            },
+        });
+    }
+    if (!deepEqual(localSettings.large_file_storage, settings.large_file_storage)) {
+        log.debug(`Updating large file storage...`);
+        await WorkspaceService.editLargeFileStorageConfig({
+            workspace,
+            requestBody: {
+                large_file_storage: localSettings.large_file_storage,
+            },
+        });
+    }
+    if (!deepEqual(localSettings.git_sync, settings.git_sync)) {
+        log.debug(`Updating git sync...`);
+        await WorkspaceService.editWorkspaceGitSyncConfig({
+            workspace,
+            requestBody: {
+                git_sync_settings: localSettings.git_sync,
+            },
+        });
+    }
+    if (!deepEqual(localSettings.default_scripts, settings.default_scripts)) {
+        log.debug(`Updating default scripts...`);
+        await WorkspaceService.editDefaultScripts({
+            workspace,
+            requestBody: localSettings.default_scripts,
+        });
+    }
+    if (localSettings.default_app !== settings.default_app) {
+        log.debug(`Updating default app...`);
+        await WorkspaceService.editWorkspaceDefaultApp({
+            workspace,
+            requestBody: {
+                default_app_path: localSettings.default_app,
+            },
+        });
+    }
+    if (localSettings.name !== settings.name) {
+        log.debug(`Updating workspace name...`);
+        await WorkspaceService.changeWorkspaceName({
+            workspace,
+            requestBody: {
+                new_name: localSettings.name,
+            },
+        });
+    }
+}
+export async function pushWorkspaceKey(workspace, _path, key, localKey) {
+    try {
+        key = await WorkspaceService.getWorkspaceEncryptionKey({
+            workspace,
+        }).then((r) => r.key);
+    }
+    catch (err) {
+        throw new Error(`Failed to get workspace encryption key: ${err}`);
+    }
+    if (localKey && key !== localKey) {
+        const confirm = await Confirm.prompt({
+            message: "The local workspace encryption key does not match the remote. Do you want to reencrypt all your secrets on the remote with the new key?\nSay 'no' if your local secrets are already encrypted with the new key (e.g. workspace/instance migration)\nOtherwise, say 'yes' and pull the secrets after the reencryption.\n",
+            default: true,
+        });
+        log.debug(`Updating workspace encryption key...`);
+        await WorkspaceService.setWorkspaceEncryptionKey({
+            workspace,
+            requestBody: {
+                new_key: localKey,
+                skip_reencrypt: !confirm,
+            },
+        });
+    }
+    else {
+        log.debug(`Workspace encryption key is up to date`);
+    }
+}
+export async function pullInstanceSettings(preview = false) {
+    const remoteSettings = await SettingService.listGlobalSettings();
+    if (preview) {
+        let localSettings = [];
+        try {
+            localSettings = yamlParse(await dntShim.Deno.readTextFile("instance_settings.yaml"));
+        }
+        catch { }
+        return compareInstanceObjects(remoteSettings, localSettings, "name", "setting");
+    }
+    else {
+        log.info("Pulling settings from instance");
+        await dntShim.Deno.writeTextFile("instance_settings.yaml", yamlStringify(remoteSettings));
+        log.info(colors.green("Settings written to instance_settings.yaml"));
+    }
+}
+export async function pushInstanceSettings(preview = false, baseUrl) {
+    const remoteSettings = await SettingService.listGlobalSettings();
+    let localSettings = (await dntShim.Deno.readTextFile("instance_settings.yaml")
+        .then((raw) => yamlParse(raw))
+        .catch(() => []));
+    if (baseUrl) {
+        localSettings = localSettings.filter((s) => s.name !== "base_url");
+        localSettings.push({
+            name: "base_url",
+            value: baseUrl,
+        });
+    }
+    if (preview) {
+        return compareInstanceObjects(localSettings, remoteSettings, "name", "setting");
+    }
+    else {
+        for (const setting of localSettings) {
+            const remoteMatch = remoteSettings.find((s) => s.name === setting.name);
+            if (remoteMatch && deepEqual(remoteMatch, setting)) {
+                continue;
+            }
+            try {
+                await SettingService.setGlobal({
+                    key: setting.name,
+                    requestBody: {
+                        value: setting.value,
+                    },
+                });
+            }
+            catch (err) {
+                log.error(`Failed to set setting ${setting.name}: ${err}`);
+            }
+        }
+        for (const remoteSetting of remoteSettings) {
+            const localMatch = localSettings.find((s) => s.name === remoteSetting.name);
+            if (!localMatch) {
+                try {
+                    await SettingService.setGlobal({
+                        key: remoteSetting.name,
+                        requestBody: {
+                            value: null,
+                        },
+                    });
+                }
+                catch (err) {
+                    log.error(`Failed to delete setting ${remoteSetting.name}: ${err}`);
+                }
+            }
+        }
+        log.info(colors.green("Settings pushed to instance"));
+    }
+}
+export async function pullInstanceConfigs(preview = false) {
+    const remoteConfigs = await ConfigService.listConfigs();
+    if (preview) {
+        let localConfigs = [];
+        try {
+            localConfigs = yamlParse(await dntShim.Deno.readTextFile("instance_configs.yaml"));
+        }
+        catch { }
+        return compareInstanceObjects(remoteConfigs, localConfigs, "name", "config");
+    }
+    else {
+        log.info("Pulling configs from instance");
+        await dntShim.Deno.writeTextFile("instance_configs.yaml", yamlStringify(remoteConfigs));
+        log.info(colors.green("Configs written to instance_configs.yaml"));
+    }
+}
+export async function pushInstanceConfigs(preview = false) {
+    const remoteConfigs = await ConfigService.listConfigs();
+    const localConfigs = (await dntShim.Deno.readTextFile("instance_configs.yaml")
+        .then((raw) => yamlParse(raw))
+        .catch(() => []));
+    if (preview) {
+        return compareInstanceObjects(localConfigs, remoteConfigs, "name", "config");
+    }
+    else {
+        log.info("Pushing configs to instance");
+        for (const config of localConfigs) {
+            const remoteMatch = remoteConfigs.find((c) => c.name === config.name);
+            if (remoteMatch && deepEqual(remoteMatch, config)) {
+                continue;
+            }
+            try {
+                await ConfigService.updateConfig({
+                    name: config.name,
+                    requestBody: config.config,
+                });
+            }
+            catch (err) {
+                log.error(`Failed to set config ${config.name}: ${err}`);
+            }
+        }
+        for (const removeConfig of remoteConfigs) {
+            const localMatch = localConfigs.find((c) => c.name === removeConfig.name);
+            if (!localMatch) {
+                try {
+                    await ConfigService.deleteConfig({
+                        name: removeConfig.name,
+                    });
+                }
+                catch (err) {
+                    log.error(`Failed to delete config ${removeConfig.name}: ${err}`);
+                }
+            }
+        }
+        log.info(colors.green("Configs pushed to instance"));
+    }
+}

package/esm/store.d.ts

@@ -0,0 +1,3 @@
+export declare function getRootStore(): Promise<string>;
+export declare function getStore(baseUrl: string): Promise<string>;
+//# sourceMappingURL=store.d.ts.map

package/esm/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAgBA,wBAAsB,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAIpD;AAED,wBAAsB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAK/D"}

package/esm/store.js

@@ -0,0 +1,71 @@
+import * as dntShim from "./_dnt.shims.js";
+import { ensureDir } from "./deps.js";
+function hash_string(str) {
+    let hash = 0, i, chr;
+    if (str.length === 0)
+        return hash;
+    for (i = 0; i < str.length; i++) {
+        chr = str.charCodeAt(i);
+        hash = (hash << 5) - hash + chr;
+        hash |= 0; // Convert to 32bit integer
+    }
+    return hash;
+}
+export async function getRootStore() {
+    const store = (config_dir() ?? tmp_dir() ?? "/tmp/") + "/windmill/";
+    await ensureDir(store);
+    return store;
+}
+export async function getStore(baseUrl) {
+    const baseHash = Math.abs(hash_string(baseUrl)).toString(16);
+    const baseStore = (await getRootStore()) + baseHash + "/";
+    await ensureDir(baseStore);
+    return baseStore;
+}
+//inlined import dir from "https://deno.land/x/dir/mod.ts";
+function tmp_dir() {
+    switch (dntShim.Deno.build.os) {
+        case "linux": {
+            const xdg = dntShim.Deno.env.get("XDG_RUNTIME_DIR");
+            if (xdg)
+                return `${xdg}-/tmp`;
+            const tmpDir = dntShim.Deno.env.get("TMPDIR");
+            if (tmpDir)
+                return tmpDir;
+            const tempDir = dntShim.Deno.env.get("TEMP");
+            if (tempDir)
+                return tempDir;
+            const tmp = dntShim.Deno.env.get("TMP");
+            if (tmp)
+                return tmp;
+            return "/var/tmp";
+        }
+        case "darwin":
+            return dntShim.Deno.env.get("TMPDIR") ?? null;
+        case "windows":
+            return dntShim.Deno.env.get("TMP") ?? dntShim.Deno.env.get("TEMP") ?? null;
+    }
+    return null;
+}
+function config_dir() {
+    switch (dntShim.Deno.build.os) {
+        case "linux": {
+            const xdg = dntShim.Deno.env.get("XDG_CONFIG_HOME");
+            if (xdg)
+                return xdg;
+            const home = dntShim.Deno.env.get("HOME");
+            if (home)
+                return `${home}/.config`;
+            break;
+        }
+        case "darwin": {
+            const home = dntShim.Deno.env.get("HOME");
+            if (home)
+                return `${home}/Library/Preferences`;
+            break;
+        }
+        case "windows":
+            return dntShim.Deno.env.get("APPDATA") ?? null;
+    }
+    return null;
+}

package/esm/sync.d.ts

@@ -0,0 +1,99 @@
+import { Command, FlowModule } from "./deps.js";
+import { GlobalOptions } from "./types.js";
+import { SyncOptions } from "./conf.js";
+import { SyncCodebase } from "./codebase.js";
+type DynFSElement = {
+    isDirectory: boolean;
+    path: string;
+    getContentText(): Promise<string>;
+    getChildren(): AsyncIterable<DynFSElement>;
+};
+export declare function findCodebase(path: string, codebases: SyncCodebase[]): SyncCodebase | undefined;
+export declare function FSFSElement(p: string, codebases: SyncCodebase[]): Promise<DynFSElement>;
+export declare const yamlOptions: {
+    sortKeys: (a: any, b: any) => number;
+    noCompatMode: boolean;
+    noRefs: boolean;
+    skipInvalid: boolean;
+};
+export interface InlineScript {
+    path: string;
+    content: string;
+}
+export declare function extractInlineScriptsForFlows(modules: FlowModule[], pathAssigner: PathAssigner): InlineScript[];
+interface PathAssigner {
+    assignPath(summary: string | undefined, language: string): [string, string];
+}
+export declare function extractInlineScriptsForApps(rec: any, pathAssigner: PathAssigner): InlineScript[];
+export declare function newPathAssigner(defaultTs: "bun" | "deno"): PathAssigner;
+export declare function readDirRecursiveWithIgnore(ignore: (path: string, isDirectory: boolean) => boolean, root: DynFSElement): AsyncGenerator<{
+    path: string;
+    ignored: boolean;
+    isDirectory: boolean;
+    getContentText(): Promise<string>;
+}>;
+export declare function elementsToMap(els: DynFSElement, ignore: (path: string, isDirectory: boolean) => boolean, json: boolean, skips: Skips): Promise<{
+    [key: string]: string;
+}>;
+interface Skips {
+    skipVariables?: boolean | undefined;
+    skipResources?: boolean | undefined;
+    skipSecrets?: boolean | undefined;
+    includeSchedules?: boolean | undefined;
+    includeUsers?: boolean | undefined;
+    includeGroups?: boolean | undefined;
+    includeSettings?: boolean | undefined;
+    includeKey?: boolean | undefined;
+}
+export declare const isWhitelisted: (p: string) => boolean;
+export declare function ignoreF(wmillconf: {
+    includes?: string[];
+    excludes?: string[];
+}): Promise<(p: string, isDirectory: boolean) => boolean>;
+export declare function pull(opts: GlobalOptions & SyncOptions): Promise<void>;
+export declare function push(opts: GlobalOptions & SyncOptions): Promise<void>;
+declare const command: Command<void, void, {
+    failConflicts?: true | undefined;
+} & {
+    raw?: true | undefined;
+} & {
+    stateful?: true | undefined;
+} & {
+    skipPull?: true | undefined;
+} & {
+    yes?: true | undefined;
+} & {
+    plainSecrets?: true | undefined;
+} & {
+    json?: true | undefined;
+} & {
+    skipVariables?: true | undefined;
+} & {
+    skipSecrets?: true | undefined;
+} & {
+    skipResources?: true | undefined;
+} & {
+    includeSchedules?: true | undefined;
+} & {
+    includeUsers?: true | undefined;
+} & {
+    includeGroups?: true | undefined;
+} & {
+    includeSettings?: true | undefined;
+} & {
+    includeKey?: true | undefined;
+} & {
+    includes?: import("./deps/jsr.io/@cliffy/command/1.0.0-rc.5/mod.js").FileType[] | undefined;
+} & {
+    excludes?: import("./deps/jsr.io/@cliffy/command/1.0.0-rc.5/mod.js").FileType[] | undefined;
+} & {
+    message?: import("./deps/jsr.io/@cliffy/command/1.0.0-rc.5/mod.js").StringType | undefined;
+}, [], void, void, void, Command<void, void, void, [], void, {
+    number: number;
+    integer: number;
+    string: string;
+    boolean: boolean;
+    file: string;
+}, void, undefined>>;
+export default command;
+//# sourceMappingURL=sync.d.ts.map

package/esm/sync.d.ts.map

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