@acala-network/chopsticks-testing 0.9.1-1 → 0.9.1-3

package/dist/esm/check.js

@@ -1,58 +1,44 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Checker_instances, _Checker_value, _Checker_pipeline, _Checker_format, _Checker_message, _Checker_redactOptions, _Checker_redact;
 import { expect } from 'vitest';
-const processCodecOrArray = (codec, fn) => Array.isArray(codec) ? codec.map(fn) : fn(codec);
-const toHuman = (codec) => processCodecOrArray(codec, (c) => c?.toHuman?.() ?? c);
-const toHex = (codec) => processCodecOrArray(codec, (c) => c?.toHex?.() ?? c);
-const toJson = (codec) => processCodecOrArray(codec, (c) => c?.toJSON?.() ?? c);
+const processCodecOrArray = (codec, fn)=>Array.isArray(codec) ? codec.map(fn) : fn(codec);
+const toHuman = (codec)=>processCodecOrArray(codec, (c)=>c?.toHuman?.() ?? c);
+const toHex = (codec)=>processCodecOrArray(codec, (c)=>c?.toHex?.() ?? c);
+const toJson = (codec)=>processCodecOrArray(codec, (c)=>c?.toJSON?.() ?? c);
 export class Checker {
-    constructor(value, message) {
-        _Checker_instances.add(this);
-        _Checker_value.set(this, void 0);
-        _Checker_pipeline.set(this, []);
-        _Checker_format.set(this, 'json');
-        _Checker_message.set(this, void 0);
-        _Checker_redactOptions.set(this, void 0);
-        __classPrivateFieldSet(this, _Checker_value, value, "f");
-        __classPrivateFieldSet(this, _Checker_message, message, "f");
+    #value;
+    #pipeline = [];
+    #format = 'json';
+    #message;
+    #redactOptions;
+    constructor(value, message){
+        this.#value = value;
+        this.#message = message;
     }
     toHuman() {
-        __classPrivateFieldSet(this, _Checker_format, 'human', "f");
+        this.#format = 'human';
         return this;
     }
     toHex() {
-        __classPrivateFieldSet(this, _Checker_format, 'hex', "f");
+        this.#format = 'hex';
         return this;
     }
     toJson() {
-        __classPrivateFieldSet(this, _Checker_format, 'json', "f");
+        this.#format = 'json';
         return this;
     }
     message(message) {
-        __classPrivateFieldSet(this, _Checker_message, message, "f");
+        this.#message = message;
         return this;
     }
     filterEvents(...filters) {
         this.toHuman();
-        __classPrivateFieldGet(this, _Checker_pipeline, "f").push((value) => {
-            let data = value.map(({ event: { index: _, ...event } }) => event);
+        this.#pipeline.push((value)=>{
+            let data = value.map(({ event: { index: _, ...event } })=>event);
             if (filters.length > 0) {
-                data = data.filter((evt) => {
-                    return filters.some((filter) => {
+                data = data.filter((evt)=>{
+                    return filters.some((filter)=>{
                         if (typeof filter === 'string') {
                             return evt.section === filter;
-                        }
-                        else if ('method' in filter) {
+                        } else if ('method' in filter) {
                             const { section, method } = filter;
                             return evt.section === section && evt.method === method;
                         }
@@ -63,23 +49,86 @@ export class Checker {
         });
         return this;
     }
-    redact(options = { number: 2, hash: true }) {
-        __classPrivateFieldSet(this, _Checker_redactOptions, {
-            ...__classPrivateFieldGet(this, _Checker_redactOptions, "f"),
-            ...options,
-        }, "f");
+    redact(options = {
+        number: 2,
+        hash: true
+    }) {
+        this.#redactOptions = {
+            ...this.#redactOptions,
+            ...options
+        };
         return this;
     }
+    #redact(value) {
+        if (!this.#redactOptions) {
+            return value;
+        }
+        const redactNumber = this.#redactOptions.number === true || typeof this.#redactOptions.number === 'number';
+        const precision = redactNumber ? typeof this.#redactOptions.number === 'number' ? this.#redactOptions.number : 0 : 0;
+        const redactHash = this.#redactOptions.hash === true;
+        const redactHex = this.#redactOptions.hex === true;
+        const redactAddress = this.#redactOptions.address === true;
+        const processNumber = (value)=>{
+            if (precision > 0) {
+                const rounded = parseFloat(value.toPrecision(precision));
+                if (rounded === value) {
+                    return rounded;
+                }
+                return `(rounded ${rounded})`;
+            }
+            return '(number)';
+        };
+        const process = (obj)=>{
+            if (obj == null) {
+                return obj;
+            }
+            if (Array.isArray(obj)) {
+                return obj.map(process);
+            }
+            if (redactNumber && typeof obj === 'number') {
+                return processNumber(obj);
+            }
+            if (typeof obj === 'string') {
+                if (redactNumber && obj.match(/0x000000[0-9a-f]{26}/)) {
+                    // this is very likely u128 encoded in hex
+                    const num = parseInt(obj);
+                    return processNumber(num);
+                }
+                if (redactHash && obj.match(/0x[0-9a-f]{64}/)) {
+                    return '(hash)';
+                }
+                if (redactHex && obj.match(/0x[0-9a-f]+/)) {
+                    return '(hex)';
+                }
+                if (redactAddress && obj.match(/^[1-9A-HJ-NP-Za-km-z]{46,48}$/)) {
+                    return '(address)';
+                }
+                if (redactNumber && obj.match(/^-?[\d,]+$/)) {
+                    const num = parseInt(obj.replace(/,/g, ''));
+                    return processNumber(num);
+                }
+                return obj;
+            }
+            if (typeof obj === 'object') {
+                return Object.fromEntries(Object.entries(obj).map(([k, v])=>[
+                        k,
+                        process(v)
+                    ]));
+            }
+            return obj;
+        };
+        return process(value);
+    }
     map(fn) {
-        __classPrivateFieldGet(this, _Checker_pipeline, "f").push(fn);
+        this.#pipeline.push(fn);
         return this;
     }
     pipe(fn) {
         return fn ? fn(this) : this;
     }
     async value() {
-        let value = await __classPrivateFieldGet(this, _Checker_value, "f");
-        switch (__classPrivateFieldGet(this, _Checker_format, "f")) {
+        let value = await this.#value;
+        switch(this.#format){
             case 'human':
                 value = toHuman(value);
                 break;
@@ -90,78 +139,17 @@ export class Checker {
                 value = toJson(value);
                 break;
         }
-        for (const fn of __classPrivateFieldGet(this, _Checker_pipeline, "f")) {
+        for (const fn of this.#pipeline){
             value = await fn(value);
         }
-        value = __classPrivateFieldGet(this, _Checker_instances, "m", _Checker_redact).call(this, value);
+        value = this.#redact(value);
         return value;
     }
     async toMatchSnapshot(msg) {
-        return expect(await this.value()).toMatchSnapshot(msg ?? __classPrivateFieldGet(this, _Checker_message, "f"));
+        return expect(await this.value()).toMatchSnapshot(msg ?? this.#message);
     }
 }
-_Checker_value = new WeakMap(), _Checker_pipeline = new WeakMap(), _Checker_format = new WeakMap(), _Checker_message = new WeakMap(), _Checker_redactOptions = new WeakMap(), _Checker_instances = new WeakSet(), _Checker_redact = function _Checker_redact(value) {
-    if (!__classPrivateFieldGet(this, _Checker_redactOptions, "f")) {
-        return value;
-    }
-    const redactNumber = __classPrivateFieldGet(this, _Checker_redactOptions, "f").number === true || typeof __classPrivateFieldGet(this, _Checker_redactOptions, "f").number === 'number';
-    const precision = redactNumber
-        ? typeof __classPrivateFieldGet(this, _Checker_redactOptions, "f").number === 'number'
-            ? __classPrivateFieldGet(this, _Checker_redactOptions, "f").number
-            : 0
-        : 0;
-    const redactHash = __classPrivateFieldGet(this, _Checker_redactOptions, "f").hash === true;
-    const redactHex = __classPrivateFieldGet(this, _Checker_redactOptions, "f").hex === true;
-    const redactAddress = __classPrivateFieldGet(this, _Checker_redactOptions, "f").address === true;
-    const processNumber = (value) => {
-        if (precision > 0) {
-            const rounded = parseFloat(value.toPrecision(precision));
-            if (rounded === value) {
-                return rounded;
-            }
-            return `(rounded ${rounded})`;
-        }
-        return '(number)';
-    };
-    const process = (obj) => {
-        if (obj == null) {
-            return obj;
-        }
-        if (Array.isArray(obj)) {
-            return obj.map(process);
-        }
-        if (redactNumber && typeof obj === 'number') {
-            return processNumber(obj);
-        }
-        if (typeof obj === 'string') {
-            if (redactNumber && obj.match(/0x000000[0-9a-f]{26}/)) {
-                // this is very likely u128 encoded in hex
-                const num = parseInt(obj);
-                return processNumber(num);
-            }
-            if (redactHash && obj.match(/0x[0-9a-f]{64}/)) {
-                return '(hash)';
-            }
-            if (redactHex && obj.match(/0x[0-9a-f]+/)) {
-                return '(hex)';
-            }
-            if (redactAddress && obj.match(/^[1-9A-HJ-NP-Za-km-z]{46,48}$/)) {
-                return '(address)';
-            }
-            if (redactNumber && obj.match(/^-?[\d,]+$/)) {
-                const num = parseInt(obj.replace(/,/g, ''));
-                return processNumber(num);
-            }
-            return obj;
-        }
-        if (typeof obj === 'object') {
-            return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, process(v)]));
-        }
-        return obj;
-    };
-    return process(value);
-};
-export const check = (value, msg) => {
+export const check = (value, msg)=>{
     if (value instanceof Checker) {
         if (msg) {
             return value.message(msg);
@@ -170,14 +158,10 @@ export const check = (value, msg) => {
     }
     return new Checker(value, msg);
 };
-export const checkEvents = ({ events }, ...filters) => check(events, 'events')
-    .filterEvents(...filters)
-    .redact();
-export const checkSystemEvents = ({ api }, ...filters) => check(api.query.system.events(), 'system events')
-    .filterEvents(...filters)
-    .redact();
-export const checkUmp = ({ api }) => check(api.query.parachainSystem.upwardMessages(), 'ump').map((value) => api.createType('Vec<XcmVersionedXcm>', value).toJSON());
-export const checkHrmp = ({ api }) => check(api.query.parachainSystem.hrmpOutboundMessages(), 'hrmp').map((value) => value.map(({ recipient, data }) => ({
-    data: api.createType('(XcmpMessageFormat, XcmVersionedXcm)', data),
-    recipient,
-})));
+export const checkEvents = ({ events }, ...filters)=>check(events, 'events').filterEvents(...filters).redact();
+export const checkSystemEvents = ({ api }, ...filters)=>check(api.query.system.events(), 'system events').filterEvents(...filters).redact();
+export const checkUmp = ({ api })=>check(api.query.parachainSystem.upwardMessages(), 'ump').map((value)=>api.createType('Vec<XcmVersionedXcm>', value).toJSON());
+export const checkHrmp = ({ api })=>check(api.query.parachainSystem.hrmpOutboundMessages(), 'hrmp').map((value)=>value.map(({ recipient, data })=>({
+                data: api.createType('(XcmpMessageFormat, XcmVersionedXcm)', data),
+                recipient
+            })));

package/dist/esm/index.js

@@ -1,10 +1,10 @@
 import { ApiPromise, WsProvider } from '@polkadot/api';
-import { BuildBlockMode, connectParachains, connectVertical, fetchConfig, setupWithServer, } from '@acala-network/chopsticks';
+import { BuildBlockMode, connectParachains, connectVertical, fetchConfig, setupWithServer } from '@acala-network/chopsticks';
 import { Keyring, createTestKeyring } from '@polkadot/keyring';
 import { expect } from 'vitest';
 export * from './check';
 export * from './signFake';
-export const createConfig = ({ endpoint, blockNumber, blockHash, wasmOverride, db, timeout, port, maxMemoryBlockCount, resume, }) => {
+export const createConfig = ({ endpoint, blockNumber, blockHash, wasmOverride, db, timeout, port, maxMemoryBlockCount, resume })=>{
     // random port if not specified
     port = port ?? Math.floor(Math.random() * 10000) + 10000;
     const config = {
@@ -17,14 +17,14 @@ export const createConfig = ({ endpoint, blockNumber, blockHash, wasmOverride, d
         db,
         'wasm-override': wasmOverride,
         timeout,
-        resume: resume ?? false,
+        resume: resume ?? false
     };
     return config;
 };
-export const setupContext = async (option) => {
+export const setupContext = async (option)=>{
     return setupContextWithConfig(createConfig(option));
 };
-export const setupContextWithConfig = async ({ timeout, ...config }) => {
+export const setupContextWithConfig = async ({ timeout, ...config })=>{
     const { chain, listenPort, close } = await setupWithServer(config);
     const url = `ws://localhost:${listenPort}`;
     const ws = new WsProvider(url, undefined, undefined, timeout);
@@ -33,9 +33,9 @@ export const setupContextWithConfig = async ({ timeout, ...config }) => {
         signedExtensions: {
             SetEvmOrigin: {
                 extrinsic: {},
-                payload: {},
-            },
-        },
+                payload: {}
+            }
+        }
     });
     await api.isReady;
     return {
@@ -44,78 +44,95 @@ export const setupContextWithConfig = async ({ timeout, ...config }) => {
         ws,
         api,
         dev: {
-            newBlock: (param) => {
-                return ws.send('dev_newBlock', [param]);
-            },
-            setStorage: (values, blockHash) => {
-                return ws.send('dev_setStorage', [values, blockHash]);
+            newBlock: (param)=>{
+                return ws.send('dev_newBlock', [
+                    param
+                ]);
             },
-            timeTravel: (date) => {
-                return ws.send('dev_timeTravel', [date]);
+            setStorage: (values, blockHash)=>{
+                return ws.send('dev_setStorage', [
+                    values,
+                    blockHash
+                ]);
             },
-            setHead: (hashOrNumber) => {
-                return ws.send('dev_setHead', [hashOrNumber]);
+            timeTravel: (date)=>{
+                return ws.send('dev_timeTravel', [
+                    date
+                ]);
             },
+            setHead: (hashOrNumber)=>{
+                return ws.send('dev_setHead', [
+                    hashOrNumber
+                ]);
+            }
         },
-        async teardown() {
+        async teardown () {
             await api.disconnect();
             await close();
         },
-        async pause() {
-            await ws.send('dev_setBlockBuildMode', [BuildBlockMode.Instant]);
+        async pause () {
+            await ws.send('dev_setBlockBuildMode', [
+                BuildBlockMode.Instant
+            ]);
             // log a bit later to ensure the message is visible
-            setTimeout(() => console.log(`Test paused. Polkadot.js apps URL: https://polkadot.js.org/apps/?rpc=${url}`), 100);
-            return new Promise((_resolve) => { }); // wait forever
-        },
+            setTimeout(()=>console.log(`Test paused. Polkadot.js apps URL: https://polkadot.js.org/apps/?rpc=${url}`), 100);
+            return new Promise((_resolve)=>{}) // wait forever
+            ;
+        }
     };
 };
-export const setupNetworks = async (networkOptions) => {
+export const setupNetworks = async (networkOptions)=>{
     const ret = {};
     let wasmOverriden = false;
-    for (const [name, options] of Object.entries(networkOptions)) {
-        const config = typeof options === 'string' ? await fetchConfig(options) : options ?? (await fetchConfig(name));
+    for (const [name, options] of Object.entries(networkOptions)){
+        const config = typeof options === 'string' ? await fetchConfig(options) : options ?? await fetchConfig(name);
         ret[name] = await setupContextWithConfig(config);
         wasmOverriden ||= config['wasm-override'] != null;
     }
-    const relaychainName = Object.keys(ret).filter((x) => ['polkadot', 'kusama'].includes(x.toLocaleLowerCase()))[0];
+    const relaychainName = Object.keys(ret).filter((x)=>[
+            'polkadot',
+            'kusama'
+        ].includes(x.toLocaleLowerCase()))[0];
     const { [relaychainName]: relaychain, ...parachains } = ret;
     if (relaychain) {
-        for (const parachain of Object.values(parachains)) {
+        for (const parachain of Object.values(parachains)){
             await connectVertical(relaychain.chain, parachain.chain);
         }
     }
-    const parachainList = Object.values(parachains).map((i) => i.chain);
+    const parachainList = Object.values(parachains).map((i)=>i.chain);
     if (parachainList.length > 0) {
         await connectParachains(parachainList);
     }
     if (wasmOverriden) {
         // trigger runtime upgrade if needed (due to wasm override)
-        for (const chain of Object.values(ret)) {
+        for (const chain of Object.values(ret)){
             await chain.dev.newBlock();
         }
         // handle xcm version message if needed (due to wasm override triggered xcm version upgrade)
-        for (const chain of Object.values(ret)) {
+        for (const chain of Object.values(ret)){
             await chain.dev.newBlock();
         }
     }
     return ret;
 };
-const processCodecOrArray = (codec, fn) => Array.isArray(codec) ? codec.map(fn) : fn(codec);
-const toHuman = (codec) => processCodecOrArray(codec, (c) => c?.toHuman?.() ?? c);
-const toJson = (codec) => processCodecOrArray(codec, (c) => c?.toJSON?.() ?? c);
-const toHex = (codec) => processCodecOrArray(codec, (c) => c?.toHex?.() ?? c);
-export const expectJson = (codec) => {
+const processCodecOrArray = (codec, fn)=>Array.isArray(codec) ? codec.map(fn) : fn(codec);
+const toHuman = (codec)=>processCodecOrArray(codec, (c)=>c?.toHuman?.() ?? c);
+const toJson = (codec)=>processCodecOrArray(codec, (c)=>c?.toJSON?.() ?? c);
+const toHex = (codec)=>processCodecOrArray(codec, (c)=>c?.toHex?.() ?? c);
+export const expectJson = (codec)=>{
     return expect(toJson(codec));
 };
-export const expectHex = (codec) => {
+export const expectHex = (codec)=>{
     return expect(toHex(codec));
 };
-const _matchEvents = async (msg, events, ...filters) => {
-    let data = toHuman(await events).map(({ event: { index: _, ...event } }) => event);
+const _matchEvents = async (msg, events, ...filters)=>{
+    let data = toHuman(await events).map(({ event: { index: _, ...event } })=>event);
     if (filters.length > 0) {
-        const filtersArr = Array.isArray(filters) ? filters : [filters];
-        data = data.filter((evt) => {
-            return filtersArr.some((filter) => {
+        const filtersArr = Array.isArray(filters) ? filters : [
+            filters
+        ];
+        data = data.filter((evt)=>{
+            return filtersArr.some((filter)=>{
                 if (typeof filter === 'string') {
                     return evt.section === filter;
                 }
@@ -126,15 +143,15 @@ const _matchEvents = async (msg, events, ...filters) => {
     }
     return expect(data).toMatchSnapshot(msg);
 };
-export const matchEvents = async (events, ...filters) => {
+export const matchEvents = async (events, ...filters)=>{
     return _matchEvents('events', redact(events), ...filters);
 };
-export const matchSystemEvents = async ({ api }, ...filters) => {
+export const matchSystemEvents = async ({ api }, ...filters)=>{
     await _matchEvents('system events', redact(api.query.system.events()), ...filters);
 };
-export const redact = async (data) => {
+export const redact = async (data)=>{
     const json = toHuman(await data);
-    const process = (obj) => {
+    const process = (obj)=>{
         if (obj == null) {
             return obj;
         }
@@ -163,7 +180,10 @@ export const redact = async (data) => {
             return obj;
         }
         if (typeof obj === 'object') {
-            return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, process(v)]));
+            return Object.fromEntries(Object.entries(obj).map(([k, v])=>[
+                    k,
+                    process(v)
+                ]));
         }
         return obj;
     };
@@ -171,16 +191,16 @@ export const redact = async (data) => {
 };
 export function defer() {
     const deferred = {};
-    deferred.promise = new Promise((resolve, reject) => {
+    deferred.promise = new Promise((resolve, reject)=>{
         deferred.resolve = resolve;
         deferred.reject = reject;
     });
     return deferred;
 }
-export const sendTransaction = async (tx) => {
+export const sendTransaction = async (tx)=>{
     const signed = await tx;
     const deferred = defer();
-    await signed.send((status) => {
+    await signed.send((status)=>{
         console.log('tranaction status: ', status.status.toHuman());
         if (status.isInBlock || status.isFinalized) {
             deferred.resolve(status.events);
@@ -190,13 +210,18 @@ export const sendTransaction = async (tx) => {
         }
     });
     return {
-        events: deferred.promise,
+        events: deferred.promise
     };
 };
-export const testingPairs = (keyringType = 'ed25519', ss58Format) => {
-    const keyringEth = createTestKeyring({ type: 'ethereum' });
+export const testingPairs = (keyringType = 'ed25519', ss58Format)=>{
+    const keyringEth = createTestKeyring({
+        type: 'ethereum'
+    });
     // default to ed25519 because sr25519 signature is non-deterministic
-    const keyring = new Keyring({ type: keyringType, ss58Format });
+    const keyring = new Keyring({
+        type: keyringType,
+        ss58Format
+    });
     return {
         alice: keyring.addFromUri('//Alice'),
         bob: keyring.addFromUri('//Bob'),
@@ -209,6 +234,6 @@ export const testingPairs = (keyringType = 'ed25519', ss58Format) => {
         dorothy: keyringEth.getPair('0x773539d4Ac0e786233D90A233654ccEE26a613D9'),
         ethan: keyringEth.getPair('0xFf64d3F6efE2317EE2807d223a0Bdc4c0c49dfDB'),
         keyring,
-        keyringEth,
+        keyringEth
     };
 };

package/dist/esm/signFake.js

@@ -1,17 +1,22 @@
-export const signFakeWithApi = async (api, tx, addr, options = {}) => {
+export const signFakeWithApi = async (api, tx, addr, options = {})=>{
     const nonce = options.nonce ?? (await api.query.system.account(addr)).nonce;
     signFake(tx, addr, {
         nonce,
         genesisHash: api.genesisHash,
         runtimeVersion: api.runtimeVersion,
         blockHash: api.genesisHash,
-        ...options,
+        ...options
     });
 };
-export const signFake = (tx, addr, options) => {
+export const signFake = (tx, addr, options)=>{
     const mockSignature = new Uint8Array(64);
     mockSignature.fill(0xcd);
-    mockSignature.set([0xde, 0xad, 0xbe, 0xef]);
+    mockSignature.set([
+        0xde,
+        0xad,
+        0xbe,
+        0xef
+    ]);
     tx.signFake(addr, options);
     tx.signature.set(mockSignature);
 };

package/package.json

@@ -1,19 +1,25 @@
 {
   "name": "@acala-network/chopsticks-testing",
-  "version": "0.9.1-1",
+  "version": "0.9.1-3",
   "author": "Acala Developers <hello@acala.network>",
   "license": "Apache-2.0",
+  "type": "module",
   "scripts": {
     "clean": "rm -rf dist",
-    "build": "yarn clean && tsc -p ./tsconfig.json && tsc -p ./tsconfig.esm.json"
+    "build": "yarn clean && yarn build:cjs && yarn build:esm && yarn build:types",
+    "build:cjs": "swc ./src --config-file ../../.cjsswcrc -d dist/cjs && echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json",
+    "build:esm": "swc ./src --config-file ../../.esmswcrc -d dist/esm",
+    "build:types": "tsc -p tsconfig.json --emitDeclarationOnly --outDir dist/types"
   },
   "dependencies": {
-    "@acala-network/chopsticks": "0.9.1-1"
+    "@acala-network/chopsticks": "0.9.1-3"
   },
   "peerDependencies": {
     "vitest": "^0.34.0"
   },
   "devDependencies": {
+    "@swc/cli": "0.1.62",
+    "@swc/core": "^1.3.96",
     "@types/chai": "^4.3.5",
     "typescript": "^5.1.6"
   },
@@ -38,6 +44,7 @@
       "import": "./dist/esm/index.js",
       "default": "./dist/esm/index.js"
     },
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./package.cjs.json": "./dist/cjs/package.json"
   }
 }