ic-mops 2.0.0 → 2.1.0

package/dist/constants.js

@@ -0,0 +1,21 @@
+/**
+ * Common ignore patterns for glob operations across Motoko files.
+ */
+export const MOTOKO_IGNORE_PATTERNS = [
+    "**/node_modules/**",
+    "**/.mops/**",
+    "**/.vessel/**",
+    "**/.git/**",
+    "**/dist/**",
+];
+/**
+ * Common glob configuration for Motoko file operations
+ */
+export const MOTOKO_GLOB_CONFIG = {
+    nocase: true,
+    ignore: MOTOKO_IGNORE_PATTERNS,
+};
+/**
+ * Regex to match a file path for dependency and toolchain versions
+ */
+export const FILE_PATH_REGEX = /^(\.?\.)?\//;

package/dist/environments/nodejs/cli.js

@@ -1,4 +1,9 @@
-import * as wasm from "../../wasm/pkg/nodejs/wasm.js";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { setWasmBindings } from "../../wasm.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const wasm = require(path.join(__dirname, "../../wasm/pkg/nodejs/wasm.js"));
 setWasmBindings(wasm);
 export * from "../../cli.js";

package/dist/helpers/autofix-motoko.d.ts

@@ -0,0 +1,26 @@
+interface MocSpan {
+    file: string;
+    line_start: number;
+    column_start: number;
+    line_end: number;
+    column_end: number;
+    is_primary: boolean;
+    label: string | null;
+    suggested_replacement: string | null;
+    suggestion_applicability: string | null;
+}
+export interface MocDiagnostic {
+    message: string;
+    code: string;
+    level: string;
+    spans: MocSpan[];
+    notes: string[];
+}
+export declare function parseDiagnostics(stdout: string): MocDiagnostic[];
+export interface AutofixResult {
+    /** Map of file path → diagnostic codes fixed in that file */
+    fixedFiles: Map<string, string[]>;
+    totalFixCount: number;
+}
+export declare function autofixMotoko(mocPath: string, files: string[], mocArgs: string[]): Promise<AutofixResult | null>;
+export {};

package/dist/helpers/autofix-motoko.js

