ic-mops 1.11.1 → 2.0.0

package/dist/resolve-packages.js

@@ -1,13 +1,13 @@
-import process from 'node:process';
-import path from 'node:path';
-import { existsSync } from 'node:fs';
-import chalk from 'chalk';
-import { checkConfigFile, getRootDir, parseGithubURL, readConfig } from './mops.js';
-import { readVesselConfig } from './vessel.js';
-import { getDepCacheDir, getDepCacheName } from './cache.js';
-import { getPackageId } from './helpers/get-package-id.js';
-import { checkLockFileLight, readLockFile } from './integrity.js';
-export async function resolvePackages({ conflicts = 'ignore' } = {}) {
+import process from "node:process";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import chalk from "chalk";
+import { checkConfigFile, getRootDir, parseGithubURL, readConfig, } from "./mops.js";
+import { readVesselConfig } from "./vessel.js";
+import { getDepCacheDir, getDepCacheName } from "./cache.js";
+import { getPackageId } from "./helpers/get-package-id.js";
+import { checkLockFileLight, readLockFile } from "./integrity.js";
+export async function resolvePackages({ conflicts = "ignore", } = {}) {
     if (!checkConfigFile()) {
         return {};
     }
@@ -20,9 +20,9 @@ export async function resolvePackages({ conflicts = 'ignore' } = {}) {
     let rootDir = getRootDir();
     let packages = {};
     let versions = {};
-    let compareVersions = (a = '0.0.0', b = '0.0.0') => {
-        let ap = a.split('.').map((x) => parseInt(x));
-        let bp = b.split('.').map((x) => parseInt(x));
+    let compareVersions = (a = "0.0.0", b = "0.0.0") => {
+        let ap = a.split(".").map((x) => parseInt(x));
+        let bp = b.split(".").map((x) => parseInt(x));
         if (ap[0] - bp[0]) {
             return Math.sign(ap[0] - bp[0]);
         }
@@ -51,16 +51,21 @@ export async function resolvePackages({ conflicts = 'ignore' } = {}) {
     let collectDeps = async (config, configDir, isRoot = false) => {
         let allDeps = [...Object.values(config.dependencies || {})];
         if (isRoot) {
-            allDeps = [...allDeps, ...Object.values(config['dev-dependencies'] || {})];
+            allDeps = [
+                ...allDeps,
+                ...Object.values(config["dev-dependencies"] || {}),
+            ];
         }
         for (const pkgDetails of allDeps) {
             const { name, repo, version } = pkgDetails;
             // take root dep version or bigger one
-            if (isRoot
-                || !packages[name]
-                || !packages[name]?.isRoot
-                    && (repo && packages[name]?.repo && compareGitVersions(packages[name]?.repo || '', repo) === -1
-                        || compareVersions(packages[name]?.version, version) === -1)) {
+            if (isRoot ||
+                !packages[name] ||
+                (!packages[name]?.isRoot &&
+                    ((repo &&
+                        packages[name]?.repo &&
+                        compareGitVersions(packages[name]?.repo || "", repo) === -1) ||
+                        compareVersions(packages[name]?.version, version) === -1))) {
                 let temp = {
                     ...pkgDetails,
                     isRoot,
@@ -72,22 +77,27 @@ export async function resolvePackages({ conflicts = 'ignore' } = {}) {
                 }
             }
             let nestedConfig;
-            let localNestedDir = '';
+            let localNestedDir = "";
             // read nested config
             if (repo) {
                 let cacheDir = getDepCacheName(name, repo);
-                nestedConfig = await readVesselConfig(getDepCacheDir(cacheDir), { silent: true }) || {};
+                nestedConfig =
+                    (await readVesselConfig(getDepCacheDir(cacheDir), {
+                        silent: true,
+                    })) || {};
             }
             else if (pkgDetails.path) {
-                localNestedDir = path.resolve(configDir, pkgDetails.path).replaceAll('{MOPS_ENV}', process.env.MOPS_ENV || 'local');
-                let mopsToml = path.join(localNestedDir, 'mops.toml');
+                localNestedDir = path
+                    .resolve(configDir, pkgDetails.path)
+                    .replaceAll("{MOPS_ENV}", process.env.MOPS_ENV || "local");
+                let mopsToml = path.join(localNestedDir, "mops.toml");
                 if (existsSync(mopsToml)) {
                     nestedConfig = readConfig(mopsToml);
                 }
             }
             else if (version) {
                 let cacheDir = getDepCacheName(name, version);
-                nestedConfig = readConfig(getDepCacheDir(cacheDir) + '/mops.toml');
+                nestedConfig = readConfig(getDepCacheDir(cacheDir) + "/mops.toml");
             }
             // collect nested deps
             if (nestedConfig) {
@@ -96,9 +106,9 @@ export async function resolvePackages({ conflicts = 'ignore' } = {}) {
             if (!versions[name]) {
                 versions[name] = [];
             }
-            let parentPkgId = isRoot ? '<root>' : '';
-            if ('package' in config) {
-                parentPkgId = getPackageId(config.package?.name || '', config.package?.version || '');
+            let parentPkgId = isRoot ? "<root>" : "";
+            if ("package" in config) {
+                parentPkgId = getPackageId(config.package?.name || "", config.package?.version || "");
             }
             if (repo) {
                 const { branch } = parseGithubURL(repo);
@@ -121,25 +131,30 @@ export async function resolvePackages({ conflicts = 'ignore' } = {}) {
     await collectDeps(config, rootDir, true);
     // show conflicts
     let hasConflicts = false;
-    if (conflicts !== 'ignore') {
+    if (conflicts !== "ignore") {
         for (let [dep, vers] of Object.entries(versions)) {
-            let majors = new Set(vers.filter(x => x.isMopsPackage).map(x => x.version.split('.')[0]));
+            let majors = new Set(vers.filter((x) => x.isMopsPackage).map((x) => x.version.split(".")[0]));
             if (majors.size > 1) {
-                console.error(chalk.reset('') + chalk.redBright(conflicts === 'error' ? 'Error!' : 'Warning!'), `Conflicting versions of dependency "${dep}"`);
+                console.error(chalk.reset("") +
+                    chalk.redBright(conflicts === "error" ? "Error!" : "Warning!"), `Conflicting versions of dependency "${dep}"`);
                 for (let { version, dependencyOf } of vers.reverse()) {
-                    console.error(chalk.reset('  ') + `${dep} ${chalk.bold.red(version.split('.')[0])}.${version.split('.').slice(1).join('.')} is dependency of ${chalk.bold(dependencyOf)}`);
+                    console.error(chalk.reset("  ") +
+                        `${dep} ${chalk.bold.red(version.split(".")[0])}.${version.split(".").slice(1).join(".")} is dependency of ${chalk.bold(dependencyOf)}`);
                 }
                 hasConflicts = true;
             }
         }
     }
-    if (conflicts === 'error' && hasConflicts) {
+    if (conflicts === "error" && hasConflicts) {
         process.exit(1);
     }
-    return Object.fromEntries(Object.entries(packages).map(([name, pkg]) => {
+    return Object.fromEntries(Object.entries(packages)
+        .map(([name, pkg]) => {
         let version;
         if (pkg.path) {
-            version = path.resolve(rootDir, pkg.path).replaceAll('{MOPS_ENV}', process.env.MOPS_ENV || 'local');
+            version = path
+                .resolve(rootDir, pkg.path)
+                .replaceAll("{MOPS_ENV}", process.env.MOPS_ENV || "local");
         }
         else if (pkg.repo) {
             version = pkg.repo;
@@ -148,8 +163,9 @@ export async function resolvePackages({ conflicts = 'ignore' } = {}) {
             version = pkg.version;
         }
         else {
-            return [name, ''];
+            return [name, ""];
         }
         return [name, version];
-    }).filter(([, version]) => version !== ''));
+    })
+        .filter(([, version]) => version !== ""));
 }

package/dist/templates/mops-publish.yml

@@ -9,9 +9,9 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v4
-      - uses: ZenVoich/setup-mops@v1
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+      - uses: dfinity/setup-mops@v1
         with:
           # Make sure you set the MOPS_IDENTITY_PEM secret in your repository settings https://docs.github.com/en/actions/security-guides/using-secrets-in-github-actions#creating-secrets-for-a-repository
           identity-pem: ${{ secrets.MOPS_IDENTITY_PEM }}
-      - run: mops publish
+      - run: mops publish

package/dist/templates/mops-test.yml

@@ -12,8 +12,8 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v4
-      - uses: ZenVoich/setup-mops@v1
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+      - uses: dfinity/setup-mops@v1
         with:
           mops-version: 1
 
@@ -21,4 +21,4 @@ jobs:
         run: mops install
 
       - name: run tests
-        run: mops test
+        run: mops test

package/dist/templates/src/lib.mo

@@ -1,15 +1,15 @@
 module {
-	// This comment will not be included in the documentation
-	// Use triple slash for documentation
+  // This comment will not be included in the documentation
+  // Use triple slash for documentation
 
-	/// Add two natural numbers
-	///
-	/// Example:
-	/// ```motoko
-	/// assert add(1, 2) == 3;
-	/// assert add(7, 3) == 10;
-	/// ```
-	public func add(x : Nat, y : Nat) : Nat {
-		return x + y;
-	};
-};
+  /// Add two natural numbers
+  ///
+  /// Example:
+  /// ```motoko
+  /// assert add(1, 2) == 3;
+  /// assert add(7, 3) == 10;
+  /// ```
+  public func add(x : Nat, y : Nat) : Nat {
+    return x + y;
+  };
+};

package/dist/templates/test/lib.test.mo

@@ -1,4 +1,4 @@
-import {add} "../src";
+import { add } "../src";
 
 assert add(1, 2) == 3;
-assert add(3, 22) == 25;
+assert add(3, 22) == 25;

package/dist/templates.js

@@ -1,4 +1,4 @@
-import fs from 'node:fs';
+import fs from "node:fs";
 export function copyTemplateFileSync(file, dest) {
     fs.copyFileSync(new URL(`./templates/${file}`, import.meta.url), dest);
 }

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

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

package/dist/tests/cli.test.js

@@ -0,0 +1,63 @@
+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 () => {
+        expect((await cli(["--version"])).stdout).toMatch(/CLI \d+\.\d+\.\d+/);
+    });
+    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/types.d.ts

@@ -16,9 +16,19 @@ export type Config = {
         donation?: string;
     };
     dependencies?: Dependencies;
-    'dev-dependencies'?: Dependencies;
+    "dev-dependencies"?: Dependencies;
     toolchain?: Toolchain;
     requirements?: Requirements;
+    canisters?: Record<string, string | CanisterConfig>;
+    build?: {
+        outputDir?: string;
+        args?: string[];
+    };
+};
+export type CanisterConfig = {
+    main: string;
+    args?: string[];
+    candid?: string;
 };
 export type Dependencies = Record<string, Dependency>;
 export type Dependency = {
@@ -30,10 +40,10 @@ export type Dependency = {
 export type Toolchain = {
     moc?: string;
     wasmtime?: string;
-    'pocket-ic'?: string;
+    "pocket-ic"?: string;
 };
-export type Tool = 'moc' | 'wasmtime' | 'pocket-ic';
+export type Tool = "moc" | "wasmtime" | "pocket-ic";
 export type Requirements = {
     moc?: string;
 };
-export type TestMode = 'interpreter' | 'wasi' | 'replica';
+export type TestMode = "interpreter" | "wasi" | "replica";

package/dist/vessel.d.ts

@@ -1,6 +1,6 @@
 export type VesselConfig = {
     dependencies: VesselDependencies;
-    'dev-dependencies': VesselDependencies;
+    "dev-dependencies": VesselDependencies;
 };
 export type VesselDependencies = Array<{
     name: string;
@@ -13,7 +13,7 @@ export declare const readVesselConfig: (dir: string, { cache, silent }?: {
     silent?: boolean | undefined;
 }) => Promise<VesselConfig | null>;
 export declare const downloadFromGithub: (repo: string, dest: string, onProgress: any) => Promise<unknown>;
-export declare const installFromGithub: (name: string, repo: string, { verbose, dep, silent, ignoreTransitive }?: {
+export declare const installFromGithub: (name: string, repo: string, { verbose, dep, silent, ignoreTransitive, }?: {
     verbose?: boolean | undefined;
     dep?: boolean | undefined;
     silent?: boolean | undefined;

package/dist/vessel.js

@@ -1,24 +1,28 @@
-import process from 'node:process';
-import { existsSync, mkdirSync, createWriteStream, readFileSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import { pipeline } from 'node:stream';
-import { deleteSync } from 'del';
-import { execaCommand } from 'execa';
-import chalk from 'chalk';
-import { createLogUpdate } from 'log-update';
-import got from 'got';
-import decompress from 'decompress';
-import { parseGithubURL, progressBar } from './mops.js';
-import { getDepCacheDir, getGithubDepCacheName, isDepCached } from './cache.js';
+import process from "node:process";
+import { existsSync, mkdirSync, createWriteStream, readFileSync, writeFileSync, } from "node:fs";
+import path from "node:path";
+import { pipeline } from "node:stream";
+import { deleteSync } from "del";
+import { execaCommand } from "execa";
+import chalk from "chalk";
+import { createLogUpdate } from "log-update";
+import got from "got";
+import decompress from "decompress";
+import { parseGithubURL, progressBar } from "./mops.js";
+import { getDepCacheDir, getGithubDepCacheName, isDepCached } from "./cache.js";
 const dhallFileToJson = async (filePath, silent) => {
     if (existsSync(filePath)) {
         let cwd = new URL(path.dirname(import.meta.url)).pathname;
         let res;
         try {
-            res = await execaCommand(`dhall-to-json --file ${filePath}`, { preferLocal: true, cwd });
+            res = await execaCommand(`dhall-to-json --file ${filePath}`, {
+                preferLocal: true,
+                cwd,
+            });
         }
         catch (err) {
-            silent || console.error('dhall-to-json error:', err.message?.split('Message:')[0]);
+            silent ||
+                console.error("dhall-to-json error:", err.message?.split("Message:")[0]);
             return null;
         }
         if (res.exitCode === 0) {
@@ -31,14 +35,14 @@ const dhallFileToJson = async (filePath, silent) => {
     return null;
 };
 export const readVesselConfig = async (dir, { cache = true, silent = false } = {}) => {
-    const cachedFile = (dir || process.cwd()) + '/vessel.json';
+    const cachedFile = (dir || process.cwd()) + "/vessel.json";
     if (existsSync(cachedFile)) {
         let cachedConfig = readFileSync(cachedFile).toString();
         return JSON.parse(cachedConfig);
     }
     const [vessel, packageSetArray] = await Promise.all([
-        dhallFileToJson((dir || process.cwd()) + '/vessel.dhall', silent),
-        dhallFileToJson((dir || process.cwd()) + '/package-set.dhall', silent),
+        dhallFileToJson((dir || process.cwd()) + "/vessel.dhall", silent),
+        dhallFileToJson((dir || process.cwd()) + "/package-set.dhall", silent),
     ]);
     if (!vessel || !packageSetArray) {
         return null;
@@ -50,12 +54,12 @@ export const readVesselConfig = async (dir, { cache = true, silent = false } = {
     }
     let config = {
         dependencies: vessel.dependencies.map((name) => {
-            return { name, repo: repos[name], version: '' };
+            return { name, repo: repos[name], version: "" };
         }),
-        'dev-dependencies': [],
+        "dev-dependencies": [],
     };
     if (cache === true) {
-        writeFileSync(cachedFile, JSON.stringify(config), 'utf-8');
+        writeFileSync(cachedFile, JSON.stringify(config), "utf-8");
     }
     return config;
 };
@@ -64,25 +68,25 @@ export const downloadFromGithub = async (repo, dest, onProgress) => {
     const zipFile = `https://github.com/${org}/${gitName}/archive/${commitHash || branch}.zip`;
     const readStream = got.stream(zipFile);
     const promise = new Promise((resolve, reject) => {
-        readStream.on('error', (err) => {
+        readStream.on("error", (err) => {
             console.error(chalk.red(`Error: failed to download from GitHub: ${zipFile}`));
             console.error(err.message);
             reject(err);
         });
-        readStream.on('downloadProgress', ({ transferred, total }) => {
-            onProgress?.(transferred, total || 2 * (1024 ** 2));
+        readStream.on("downloadProgress", ({ transferred, total }) => {
+            onProgress?.(transferred, total || 2 * 1024 ** 2);
         });
-        readStream.on('response', (response) => {
+        readStream.on("response", (response) => {
             if (response.headers.age > 3600) {
-                console.error(chalk.red('Error: ') + 'Failure - response too old');
+                console.error(chalk.red("Error: ") + "Failure - response too old");
                 readStream.destroy(); // Destroy the stream to prevent hanging resources.
                 reject();
                 return;
             }
             // Prevent `onError` being called twice.
-            readStream.off('error', reject);
-            const tmpDir = path.resolve(process.cwd(), '.mops/_tmp/');
-            const tmpFile = path.resolve(tmpDir, `${gitName}@${(commitHash || branch).replaceAll('/', '___')}.zip`);
+            readStream.off("error", reject);
+            const tmpDir = path.resolve(process.cwd(), ".mops/_tmp/");
+            const tmpFile = path.resolve(tmpDir, `${gitName}@${(commitHash || branch).replaceAll("/", "___")}.zip`);
             try {
                 mkdirSync(tmpDir, { recursive: true });
                 pipeline(readStream, createWriteStream(tmpFile), (err) => {
@@ -95,13 +99,15 @@ export const downloadFromGithub = async (repo, dest, onProgress) => {
                             extract: true,
                             strip: 1,
                             headers: {
-                                accept: 'application/zip',
+                                accept: "application/zip",
                             },
                         };
-                        decompress(tmpFile, dest, options).then((unzippedFiles) => {
+                        decompress(tmpFile, dest, options)
+                            .then((unzippedFiles) => {
                             deleteSync([tmpDir]);
                             resolve(unzippedFiles);
-                        }).catch(err => {
+                        })
+                            .catch((err) => {
                             deleteSync([tmpDir]);
                             reject(err);
                         });
@@ -116,16 +122,17 @@ export const downloadFromGithub = async (repo, dest, onProgress) => {
     });
     return promise;
 };
-export const installFromGithub = async (name, repo, { verbose = false, dep = false, silent = false, ignoreTransitive = false } = {}) => {
+export const installFromGithub = async (name, repo, { verbose = false, dep = false, silent = false, ignoreTransitive = false, } = {}) => {
     let cacheName = getGithubDepCacheName(name, repo);
     let cacheDir = getDepCacheDir(cacheName);
     let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
     if (isDepCached(cacheName)) {
-        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} (cache)`);
+        silent || logUpdate(`${dep ? "Dependency" : "Installing"} ${repo} (cache)`);
     }
     else {
         let progress = (step, total) => {
-            silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} ${progressBar(step, total)}`);
+            silent ||
+                logUpdate(`${dep ? "Dependency" : "Installing"} ${repo} ${progressBar(step, total)}`);
         };
         progress(0, 1024 * 500);
         mkdirSync(cacheDir, { recursive: true });

package/dist/wasm/pkg/bundler/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "wasm",
+  "type": "module",
+  "collaborators": [
+    "Ryan Vandersmith <ryan.vandersmith@dfinity.org>"
+  ],
+  "version": "0.1.0",
+  "files": [
+    "wasm_bg.wasm",
+    "wasm.js",
+    "wasm_bg.js",
+    "wasm.d.ts"
+  ],
+  "main": "wasm.js",
+  "types": "wasm.d.ts",
+  "sideEffects": [
+    "./wasm.js",
+    "./snippets/*"
+  ]
+}

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

@@ -0,0 +1,3 @@
+/* tslint:disable */
+/* eslint-disable */
+export function is_candid_compatible(new_interface: string, original_interface: string): boolean;

package/dist/wasm/pkg/bundler/wasm.js

@@ -0,0 +1,5 @@
+import * as wasm from "./wasm_bg.wasm";
+export * from "./wasm_bg.js";
+import { __wbg_set_wasm } from "./wasm_bg.js";
+__wbg_set_wasm(wasm);
+wasm.__wbindgen_start();

package/dist/wasm/pkg/bundler/wasm_bg.js

@@ -0,0 +1,93 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+/**
+ * @param {string} new_interface
+ * @param {string} original_interface
+ * @returns {boolean}
+ */
+export function is_candid_compatible(new_interface, original_interface) {
+    const ptr0 = passStringToWasm0(new_interface, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(original_interface, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.is_candid_compatible(ptr0, len0, ptr1, len1);
+    return ret !== 0;
+}
+
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_externrefs;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+    ;
+};
+

package/dist/wasm/pkg/bundler/wasm_bg.wasm.d.ts

@@ -0,0 +1,8 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const is_candid_compatible: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_start: () => void;