@ocap/asset 1.27.16 → 1.28.0

package/esm/index.d.ts

@@ -1,36 +1,38 @@
-import type { LiteralUnion, PartialDeep } from 'type-fest';
-import type { WalletObject } from '@ocap/wallet';
-import type { TAssetFactoryState, TCreateAssetTx } from '@ocap/types';
+import { LiteralUnion, PartialDeep } from "type-fest";
+import { WalletObject } from "@ocap/wallet";
+import { TAssetFactoryState, TCreateAssetTx } from "@ocap/types";
+
+//#region src/index.d.ts
 type $TSFixMe = any;
-export type TPickedFactoryState = PartialDeep<TAssetFactoryState>;
-export type TIssuer = {
-    name: string;
-    wallet: WalletObject;
+type TPickedFactoryState = PartialDeep<TAssetFactoryState>;
+type TIssuer = {
+  name: string;
+  wallet: WalletObject;
 };
-export type TIssuerInput = {
-    id: string;
-    pk: string;
-    name: string;
+type TIssuerInput = {
+  id: string;
+  pk: string;
+  name: string;
 };
-export type THook = {
-    type: LiteralUnion<'contract' | 'url', string>;
-    name: LiteralUnion<'mint' | 'postMint' | 'preMint', string>;
-    hook: string;
+type THook = {
+  type: LiteralUnion<'contract' | 'url', string>;
+  name: LiteralUnion<'mint' | 'postMint' | 'preMint', string>;
+  hook: string;
 };
-export type TInputMap = {
-    [key: string]: string;
+type TInputMap = {
+  [key: string]: string;
 };
-export type TMintResult = {
-    address: string;
-    asset: TCreateAssetTx;
+type TMintResult = {
+  address: string;
+  asset: TCreateAssetTx;
 };
-export type TPreMintResult = TMintResult & {
-    variables: TInputMap;
-    issuer: TIssuerInput;
+type TPreMintResult = TMintResult & {
+  variables: TInputMap;
+  issuer: TIssuerInput;
 };
-export declare const isValidNotation: (notation: string) => boolean;
-export declare const isValidHook: (hook: THook, quota?: $TSFixMe, throwOnError?: boolean) => boolean;
-export declare const isValidFactory: (props: any) => boolean;
+declare const isValidNotation: (notation: string) => boolean;
+declare const isValidHook: (hook: THook, quota?: $TSFixMe, throwOnError?: boolean) => boolean;
+declare const isValidFactory: (props: any) => boolean;
 /**
  * Find credentialSubject path in the object
  * Because they need prerender
@@ -39,7 +41,7 @@ export declare const isValidFactory: (props: any) => boolean;
  * @param {string} keyword
  * @return {string} list of keys
  */
-export declare const findPrerenderKeys: (obj: $TSFixMe, keyword: string) => string[];
+declare const findPrerenderKeys: (obj: $TSFixMe, keyword: string) => string[];
 /**
  * Mint from an asset factory, used on server side
  *
@@ -49,11 +51,16 @@ export declare const findPrerenderKeys: (obj: $TSFixMe, keyword: string) => stri
  * @param {string} params.owner owner did for the new asset
  * @param {object} params.issuer issuer object
  */
-export declare const mintFromFactory: ({ factory, inputs, owner, issuer, }: {
-    factory: TPickedFactoryState;
-    inputs: TInputMap;
-    owner: string;
-    issuer: TIssuerInput;
+declare const mintFromFactory: ({
+  factory,
+  inputs,
+  owner,
+  issuer
+}: {
+  factory: TPickedFactoryState;
+  inputs: TInputMap;
+  owner: string;
+  issuer: TIssuerInput;
 }) => TMintResult;
 /**
  * Simulate minting from an asset factory, used for client side
@@ -64,11 +71,17 @@ export declare const mintFromFactory: ({ factory, inputs, owner, issuer, }: {
  * @param {string} params.owner owner did for the new asset
  * @param {object} params.issuer factory issuer wallet and name
  */
-export declare const preMintFromFactory: ({ factory, inputs, owner, issuer, }: {
-    factory?: TPickedFactoryState;
-    inputs: TInputMap;
-    owner?: string;
-    issuer?: TIssuer;
+declare const preMintFromFactory: ({
+  factory,
+  inputs,
+  owner,
+  issuer
+}: {
+  factory?: TPickedFactoryState;
+  inputs: TInputMap;
+  owner?: string;
+  issuer?: TIssuer;
 }) => Promise<TPreMintResult>;
-export declare const formatFactoryState: (state: TAssetFactoryState) => TPickedFactoryState;
-export {};
+declare const formatFactoryState: (state: TAssetFactoryState) => TPickedFactoryState;
+//#endregion
+export { THook, TInputMap, TIssuer, TIssuerInput, TMintResult, TPickedFactoryState, TPreMintResult, findPrerenderKeys, formatFactoryState, isValidFactory, isValidHook, isValidNotation, mintFromFactory, preMintFromFactory };

package/esm/index.js

@@ -1,248 +1,245 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-import get from 'lodash/get';
-import set from 'lodash/set';
-import uniq from 'lodash/uniq';
-import uniqBy from 'lodash/uniqBy';
-import isEmpty from 'lodash/isEmpty';
-import flatten from 'flat';
-import mustache from 'mustache';
-import isAbsoluteUrl from 'is-absolute-url';
-import cloneDeep from 'lodash/cloneDeep';
-import { toTypeInfo, fromPublicKeyHash } from '@arcblock/did';
-import { verify, stableStringify, proofTypes } from '@arcblock/vc';
-import { schemas } from '@arcblock/validator';
-import { toAssetAddress } from '@arcblock/did-util';
-import { types } from '@ocap/mcrypto';
-import { toBase58, toBase64 } from '@ocap/util';
-import { compile, validate, getQuota } from '@ocap/contract';
-import Debug from 'debug';
-const debug = Debug('@ocap/asset');
-const SUPPORTED_HOOK_NAMES = ['preMint', 'mint', 'postMint'];
-const SUPPORTED_HOOK_TYPES = ['contract', 'url'];
-export const isValidNotation = (notation) => ['ctx', 'data', 'input'].includes(notation.split('.').shift());
-export const isValidHook = (hook, quota, throwOnError = false) => {
-    if (SUPPORTED_HOOK_TYPES.includes(hook.type) === false) {
-        return false;
-    }
-    if (SUPPORTED_HOOK_NAMES.includes(hook.name) === false) {
-        return false;
-    }
-    if (hook.type === 'url') {
-        return isAbsoluteUrl(hook.hook);
-    }
-    if (hook.type === 'contract') {
-        try {
-            const compiled = compile(hook.hook);
-            validate(compiled, quota);
-            return true;
-        }
-        catch (err) {
-            if (process.env.NODE_ENV !== 'test') {
-                console.error('invalid contract hook', err.message);
-            }
-            if (throwOnError) {
-                throw new Error(`Factory hook ${hook.name} is invalid: ${err.message}`);
-            }
-            return false;
-        }
-    }
-    return false;
+import get from "lodash/get.js";
+import set from "lodash/set.js";
+import uniq from "lodash/uniq.js";
+import uniqBy from "lodash/uniqBy.js";
+import isEmpty from "lodash/isEmpty.js";
+import flatten from "flat";
+import mustache from "mustache";
+import isAbsoluteUrl from "is-absolute-url";
+import cloneDeep from "lodash/cloneDeep.js";
+import { fromPublicKeyHash, toTypeInfo } from "@arcblock/did";
+import { proofTypes, stableStringify, verify } from "@arcblock/vc";
+import { schemas } from "@arcblock/validator";
+import { toAssetAddress } from "@arcblock/did-util";
+import { types } from "@ocap/mcrypto";
+import { toBase58, toBase64 } from "@ocap/util";
+import { compile, getQuota, validate } from "@ocap/contract";
+import Debug from "debug";
+
+//#region src/index.ts
+const debug = Debug("@ocap/asset");
+const SUPPORTED_HOOK_NAMES = [
+	"preMint",
+	"mint",
+	"postMint"
+];
+const SUPPORTED_HOOK_TYPES = ["contract", "url"];
+const isValidNotation = (notation) => [
+	"ctx",
+	"data",
+	"input"
+].includes(notation.split(".").shift());
+const isValidHook = (hook, quota, throwOnError = false) => {
+	if (SUPPORTED_HOOK_TYPES.includes(hook.type) === false) return false;
+	if (SUPPORTED_HOOK_NAMES.includes(hook.name) === false) return false;
+	if (hook.type === "url") return isAbsoluteUrl(hook.hook);
+	if (hook.type === "contract") try {
+		validate(compile(hook.hook), quota);
+		return true;
+	} catch (err) {
+		if (process.env.NODE_ENV !== "test") console.error("invalid contract hook", err.message);
+		if (throwOnError) throw new Error(`Factory hook ${hook.name} is invalid: ${err.message}`);
+		return false;
+	}
+	return false;
 };
-// @link https://github.com/improbable-eng/ts-protoc-gen
-export const isValidFactory = (props) => {
-    if (!props) {
-        throw new Error('Factory props should not be empty');
-    }
-    const { value, error } = schemas.factorySchema.validate(props);
-    if (error) {
-        throw new Error(`Invalid factory: ${error.details.map((x) => x.message).join(', ')}`);
-    }
-    // input.tokens and input.assets should not be empty
-    if (['tokens', 'assets'].every((x) => isEmpty(value.input[x])) && value.input.value <= 0) {
-        throw new Error('Factory input should contain at least one token or asset');
-    }
-    if (uniqBy(value.input.tokens, 'address').length !== value.input.tokens.length) {
-        throw new Error('Factory token input should not contains duplicate address');
-    }
-    if (uniq(value.input.assets).length !== value.input.assets.length) {
-        throw new Error('Factory asset input should not contains duplicate address');
-    }
-    try {
-        // should be a valid mustache template when serialized as json
-        const template = JSON.stringify(value.output, null, 2);
-        const result = mustache.parse(template);
-        if (result.filter(([type]) => type === 'name').some(([, notation]) => isValidNotation(notation) === false)) {
-            throw new Error('Invalid tags found in the output template');
-        }
-    }
-    catch (err) {
-        throw new Error('Factory output should be a valid mustache template when serialized as json');
-    }
-    // validate hooks
-    const quota = getQuota(value.input);
-    if (Array.isArray(value.hooks)) {
-        const invalidHook = value.hooks.find((x) => isValidHook(x, quota, true) === false);
-        if (invalidHook) {
-            throw new Error(`Factory hook ${invalidHook.name} is invalid`);
-        }
-    }
-    // ensure input and hook are zero-sum for factories that consumes token
-    if (value.settlement === 'instant') {
-        if (quota.value <= 0 && Object.keys(quota.tokens).every((x) => quota[x] <= 0)) {
-            return true;
-        }
-        if (isEmpty(value.hooks)) {
-            throw new Error('Factory hooks should not be empty for instant settlement');
-        }
-        const mintHook = value.hooks.find((x) => x.name === 'mint');
-        if (!mintHook) {
-            throw new Error('Factory hook mint should not be empty for instant settlement that consumes token');
-        }
-        try {
-            const compiled = compile(mintHook.hook);
-            validate(compiled, quota, true);
-        }
-        catch (err) {
-            throw new Error(`Factory hook mint is invalid: ${err.message}`);
-        }
-    }
-    return true;
+const isValidFactory = (props) => {
+	if (!props) throw new Error("Factory props should not be empty");
+	const { value, error } = schemas.factorySchema.validate(props);
+	if (error) throw new Error(`Invalid factory: ${error.details.map((x) => x.message).join(", ")}`);
+	if (["tokens", "assets"].every((x) => isEmpty(value.input[x])) && value.input.value <= 0) throw new Error("Factory input should contain at least one token or asset");
+	if (uniqBy(value.input.tokens, "address").length !== value.input.tokens.length) throw new Error("Factory token input should not contains duplicate address");
+	if (uniq(value.input.assets).length !== value.input.assets.length) throw new Error("Factory asset input should not contains duplicate address");
+	try {
+		const template = JSON.stringify(value.output, null, 2);
+		if (mustache.parse(template).filter(([type]) => type === "name").some(([, notation]) => isValidNotation(notation) === false)) throw new Error("Invalid tags found in the output template");
+	} catch (err) {
+		throw new Error("Factory output should be a valid mustache template when serialized as json");
+	}
+	const quota = getQuota(value.input);
+	if (Array.isArray(value.hooks)) {
+		const invalidHook = value.hooks.find((x) => isValidHook(x, quota, true) === false);
+		if (invalidHook) throw new Error(`Factory hook ${invalidHook.name} is invalid`);
+	}
+	if (value.settlement === "instant") {
+		if (quota.value <= 0 && Object.keys(quota.tokens).every((x) => quota[x] <= 0)) return true;
+		if (isEmpty(value.hooks)) throw new Error("Factory hooks should not be empty for instant settlement");
+		const mintHook = value.hooks.find((x) => x.name === "mint");
+		if (!mintHook) throw new Error("Factory hook mint should not be empty for instant settlement that consumes token");
+		try {
+			validate(compile(mintHook.hook), quota, true);
+		} catch (err) {
+			throw new Error(`Factory hook mint is invalid: ${err.message}`);
+		}
+	}
+	return true;
 };
 /**
- * Find credentialSubject path in the object
- * Because they need prerender
- *
- * @param {object} obj
- * @param {string} keyword
- * @return {string} list of keys
- */
-export const findPrerenderKeys = (obj, keyword) => {
-    const flatObj = flatten(obj, { safe: true });
-    const keys = Object.keys(flatObj)
-        .map((x) => x.split('.'))
-        .filter((x) => x.includes(keyword))
-        .map((x) => x.slice(0, x.lastIndexOf(keyword) + 1))
-        .sort((a, b) => b.length - a.length)
-        .map((x) => x.join('.'));
-    return uniq(keys);
+* Find credentialSubject path in the object
+* Because they need prerender
+*
+* @param {object} obj
+* @param {string} keyword
+* @return {string} list of keys
+*/
+const findPrerenderKeys = (obj, keyword) => {
+	const flatObj = flatten(obj, { safe: true });
+	return uniq(Object.keys(flatObj).map((x) => x.split(".")).filter((x) => x.includes(keyword)).map((x) => x.slice(0, x.lastIndexOf(keyword) + 1)).sort((a, b) => b.length - a.length).map((x) => x.join(".")));
 };
 /**
- * Mint from an asset factory, used on server side
- *
- * @param {object} params { factory, inputs, issuer }
- * @param {object} params.factory factory object
- * @param {object} params.inputs factory input variables
- * @param {string} params.owner owner did for the new asset
- * @param {object} params.issuer issuer object
- */
-export const mintFromFactory = ({ factory, inputs, owner, issuer, }) => {
-    const { output, address: factoryAddress, numMinted, data } = factory;
-    debug('mintFromFactory.args', JSON.stringify({ output, factoryAddress, numMinted, inputs, owner, issuer, data }, null, 2));
-    const asset = JSON.parse(mustache.render(JSON.stringify(output), {
-        input: inputs,
-        data: data.value || data,
-        ctx: { factory: factoryAddress, id: numMinted + 1, owner, issuer },
-    }));
-    const address = toAssetAddress(asset);
-    debug('mintFromFactory.result', JSON.stringify({ asset, address }, null, 2));
-    return { asset, address };
+* Mint from an asset factory, used on server side
+*
+* @param {object} params { factory, inputs, issuer }
+* @param {object} params.factory factory object
+* @param {object} params.inputs factory input variables
+* @param {string} params.owner owner did for the new asset
+* @param {object} params.issuer issuer object
+*/
+const mintFromFactory = ({ factory, inputs, owner, issuer }) => {
+	const { output, address: factoryAddress, numMinted, data } = factory;
+	debug("mintFromFactory.args", JSON.stringify({
+		output,
+		factoryAddress,
+		numMinted,
+		inputs,
+		owner,
+		issuer,
+		data
+	}, null, 2));
+	const asset = JSON.parse(mustache.render(JSON.stringify(output), {
+		input: inputs,
+		data: data.value || data,
+		ctx: {
+			factory: factoryAddress,
+			id: numMinted + 1,
+			owner,
+			issuer
+		}
+	}));
+	const address = toAssetAddress(asset);
+	debug("mintFromFactory.result", JSON.stringify({
+		asset,
+		address
+	}, null, 2));
+	return {
+		asset,
+		address
+	};
 };
 /**
- * Simulate minting from an asset factory, used for client side
- *
- * @param {object} params { factory, inputs, issuer }
- * @param {object} params.factory factory object
- * @param {object} params.inputs factory input variables
- * @param {string} params.owner owner did for the new asset
- * @param {object} params.issuer factory issuer wallet and name
- */
-export const preMintFromFactory = async ({ factory, inputs, owner, issuer, }) => {
-    if (Object.keys(inputs).some((x) => typeof inputs[x] !== 'string')) {
-        throw new Error('Failed to mint asset from factory: input values must be strings');
-    }
-    let asset = null;
-    const { output, numMinted, address: factoryAddress, data } = factory;
-    const { wallet, name } = issuer;
-    debug('preMintFromFactory.args', JSON.stringify({ output, factoryAddress, numMinted, inputs, owner, issuer, data }, null, 2));
-    const extra = {};
-    const issuerObject = { id: wallet.address, pk: toBase58(wallet.publicKey), name };
-    const render = (templateObject) => JSON.parse(mustache.render(JSON.stringify(templateObject), {
-        input: { ...inputs, ...extra },
-        data: data.value || data,
-        ctx: { factory: factoryAddress, id: numMinted + 1, owner, issuer: issuerObject },
-    }));
-    const template = cloneDeep(output);
-    // prerender credentialSubjects if they exists
-    // then populate their ids
-    const prerenderKeys = findPrerenderKeys(template, 'credentialSubject');
-    if (prerenderKeys.length) {
-        extra.issuanceDate = new Date().toISOString();
-        for (const key of prerenderKeys) {
-            const subjectTemplate = get(template, key);
-            const subjectObject = Array.isArray(subjectTemplate)
-                ? subjectTemplate.map((x) => render(x))
-                : render(subjectTemplate);
-            set(template, key, subjectObject);
-            // calculate credential id from credentialSubject
-            const vcRootPath = key.split('.').slice(0, -1).join('.');
-            const vcIdPath = vcRootPath.split('.').concat(['id']).join('.');
-            const typeInfo = toTypeInfo(issuerObject.id);
-            const vcType = { ...typeInfo, role: types.RoleType.ROLE_VC };
-            const vcId = fromPublicKeyHash(wallet.hash(stableStringify(subjectObject)), vcType);
-            extra.id = vcId;
-            extra.proofType = proofTypes[typeInfo.pk];
-            // technically we do not support nested vc when minting
-            // But it is possible to support multiple credentialSubjects when minting
-            set(template, vcIdPath, vcId);
-            // Generate proof signatures
-            if (!proofTypes[typeInfo.pk]) {
-                throw new Error('Unsupported signer type when create verifiable credential');
-            }
-            let vcObj = render(get(template, vcRootPath));
-            delete vcObj.proof;
-            const vcStr = stableStringify(vcObj);
-            // eslint-disable-next-line no-await-in-loop
-            const signature = toBase64(await wallet.sign(vcStr));
-            vcObj.proof = {
-                type: proofTypes[typeInfo.pk],
-                created: extra.issuanceDate,
-                proofPurpose: 'assertionMethod',
-                jws: signature,
-            };
-            extra.signature = signature;
-            try {
-                // Simulate minting from start, so that we can ensure the validity of minted asset
-                asset = render(cloneDeep(output));
-                vcObj = get(asset, vcRootPath);
-                debug('preMintFromFactory.result', JSON.stringify(asset, null, 2));
-                // eslint-disable-next-line no-await-in-loop
-                await verify({ vc: vcObj, trustedIssuers: [issuerObject.id], ownerDid: owner, ignoreExpired: true });
-            }
-            catch (err) {
-                console.error(err);
-                throw new Error('Failed to mint asset from factory: invalid verifiable credential minted');
-            }
-        }
-    }
-    else {
-        // populate other variables into the whole output
-        asset = render(template);
-        debug('preMintFromFactory.result', JSON.stringify(asset, null, 2));
-    }
-    // calculate address
-    const address = toAssetAddress(asset);
-    // return extra inputs
-    return { address, issuer: issuerObject, variables: { ...inputs, ...extra }, asset };
+* Simulate minting from an asset factory, used for client side
+*
+* @param {object} params { factory, inputs, issuer }
+* @param {object} params.factory factory object
+* @param {object} params.inputs factory input variables
+* @param {string} params.owner owner did for the new asset
+* @param {object} params.issuer factory issuer wallet and name
+*/
+const preMintFromFactory = async ({ factory, inputs, owner, issuer }) => {
+	if (Object.keys(inputs).some((x) => typeof inputs[x] !== "string")) throw new Error("Failed to mint asset from factory: input values must be strings");
+	let asset = null;
+	const { output, numMinted, address: factoryAddress, data } = factory;
+	const { wallet, name } = issuer;
+	debug("preMintFromFactory.args", JSON.stringify({
+		output,
+		factoryAddress,
+		numMinted,
+		inputs,
+		owner,
+		issuer,
+		data
+	}, null, 2));
+	const extra = {};
+	const issuerObject = {
+		id: wallet.address,
+		pk: toBase58(wallet.publicKey),
+		name
+	};
+	const render = (templateObject) => JSON.parse(mustache.render(JSON.stringify(templateObject), {
+		input: {
+			...inputs,
+			...extra
+		},
+		data: data.value || data,
+		ctx: {
+			factory: factoryAddress,
+			id: numMinted + 1,
+			owner,
+			issuer: issuerObject
+		}
+	}));
+	const template = cloneDeep(output);
+	const prerenderKeys = findPrerenderKeys(template, "credentialSubject");
+	if (prerenderKeys.length) {
+		extra.issuanceDate = (/* @__PURE__ */ new Date()).toISOString();
+		for (const key of prerenderKeys) {
+			const subjectTemplate = get(template, key);
+			const subjectObject = Array.isArray(subjectTemplate) ? subjectTemplate.map((x) => render(x)) : render(subjectTemplate);
+			set(template, key, subjectObject);
+			const vcRootPath = key.split(".").slice(0, -1).join(".");
+			const vcIdPath = vcRootPath.split(".").concat(["id"]).join(".");
+			const typeInfo = toTypeInfo(issuerObject.id);
+			const vcType = {
+				...typeInfo,
+				role: types.RoleType.ROLE_VC
+			};
+			const vcId = fromPublicKeyHash(wallet.hash(stableStringify(subjectObject)), vcType);
+			extra.id = vcId;
+			extra.proofType = proofTypes[typeInfo.pk];
+			set(template, vcIdPath, vcId);
+			if (!proofTypes[typeInfo.pk]) throw new Error("Unsupported signer type when create verifiable credential");
+			let vcObj = render(get(template, vcRootPath));
+			delete vcObj.proof;
+			const vcStr = stableStringify(vcObj);
+			const signature = toBase64(await wallet.sign(vcStr));
+			vcObj.proof = {
+				type: proofTypes[typeInfo.pk],
+				created: extra.issuanceDate,
+				proofPurpose: "assertionMethod",
+				jws: signature
+			};
+			extra.signature = signature;
+			try {
+				asset = render(cloneDeep(output));
+				vcObj = get(asset, vcRootPath);
+				debug("preMintFromFactory.result", JSON.stringify(asset, null, 2));
+				await verify({
+					vc: vcObj,
+					trustedIssuers: [issuerObject.id],
+					ownerDid: owner,
+					ignoreExpired: true
+				});
+			} catch (err) {
+				console.error(err);
+				throw new Error("Failed to mint asset from factory: invalid verifiable credential minted");
+			}
+		}
+	} else {
+		asset = render(template);
+		debug("preMintFromFactory.result", JSON.stringify(asset, null, 2));
+	}
+	return {
+		address: toAssetAddress(asset),
+		issuer: issuerObject,
+		variables: {
+			...inputs,
+			...extra
+		},
+		asset
+	};
 };
-export const formatFactoryState = (state) => {
-    const { address, output, data, numMinted } = state;
-    const outputX = cloneDeep(output);
-    outputX.data.value = JSON.parse(outputX.data.value);
-    outputX.data.type = outputX.data.typeUrl;
-    return {
-        address,
-        output: outputX,
-        data: data.value ? JSON.parse(data.value) : {},
-        numMinted,
-    };
+const formatFactoryState = (state) => {
+	const { address, output, data, numMinted } = state;
+	const outputX = cloneDeep(output);
+	outputX.data.value = JSON.parse(outputX.data.value);
+	outputX.data.type = outputX.data.typeUrl;
+	return {
+		address,
+		output: outputX,
+		data: data.value ? JSON.parse(data.value) : {},
+		numMinted
+	};
 };
+
+//#endregion
+export { findPrerenderKeys, formatFactoryState, isValidFactory, isValidHook, isValidNotation, mintFromFactory, preMintFromFactory };

package/esm/lodash.d.ts

@@ -0,0 +1,7 @@
+//#region src/lodash.d.ts
+declare module 'lodash/cloneDeep';
+declare module 'lodash/get';
+declare module 'lodash/isEmpty';
+declare module 'lodash/set';
+declare module 'lodash/uniq';
+declare module 'lodash/uniqBy';

package/lib/_virtual/rolldown_runtime.js

@@ -0,0 +1,29 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;