@@ -0,0 +1,105 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { execa } from "execa";
+import { TextDocument, } from "vscode-languageserver-textdocument";
+export function parseDiagnostics(stdout) {
+    return stdout
+        .split("\n")
+        .filter((l) => l.trim())
+        .map((l) => {
+        try {
+            return JSON.parse(l);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((d) => d !== null);
+}
+function extractFixes(diagnostics) {
+    const fixes = [];
+    for (const diag of diagnostics) {
+        for (const span of diag.spans) {
+            if (span.suggestion_applicability === "MachineApplicable" &&
+                span.suggested_replacement !== null) {
+                fixes.push({
+                    file: span.file,
+                    code: diag.code,
+                    edit: {
+                        range: {
+                            start: {
+                                line: span.line_start - 1,
+                                character: span.column_start - 1,
+                            },
+                            end: {
+                                line: span.line_end - 1,
+                                character: span.column_end - 1,
+                            },
+                        },
+                        newText: span.suggested_replacement,
+                    },
+                });
+            }
+        }
+    }
+    return fixes;
+}
+const MAX_FIX_ITERATIONS = 10;
+export async function autofixMotoko(mocPath, files, mocArgs) {
+    const fixedFilesCodes = new Map();
+    for (let iteration = 0; iteration < MAX_FIX_ITERATIONS; iteration++) {
+        const allFixes = [];
+        for (const file of files) {
+            const result = await execa(mocPath, [file, "--error-format=json", ...mocArgs], { stdio: "pipe", reject: false });
+            const diagnostics = parseDiagnostics(result.stdout);
+            allFixes.push(...extractFixes(diagnostics));
+        }
+        if (allFixes.length === 0) {
+            break;
+        }
+        const fixesByFile = new Map();
+        for (const fix of allFixes) {
+            const normalizedPath = resolve(fix.file);
+            const existing = fixesByFile.get(normalizedPath) ?? [];
+            existing.push(fix);
+            fixesByFile.set(normalizedPath, existing);
+        }
+        let progress = false;
+        for (const [file, fixes] of fixesByFile) {
+            const original = await readFile(file, "utf-8");
+            const doc = TextDocument.create(`file://${file}`, "motoko", 0, original);
+            let result;
+            try {
+                result = TextDocument.applyEdits(doc, fixes.map((f) => f.edit));
+            }
+            catch (err) {
+                console.warn(`Warning: could not apply fixes to ${file}: ${err}`);
+                continue;
+            }
+            if (result === original) {
+                continue;
+            }
+            await writeFile(file, result, "utf-8");
+            progress = true;
+            const existing = fixedFilesCodes.get(file) ?? [];
+            for (const fix of fixes) {
+                existing.push(fix.code);
+            }
+            fixedFilesCodes.set(file, existing);
+        }
+        if (!progress) {
+            break;
+        }
+    }
+    if (fixedFilesCodes.size === 0) {
+        return null;
+    }
+    let totalFixCount = 0;
+    for (const codes of fixedFilesCodes.values()) {
+        totalFixCount += codes.length;
+    }
+    return {
+        fixedFiles: fixedFilesCodes,
+        totalFixCount,
+    };
+}

package/dist/helpers/get-moc-version.d.ts

@@ -1 +1,3 @@
+import { type SemVer } from "semver";
+export declare function getMocSemVer(): SemVer | null;
 export declare function getMocVersion(throwOnError?: boolean): string;

package/dist/helpers/get-moc-version.js

@@ -1,7 +1,16 @@
 import { execFileSync } from "node:child_process";
+import { parse } from "semver";
+import { readConfig } from "../mops.js";
 import { getMocPath } from "./get-moc-path.js";
+export function getMocSemVer() {
+    return parse(getMocVersion(false));
+}
 export function getMocVersion(throwOnError = false) {
-    let mocPath = getMocPath(false);
+    let configVersion = readConfig().toolchain?.moc;
+    if (configVersion) {
+        return configVersion;
+    }
+    const mocPath = getMocPath(false);
     if (!mocPath) {
         return "";
     }

package/dist/mops.js

@@ -10,6 +10,7 @@ import { mainActor, storageActor } from "./api/actors.js";
 import { getNetwork } from "./api/network.js";
 import { getHighestVersion } from "./api/getHighestVersion.js";
 import { getPackageId } from "./helpers/get-package-id.js";
+import { FILE_PATH_REGEX } from "./constants.js";
 if (!globalThis.fetch) {
     globalThis.fetch = fetch;
 }
@@ -135,7 +136,7 @@ export function getDependencyType(version) {
     if (version.startsWith("https://github.com/")) {
         return "github";
     }
-    else if (version.match(/^(\.?\.)?\//)) {
+    else if (version.match(FILE_PATH_REGEX)) {
         return "local";
     }
     else {

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "type": "module",
   "bin": {
     "mops": "bin/mops.js",
@@ -70,8 +70,9 @@
     "semver": "7.7.1",
     "stream-to-promise": "3.0.0",
     "string-width": "7.2.0",
-    "tar": "7.4.3",
-    "terminal-size": "4.0.0"
+    "tar": "7.5.6",
+    "terminal-size": "4.0.0",
+    "vscode-languageserver-textdocument": "1.0.12"
   },
   "devDependencies": {
     "@tsconfig/strictest": "2.0.5",

package/dist/tests/build-no-dfx.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/build-no-dfx.test.js

@@ -0,0 +1,9 @@
+import { describe, test } from "@jest/globals";
+import path from "path";
+import { cliSnapshot } from "./helpers";
+describe("build without dfx", () => {
+    test("builds using mops toolchain moc", async () => {
+        const cwd = path.join(import.meta.dirname, "build/no-dfx");
+        await cliSnapshot(["build"], { cwd }, 0);
+    }, 120_000);
+});

package/dist/tests/build.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/build.test.js

@@ -0,0 +1,18 @@
+import { describe, expect, test } from "@jest/globals";
+import path from "path";
+import { cliSnapshot } from "./helpers";
+describe("build", () => {
+    test("ok", async () => {
+        const cwd = path.join(import.meta.dirname, "build/success");
+        await cliSnapshot(["build", "--verbose"], { cwd }, 0);
+        await cliSnapshot(["build", "foo"], { cwd }, 0);
+        await cliSnapshot(["build", "bar"], { cwd }, 0);
+        await cliSnapshot(["build", "foo", "bar"], { cwd }, 0);
+    });
+    test("error", async () => {
+        const cwd = path.join(import.meta.dirname, "build/error");
+        await cliSnapshot(["build", "foo", "--verbose"], { cwd }, 0);
+        expect((await cliSnapshot(["build", "bar"], { cwd }, 1)).stderr).toMatch("Candid compatibility check failed for canister bar");
+        expect((await cliSnapshot(["build", "foo", "bar"], { cwd }, 1)).stderr).toMatch("Candid compatibility check failed for canister bar");
+    });
+});

package/dist/tests/check-candid.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/check-candid.test.js

@@ -0,0 +1,20 @@
+import { describe, test } from "@jest/globals";
+import path from "path";
+import { cliSnapshot } from "./helpers";
+describe("check-candid", () => {
+    test("ok", async () => {
+        const cwd = path.join(import.meta.dirname, "check-candid");
+        await cliSnapshot(["check-candid", "a.did", "a.did"], { cwd }, 0);
+        await cliSnapshot(["check-candid", "b.did", "b.did"], { cwd }, 0);
+        await cliSnapshot(["check-candid", "c.did", "c.did"], { cwd }, 0);
+        await cliSnapshot(["check-candid", "a.did", "b.did"], { cwd }, 0);
+        await cliSnapshot(["check-candid", "b.did", "a.did"], { cwd }, 0);
+    });
+    test("error", async () => {
+        const cwd = path.join(import.meta.dirname, "check-candid");
+        await cliSnapshot(["check-candid", "a.did", "c.did"], { cwd }, 1);
+        await cliSnapshot(["check-candid", "c.did", "a.did"], { cwd }, 1);
+        await cliSnapshot(["check-candid", "b.did", "c.did"], { cwd }, 1);
+        await cliSnapshot(["check-candid", "c.did", "b.did"], { cwd }, 1);
+    });
+});

package/dist/tests/check-fix.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/check-fix.test.js

@@ -0,0 +1,73 @@
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import { cpSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
+import path from "path";
+import { parseDiagnostics } from "../helpers/autofix-motoko";
+import { cli, normalizePaths } from "./helpers";
+function countCodes(stdout) {
+    const counts = {};
+    for (const diag of parseDiagnostics(stdout)) {
+        counts[diag.code] = (counts[diag.code] ?? 0) + 1;
+    }
+    return counts;
+}
+describe("check --fix", () => {
+    const fixDir = path.join(import.meta.dirname, "check/fix");
+    const runDir = path.join(fixDir, "run");
+    const warningFlags = "-W=M0223,M0236,M0237";
+    const diagnosticFlags = [warningFlags, "--error-format=json"];
+    beforeAll(() => {
+        for (const file of readdirSync(runDir).filter((f) => f.endsWith(".mo"))) {
+            unlinkSync(path.join(runDir, file));
+        }
+    });
+    function copyFixture(file) {
+        const dest = path.join(runDir, file);
+        cpSync(path.join(fixDir, file), dest);
+        return dest;
+    }
+    async function testCheckFix(file, expectedDiagnostics, expectedAfterDiagnostics = {}) {
+        const runFilePath = copyFixture(file);
+        const beforeResult = await cli(["check", runFilePath, "--", ...diagnosticFlags], { cwd: fixDir });
+        expect(countCodes(beforeResult.stdout)).toEqual(expectedDiagnostics);
+        const fixResult = await cli(["check", runFilePath, "--fix", "--", warningFlags], { cwd: fixDir });
+        expect(normalizePaths(fixResult.stdout)).toMatchSnapshot("fix output");
+        expect(readFileSync(runFilePath, "utf-8")).toMatchSnapshot();
+        const afterResult = await cli(["check", runFilePath, "--", ...diagnosticFlags], { cwd: fixDir });
+        expect(countCodes(afterResult.stdout)).toEqual(expectedAfterDiagnostics);
+        return runFilePath;
+    }
+    test("M0223", async () => {
+        await testCheckFix("M0223.mo", { M0223: 1 });
+    });
+    test("M0236", async () => {
+        await testCheckFix("M0236.mo", { M0236: 1 });
+    });
+    test("M0237", async () => {
+        await testCheckFix("M0237.mo", { M0237: 1 });
+    });
+    test("edit-suggestions", async () => {
+        await testCheckFix("edit-suggestions.mo", {
+            M0223: 2,
+            M0236: 11,
+            M0237: 17,
+        });
+    });
+    test("transitive imports", async () => {
+        const runMainPath = copyFixture("transitive-main.mo");
+        const runLibPath = copyFixture("transitive-lib.mo");
+        const fixResult = await cli(["check", runMainPath, "--fix", "--", warningFlags], { cwd: fixDir });
+        expect(normalizePaths(fixResult.stdout)).toMatchSnapshot("fix output");
+        expect(readFileSync(runMainPath, "utf-8")).toMatchSnapshot("main file");
+        expect(readFileSync(runLibPath, "utf-8")).toMatchSnapshot("lib file");
+        const afterResult = await cli(["check", runMainPath, "--", ...diagnosticFlags], { cwd: fixDir });
+        expect(countCodes(afterResult.stdout)).toEqual({});
+    });
+    test("verbose", async () => {
+        const result = await cli(["check", "Ok.mo", "--fix", "--verbose"], {
+            cwd: fixDir,
+        });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toContain("Attempting to fix files");
+        expect(result.stdout).toContain("No fixes were needed");
+    });
+});

package/dist/tests/check.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/check.test.js

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "@jest/globals";
+import path from "path";
+import { cliSnapshot } from "./helpers";
+describe("check", () => {
+    test("ok", async () => {
+        const cwd = path.join(import.meta.dirname, "check/success");
+        await cliSnapshot(["check", "Ok.mo"], { cwd }, 0);
+        await cliSnapshot(["check", "Ok.mo", "--verbose"], { cwd }, 0);
+    });
+    test("error", async () => {
+        const cwd = path.join(import.meta.dirname, "check/error");
+        await cliSnapshot(["check", "Error.mo"], { cwd }, 1);
+        await cliSnapshot(["check", "Ok.mo", "Error.mo"], { cwd }, 1);
+    });
+    test("warning", async () => {
+        const cwd = path.join(import.meta.dirname, "check/success");
+        const result = await cliSnapshot(["check", "Warning.mo"], { cwd }, 0);
+        expect(result.stderr).toMatch(/warning \[M0194\]/);
+        expect(result.stderr).toMatch(/unused identifier/);
+    });
+    test("warning verbose", async () => {
+        const cwd = path.join(import.meta.dirname, "check/success");
+        const result = await cliSnapshot(["check", "Warning.mo", "--verbose"], { cwd }, 0);
+        expect(result.stderr).toMatch(/warning \[M0194\]/);
+        expect(result.stderr).toMatch(/unused identifier/);
+    });
+    test("warning with -Werror flag", async () => {
+        const cwd = path.join(import.meta.dirname, "check/success");
+        const result = await cliSnapshot(["check", "Warning.mo", "--", "-Werror"], { cwd }, 1);
+        expect(result.stderr).toMatch(/warning \[M0194\]/);
+        expect(result.stderr).toMatch(/unused identifier/);
+    });
+});

package/dist/tests/cli.test.js

@@ -1,63 +1,10 @@
 import { describe, expect, test } from "@jest/globals";
-import { execa } from "execa";
-import path from "path";
-const cli = async (args, { cwd } = {}) => {
-    return await execa("npm", ["run", "mops", "--", ...args], {
-        env: { MOPS_CWD: cwd },
-        stdio: "pipe",
-        reject: false,
-    });
-};
-const cliSnapshot = async (args, options, exitCode) => {
-    const result = await cli(args, options);
-    expect({
-        command: result.command,
-        exitCode: result.exitCode,
-        timedOut: result.timedOut,
-        stdio: Boolean(result.stdout || result.stderr),
-    }).toEqual({
-        command: result.command,
-        exitCode,
-        timedOut: false,
-        stdio: true,
-    });
-    expect({
-        exitCode: result.exitCode,
-        stdout: result.stdout,
-        stderr: result.stderr,
-    }).toMatchSnapshot();
-    return result;
-};
-describe("mops", () => {
-    test("version", async () => {
+import { cli } from "./helpers";
+describe("cli", () => {
+    test("--version", async () => {
         expect((await cli(["--version"])).stdout).toMatch(/CLI \d+\.\d+\.\d+/);
     });
-    test("help", async () => {
+    test("--help", async () => {
         expect((await cli(["--help"])).stdout).toMatch(/^Usage: mops/m);
     });
-    test("build success", async () => {
-        const cwd = path.join(import.meta.dirname, "build/success");
-        await cliSnapshot(["build"], { cwd }, 0);
-        await cliSnapshot(["build", "foo"], { cwd }, 0);
-        await cliSnapshot(["build", "bar"], { cwd }, 0);
-        await cliSnapshot(["build", "foo", "bar"], { cwd }, 0);
-    });
-    test("build error", async () => {
-        const cwd = path.join(import.meta.dirname, "build/error");
-        await cliSnapshot(["build", "foo"], { cwd }, 0);
-        expect((await cliSnapshot(["build", "bar"], { cwd }, 1)).stderr).toMatch("Candid compatibility check failed for canister bar");
-        expect((await cliSnapshot(["build", "foo", "bar"], { cwd }, 1)).stderr).toMatch("Candid compatibility check failed for canister bar");
-    });
-    test("check-candid", async () => {
-        const cwd = path.join(import.meta.dirname, "check-candid");
-        await cliSnapshot(["check-candid", "a.did", "a.did"], { cwd }, 0);
-        await cliSnapshot(["check-candid", "b.did", "b.did"], { cwd }, 0);
-        await cliSnapshot(["check-candid", "c.did", "c.did"], { cwd }, 0);
-        await cliSnapshot(["check-candid", "a.did", "b.did"], { cwd }, 0);
-        await cliSnapshot(["check-candid", "b.did", "a.did"], { cwd }, 0);
-        await cliSnapshot(["check-candid", "a.did", "c.did"], { cwd }, 1);
-        await cliSnapshot(["check-candid", "c.did", "a.did"], { cwd }, 1);
-        await cliSnapshot(["check-candid", "b.did", "c.did"], { cwd }, 1);
-        await cliSnapshot(["check-candid", "c.did", "b.did"], { cwd }, 1);
-    });
 });

package/dist/tests/helpers.d.ts

@@ -0,0 +1,22 @@
+export interface CliOptions {
+    cwd?: string;
+}
+export declare const cli: (args: string[], { cwd }?: CliOptions) => Promise<import("execa").Result<{
+    stdio: "pipe";
+    reject: false;
+    cwd?: string | undefined;
+    env: {
+        MOPS_CWD?: string | undefined;
+        TZ?: string;
+    };
+}>>;
+export declare const normalizePaths: (text: string) => string;
+export declare const cliSnapshot: (args: string[], options: CliOptions, exitCode: number) => Promise<import("execa").Result<{
+    stdio: "pipe";
+    reject: false;
+    cwd?: string | undefined;
+    env: {
+        MOPS_CWD?: string | undefined;
+        TZ?: string;
+    };
+}>>;

package/dist/tests/helpers.js

@@ -0,0 +1,43 @@
+import { expect } from "@jest/globals";
+import { execa } from "execa";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+export const cli = async (args, { cwd } = {}) => {
+    return await execa("npm", ["run", "--silent", "mops", "--", ...args], {
+        env: { ...process.env, ...(cwd != null && { MOPS_CWD: cwd }) },
+        ...(cwd != null && { cwd }),
+        stdio: "pipe",
+        reject: false,
+    });
+};
+// Strip ANSI escape codes for portable snapshots (avoid control char in regex literal)
+const stripAnsi = (s) => s.replace(new RegExp(`\u001b\\[[0-9;]*m`, "g"), "");
+export const normalizePaths = (text) => {
+    // Replace absolute paths with placeholders for CI
+    return stripAnsi(text
+        .replaceAll(dirname(fileURLToPath(import.meta.url)), "<TEST_DIR>")
+        .replace(/\/[^\s"]+\/\.cache\/mops/g, "<CACHE>")
+        .replace(/\/[^\s"]+\/Library\/Caches\/mops/g, "<CACHE>")
+        .replace(/\/[^\s"[\]]+\/moc(?:-wrapper)?(?=\s|$)/g, "moc-wrapper")
+        .replace(/\/[^\s"[\]]+\.motoko\/bin\/moc/g, "moc-wrapper"));
+};
+export const cliSnapshot = async (args, options, exitCode) => {
+    const result = await cli(args, options);
+    expect({
+        command: result.command,
+        exitCode: result.exitCode,
+        timedOut: result.timedOut,
+        stdio: Boolean(result.stdout || result.stderr),
+    }).toEqual({
+        command: result.command,
+        exitCode,
+        timedOut: false,
+        stdio: true,
+    });
+    expect({
+        exitCode: result.exitCode,
+        stdout: normalizePaths(result.stdout),
+        stderr: normalizePaths(result.stderr),
+    }).toMatchSnapshot();
+    return result;
+};

package/dist/tests/lint.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/lint.test.js

@@ -0,0 +1,15 @@
+import { describe, test } from "@jest/globals";
+import path from "path";
+import { cliSnapshot } from "./helpers";
+describe("lint", () => {
+    test("ok", async () => {
+        const cwd = path.join(import.meta.dirname, "lint");
+        await cliSnapshot(["lint", "Ok", "--verbose"], { cwd }, 0);
+    });
+    test("error", async () => {
+        const cwd = path.join(import.meta.dirname, "lint");
+        await cliSnapshot(["lint", "--verbose"], { cwd }, 1);
+        await cliSnapshot(["lint", "NoBoolSwitch", "--verbose"], { cwd }, 1);
+        await cliSnapshot(["lint", "DoesNotExist"], { cwd }, 1);
+    });
+});

package/dist/tests/toolchain.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/toolchain.test.js

@@ -0,0 +1,11 @@
+import { describe, expect, test } from "@jest/globals";
+import path from "path";
+import { cli } from "./helpers";
+describe("toolchain", () => {
+    test("file URI", async () => {
+        const cwd = path.join(import.meta.dirname, "toolchain");
+        const result = await cli(["toolchain", "bin", "moc"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout.trim()).toBe("./mock");
+    });
+});

package/dist/types.d.ts

@@ -24,11 +24,15 @@ export type Config = {
         outputDir?: string;
         args?: string[];
     };
+    lint?: {
+        args?: string[];
+    };
 };
 export type CanisterConfig = {
     main: string;
     args?: string[];
     candid?: string;
+    initArg?: string;
 };
 export type Dependencies = Record<string, Dependency>;
 export type Dependency = {
@@ -41,8 +45,9 @@ export type Toolchain = {
     moc?: string;
     wasmtime?: string;
     "pocket-ic"?: string;
+    lintoko?: string;
 };
-export type Tool = "moc" | "wasmtime" | "pocket-ic";
+export type Tool = "moc" | "wasmtime" | "pocket-ic" | "lintoko";
 export type Requirements = {
     moc?: string;
 };

package/dist/wasm/pkg/nodejs/wasm.d.ts

@@ -1,3 +1,6 @@
 /* tslint:disable */
 /* eslint-disable */
+
+export function add_custom_sections(bytes: Uint8Array, custom_sections: any): Uint8Array;
+
 export function is_candid_compatible(new_interface: string, original_interface: string): boolean;