@laceio/sdk 0.1.1-canary.2 → 0.1.1

package/dist/providers-CwnT4vEE.js

@@ -1,343 +0,0 @@
-import { i as accManifest, n as loadCircuitAssets, r as loadVerifierKey, t as UnknownCircuitError } from "./artefact-loader-54uK5RAa.js";
-import { a as ArtefactIntegrityError } from "./errors-DIJTAsLa.js";
-//#region ../../packages/contract/passport/src/value-objects/acc-address.vo.ts
-/** Types a string as an Account Custody Contract address. It checks nothing. */
-const AccAddress = (value) => value;
-//#endregion
-//#region ../../packages/module/passport-account/src/infra/network-id.ts
-/**
-* Applies the Midnight network id the rest of the Midnight libraries read
-* from module-global state. Address formats and transaction binding depend
-* on it, and every wallet or contract operation throws until it is set, so
-* each entry point into a chain flow applies it before doing any work.
-* Setting the same id again is harmless; a different id replaces the
-* previous one, which is why one network config owns the value.
-*/
-const applyNetworkId = async (networkId) => {
-	const { setNetworkId } = await import("@midnight-ntwrk/midnight-js-network-id");
-	setNetworkId(networkId);
-};
-//#endregion
-//#region ../../packages/module/passport-account/src/infra/http-prover.ts
-/**
-* Thrown when the proof server rejects a request or does not answer before
-* the timeout. `status` carries the HTTP status code of the final response;
-* it is undefined when the request timed out before any response arrived.
-*/
-var ProofServerError = class extends Error {
-	code = "proof-server";
-	constructor(message, status) {
-		super(message);
-		this.status = status;
-		this.name = "ProofServerError";
-	}
-};
-/**
-* Canonical contract key location: `contract:<address>/<circuit>?vk=<hash>`.
-* The ledger stamps every contract call's proof preimage with this form;
-* the vk query pin is the sha256 of the verifier key the chain expects.
-*/
-const CANONICAL_KEY_LOCATION = /^contract:[0-9a-f]+\/([^?]+)(?:\?vk=([0-9a-f]+))?$/;
-/**
-* The default {@link KeyMaterialResolver}: maps a key location onto the
-* Account Custody Contract manifest and downloads that circuit's prover
-* key, verifier key, and IR through {@link loadCircuitAssets}, so every
-* byte is verified against the manifest's sha256 pins. Canonical contract
-* locations resolve by circuit name, and their embedded vk pin must match
-* the manifest's, so proving against a drifted artefact fails before the
-* proof server is asked. A location the manifest does not list resolves
-* to undefined (a protocol builtin the proof server supplies itself).
-*/
-const createManifestKeyMaterialResolver = ({ artefactUrl, fetchBytes, manifest = accManifest }) => {
-	const entries = Object.values(manifest.circuits);
-	return async (keyLocation) => {
-		const canonical = CANONICAL_KEY_LOCATION.exec(keyLocation);
-		const circuitName = canonical ? canonical[1] : keyLocation;
-		const vkPin = canonical?.[2];
-		const entry = entries.find((candidate) => candidate.keyLocation === keyLocation || candidate.name === circuitName);
-		if (!entry) return void 0;
-		if (vkPin !== void 0 && vkPin !== entry.verifierKeySha256) throw new ArtefactIntegrityError(`verifier key pin mismatch for ${entry.name}: the chain expects ${vkPin}, the manifest pins ${entry.verifierKeySha256}`);
-		const assets = await loadCircuitAssets({
-			artefactUrl,
-			circuit: entry.name,
-			fetchBytes,
-			manifest
-		});
-		return {
-			proverKey: assets.proverKey,
-			verifierKey: assets.verifierKey,
-			ir: assets.zkir
-		};
-	};
-};
-/** Proving a circuit call can legitimately take minutes on large circuits. */
-const TIMEOUT_MS = 3e5;
-/** A 500/503 is transient (proof server busy or restarting); one retry. */
-const RETRYABLE_STATUSES = new Set([500, 503]);
-const defaultFetchBytes$1 = async (url) => {
-	const response = await fetch(url);
-	if (!response.ok) throw new Error(`Artefact download failed: url="${url}", status="${response.status} ${response.statusText}"`);
-	return new Uint8Array(await response.arrayBuffer());
-};
-/**
-* A {@link PassportProver} over the Midnight proof server's HTTP API,
-* wire-compatible with the stock midnight-js client: the key location is
-* resolved client-side to the circuit's key material (prover key and IR),
-* the serialized preimage plus that material is framed with the protocol
-* payload codecs, and the framed bytes are POSTed to /prove and /check as
-* application/octet-stream with nothing else. A location the resolver
-* does not know travels without key material; the proof server supplies
-* the protocol builtin keys itself. The protocol codec loads lazily so
-* platforms only pay for it when a proof is actually requested.
-*
-* @param baseUrl - The proof server's URL; requests go to `<baseUrl>/prove`
-*   and `<baseUrl>/check`.
-* @param options - Where key material comes from, and the transports. It
-*   throws without `resolveKeyMaterial` or an `artefactUrl`.
-*/
-const createHttpProver = (baseUrl, options = {}) => {
-	const fetchHttp = options.fetchHttp ?? globalThis.fetch;
-	const resolveKeyMaterial = options.resolveKeyMaterial ?? (options.artefactUrl === void 0 ? void 0 : createManifestKeyMaterialResolver({
-		artefactUrl: options.artefactUrl,
-		fetchBytes: options.fetchBytes ?? defaultFetchBytes$1
-	}));
-	if (!resolveKeyMaterial) throw new Error("createHttpProver needs resolveKeyMaterial or an artefactUrl for the default manifest resolver.");
-	const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
-	const loadPayloadCodec = async () => import("@midnight-ntwrk/midnight-js-protocol/ledger");
-	const request = async (url, payload) => {
-		const controller = new AbortController();
-		const timer = setTimeout(() => {
-			controller.abort();
-		}, TIMEOUT_MS);
-		try {
-			return await fetchHttp(url, {
-				method: "POST",
-				headers: { "Content-Type": "application/octet-stream" },
-				body: payload,
-				signal: controller.signal
-			});
-		} catch (error) {
-			if (controller.signal.aborted) throw new ProofServerError(`Proof server request timed out after ${TIMEOUT_MS}ms: ${url}`);
-			throw error;
-		} finally {
-			clearTimeout(timer);
-		}
-	};
-	const post = async (path, payload) => {
-		const url = `${base}${path}`;
-		for (let attempt = 0;; attempt++) {
-			const response = await request(url, payload);
-			if (response.ok) return new Uint8Array(await response.arrayBuffer());
-			if (attempt === 0 && RETRYABLE_STATUSES.has(response.status)) continue;
-			throw new ProofServerError(`Proof server request failed: url="${url}", status="${response.status} ${response.statusText}"`, response.status);
-		}
-	};
-	return {
-		prove: async (preimage, keyLocation, overwriteBindingInput) => {
-			const [{ createProvingPayload }, keyMaterial] = await Promise.all([loadPayloadCodec(), resolveKeyMaterial(keyLocation)]);
-			return post("/prove", createProvingPayload(preimage, overwriteBindingInput, keyMaterial));
-		},
-		check: async (preimage, keyLocation) => {
-			const [{ createCheckPayload }, keyMaterial] = await Promise.all([loadPayloadCodec(), resolveKeyMaterial(keyLocation)]);
-			return post("/check", createCheckPayload(preimage, keyMaterial?.ir));
-		}
-	};
-};
-//#endregion
-//#region ../../packages/module/passport-account/src/infra/providers.ts
-/**
-* The ledger era every provider seam serves. The framework reads it before
-* an operation starts and refuses a provider set that cannot carry a
-* transaction end to end, so a mismatch fails before any proof is paid for.
-*/
-const SERVED_ERAS = ["v9"];
-const v9 = (tx) => ({
-	version: "v9",
-	tx
-});
-const ZSWAP_SEED_LENGTH = 32;
-const defaultRandomBytes = (length) => crypto.getRandomValues(new Uint8Array(length));
-const defaultFetchBytes = async (url) => {
-	const response = await fetch(url);
-	if (!response.ok) throw new Error(`Artefact download failed: url="${url}", status="${response.status} ${response.statusText}"`);
-	return new Uint8Array(await response.arrayBuffer());
-};
-/**
-* In-memory {@link AccProviders}.privateStateProvider. The account private
-* state only needs to outlive one deploy-and-activate flow, so nothing is
-* written to disk; contract-address scoping is a no-op because each flow
-* gets its own provider instance.
-*/
-const createInMemoryPrivateStateProvider = () => {
-	const privateStates = /* @__PURE__ */ new Map();
-	const signingKeys = /* @__PURE__ */ new Map();
-	return {
-		setContractAddress: (_address) => void 0,
-		set: async (privateStateId, state) => {
-			privateStates.set(privateStateId, state);
-		},
-		get: async (privateStateId) => privateStates.get(privateStateId) ?? null,
-		remove: async (privateStateId) => {
-			privateStates.delete(privateStateId);
-		},
-		clear: async () => {
-			privateStates.clear();
-		},
-		setSigningKey: async (address, key) => {
-			signingKeys.set(address, key);
-		},
-		getSigningKey: async (address) => signingKeys.get(address) ?? null,
-		removeSigningKey: async (address) => {
-			signingKeys.delete(address);
-		},
-		clearSigningKeys: async () => {
-			signingKeys.clear();
-		}
-	};
-};
-/**
-* Assembles the midnight-js providers {@link deployAccount} runs through,
-* swapping the platform seams in where the stock providers would expect a
-* full wallet:
-*
-* - zkConfigProvider downloads ZK assets through {@link loadCircuitAssets},
-*   so every byte is verified against the manifest's sha256 pins. A
-*   verifier key asked for alone is downloaded alone, so deploying an
-*   account fetches no prover key it does not prove with. A circuit this
-*   module never proves, such as a secp256k1 grant withdrawal, has no
-*   manifest entry: its verifier key asked for alone is verified against
-*   the contract's own expected pin, and it is skipped when verifier keys
-*   are listed.
-* - proofProvider adapts the {@link PassportProver} to the ledger's
-*   circuit-level proving interface.
-* - walletProvider delegates balancing to the {@link FeeSponsor}; the user
-*   holds no tokens, so the sponsor covers every fee. Its Zswap keys are
-*   ephemeral, generated per flow: the transactions move no coins, the
-*   keys only satisfy transaction construction and are discarded with the
-*   providers.
-* - midnightProvider submits each finalized transaction over the node RPC
-*   relay, opening and closing a connection per submission.
-*
-* `onStage` reports the proving and sponsoring stages as they start, so
-* the caller can surface flow progress that otherwise happens inside
-* midnight-js calls.
-*/
-const createMidnightProviders = async ({ network, prover, sponsor, fetchBytes = defaultFetchBytes, manifest = accManifest, onStage, randomBytes = defaultRandomBytes, createPublicDataProvider, createSubmissionService }) => {
-	await applyNetworkId(network.networkId);
-	const ledger = await import("@midnightntwrk/ledger-v9");
-	const zswapKeys = ledger.ZswapSecretKeys.fromSeed(randomBytes(ZSWAP_SEED_LENGTH));
-	const coinPublicKey = zswapKeys.coinPublicKey;
-	const encryptionPublicKey = zswapKeys.encryptionPublicKey;
-	zswapKeys.clear();
-	const assetCache = /* @__PURE__ */ new Map();
-	const circuitAssets = async (circuit) => {
-		let assets = assetCache.get(circuit);
-		if (!assets) {
-			assets = loadCircuitAssets({
-				artefactUrl: network.artefactUrl,
-				circuit,
-				fetchBytes,
-				manifest
-			});
-			assetCache.set(circuit, assets);
-		}
-		return assets;
-	};
-	const isPinnedCircuit = (circuitId) => circuitId in manifest.circuits;
-	const verifierKeyCache = /* @__PURE__ */ new Map();
-	const verifierKeyPin = async (circuitId) => {
-		if (isPinnedCircuit(circuitId)) return manifest.circuits[circuitId].verifierKeySha256;
-		const { expectedVk } = await import("./acc-module-Cmj8EsIb.js").then((n) => n.n);
-		const expectedSha256 = expectedVk[circuitId];
-		if (!expectedSha256) throw new UnknownCircuitError(circuitId);
-		return expectedSha256;
-	};
-	const verifierKey = async (circuitId) => {
-		const cachedAssets = isPinnedCircuit(circuitId) ? assetCache.get(circuitId) : void 0;
-		if (cachedAssets) return (await cachedAssets).verifierKey;
-		let key = verifierKeyCache.get(circuitId);
-		if (!key) {
-			key = (async () => {
-				const expectedSha256 = await verifierKeyPin(circuitId);
-				return loadVerifierKey({
-					artefactUrl: network.artefactUrl,
-					circuit: circuitId,
-					fetchBytes,
-					expectedSha256
-				});
-			})();
-			verifierKeyCache.set(circuitId, key);
-		}
-		return key;
-	};
-	const zkConfigProvider = {
-		getZKIR: async (circuitId) => (await circuitAssets(circuitId)).zkir,
-		getProverKey: async (circuitId) => (await circuitAssets(circuitId)).proverKey,
-		getVerifierKey: async (circuitId) => verifierKey(circuitId),
-		getVerifierKeys: async (circuitIds) => Promise.all(circuitIds.filter((circuitId) => isPinnedCircuit(circuitId)).map(async (circuitId) => [circuitId, await verifierKey(circuitId)])),
-		get: async (circuitId) => ({
-			circuitId,
-			...await circuitAssets(circuitId)
-		})
-	};
-	const resolveKeyMaterial = createManifestKeyMaterialResolver({
-		artefactUrl: network.artefactUrl,
-		fetchBytes,
-		manifest
-	});
-	const provingProvider = {
-		prove: async (preimage, keyLocation, overwriteBindingInput) => prover.prove(preimage, keyLocation, overwriteBindingInput),
-		check: async (preimage, keyLocation) => ledger.parseCheckResult(await prover.check(preimage, keyLocation)),
-		lookupKey: async (keyLocation) => resolveKeyMaterial(keyLocation)
-	};
-	const proofProvider = {
-		supportedEras: SERVED_ERAS,
-		proveTx: async ({ tx }) => {
-			onStage?.("proving");
-			return v9(await tx.prove(provingProvider, ledger.CostModel.initialCostModel()));
-		}
-	};
-	const walletProvider = {
-		supportedEras: SERVED_ERAS,
-		getCoinPublicKey: () => coinPublicKey,
-		getEncryptionPublicKey: () => encryptionPublicKey,
-		balanceTx: async ({ tx }) => {
-			onStage?.("sponsoring");
-			const balanced = await sponsor.balanceAndSign(tx.serialize());
-			return v9(ledger.Transaction.deserialize("signature", "proof", "binding", balanced));
-		}
-	};
-	const defaultSubmissionService = async () => {
-		const { createNodeRelaySubmissionService } = await import("./node-relay-Cv0cNknM.js");
-		return createNodeRelaySubmissionService(network.nodeUrl);
-	};
-	const midnightProvider = {
-		supportedEras: SERVED_ERAS,
-		submitTx: async ({ tx }) => {
-			const service = await (createSubmissionService ?? defaultSubmissionService)();
-			try {
-				await service.submitTransaction(tx, "InBlock");
-				return tx.identifiers().at(-1);
-			} finally {
-				await service.close();
-			}
-		}
-	};
-	const defaultPublicDataProvider = async () => {
-		const { indexerPublicDataProvider } = await import("@midnight-ntwrk/midnight-js-indexer-public-data-provider");
-		return indexerPublicDataProvider({
-			queryURL: network.indexerUrl,
-			subscriptionURL: network.indexerWsUrl
-		});
-	};
-	return {
-		publicDataProvider: await (createPublicDataProvider ?? defaultPublicDataProvider)(),
-		zkConfigProvider,
-		proofProvider,
-		privateStateProvider: createInMemoryPrivateStateProvider(),
-		walletProvider,
-		midnightProvider
-	};
-};
-//#endregion
-export { AccAddress as i, createHttpProver as n, applyNetworkId as r, createMidnightProviders as t };

package/dist/redacted-BmE2aXqr.js

@@ -1,81 +0,0 @@
-import { n as import_buffer, r as init__polyfill_buffer_patch } from "./_polyfill-buffer-patch-yNxN4d5E.js";
-//#region ../../packages/lib/util-redacted/src/redacted.ts
-init__polyfill_buffer_patch();
-const RedactedSymbol = Symbol.for("@lace/Redacted");
-const InspectSymbol = Symbol.for("nodejs.util.inspect.custom");
-const RedactedTagKey = "__redacted";
-const RedactedValueKey = "__redactedValue";
-const redactedString = () => "[REDACTED]";
-const decorateObject = (value) => {
-	Object.defineProperties(value, {
-		_tag: {
-			value: "Redacted",
-			configurable: true,
-			enumerable: true
-		},
-		[RedactedSymbol]: {
-			value,
-			configurable: true
-		},
-		[RedactedTagKey]: {
-			value: true,
-			configurable: true,
-			enumerable: true
-		},
-		toString: {
-			value: redactedString,
-			configurable: true
-		},
-		toJSON: {
-			value: redactedString,
-			configurable: true
-		},
-		[InspectSymbol]: {
-			value: redactedString,
-			configurable: true
-		}
-	});
-	return value;
-};
-const make = (value) => {
-	if (typeof value === "object" && value !== null) return decorateObject(value);
-	return {
-		_tag: "Redacted",
-		[RedactedSymbol]: value,
-		[RedactedTagKey]: true,
-		[RedactedValueKey]: value,
-		toString: redactedString,
-		toJSON: redactedString,
-		[InspectSymbol]: redactedString
-	};
-};
-const value = (self) => {
-	if (RedactedSymbol in self) return self[RedactedSymbol];
-	if (RedactedValueKey in self) return self[RedactedValueKey];
-	return self;
-};
-const unsafeWipe = (self) => {
-	const current = value(self);
-	if (current instanceof Uint8Array) current.fill(0);
-	else if (typeof import_buffer.Buffer !== "undefined" && import_buffer.Buffer.isBuffer(current)) current.fill(0);
-	delete self[RedactedSymbol];
-	delete self[RedactedValueKey];
-};
-const isRedacted = (value) => typeof value === "object" && value !== null && ("_tag" in value && value._tag === "Redacted" || RedactedTagKey in value);
-const filterRedacted = (value) => {
-	if (isRedacted(value)) return "[REDACTED]";
-	if (typeof value !== "object" || value === null) return value;
-	if (Array.isArray(value)) return value.map(filterRedacted);
-	const filtered = {};
-	for (const key in value) filtered[key] = filterRedacted(value[key]);
-	return filtered;
-};
-const Redacted = {
-	make,
-	value,
-	unsafeWipe,
-	isRedacted,
-	filterRedacted
-};
-//#endregion
-export { Redacted as t };

package/dist/redacted-CRZJLS3w.cjs

@@ -1,86 +0,0 @@
-const require__polyfill_buffer_patch = require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
-//#region ../../packages/lib/util-redacted/src/redacted.ts
-require__polyfill_buffer_patch.init__polyfill_buffer_patch();
-const RedactedSymbol = Symbol.for("@lace/Redacted");
-const InspectSymbol = Symbol.for("nodejs.util.inspect.custom");
-const RedactedTagKey = "__redacted";
-const RedactedValueKey = "__redactedValue";
-const redactedString = () => "[REDACTED]";
-const decorateObject = (value) => {
-	Object.defineProperties(value, {
-		_tag: {
-			value: "Redacted",
-			configurable: true,
-			enumerable: true
-		},
-		[RedactedSymbol]: {
-			value,
-			configurable: true
-		},
-		[RedactedTagKey]: {
-			value: true,
-			configurable: true,
-			enumerable: true
-		},
-		toString: {
-			value: redactedString,
-			configurable: true
-		},
-		toJSON: {
-			value: redactedString,
-			configurable: true
-		},
-		[InspectSymbol]: {
-			value: redactedString,
-			configurable: true
-		}
-	});
-	return value;
-};
-const make = (value) => {
-	if (typeof value === "object" && value !== null) return decorateObject(value);
-	return {
-		_tag: "Redacted",
-		[RedactedSymbol]: value,
-		[RedactedTagKey]: true,
-		[RedactedValueKey]: value,
-		toString: redactedString,
-		toJSON: redactedString,
-		[InspectSymbol]: redactedString
-	};
-};
-const value = (self) => {
-	if (RedactedSymbol in self) return self[RedactedSymbol];
-	if (RedactedValueKey in self) return self[RedactedValueKey];
-	return self;
-};
-const unsafeWipe = (self) => {
-	const current = value(self);
-	if (current instanceof Uint8Array) current.fill(0);
-	else if (typeof require__polyfill_buffer_patch.import_buffer.Buffer !== "undefined" && require__polyfill_buffer_patch.import_buffer.Buffer.isBuffer(current)) current.fill(0);
-	delete self[RedactedSymbol];
-	delete self[RedactedValueKey];
-};
-const isRedacted = (value) => typeof value === "object" && value !== null && ("_tag" in value && value._tag === "Redacted" || RedactedTagKey in value);
-const filterRedacted = (value) => {
-	if (isRedacted(value)) return "[REDACTED]";
-	if (typeof value !== "object" || value === null) return value;
-	if (Array.isArray(value)) return value.map(filterRedacted);
-	const filtered = {};
-	for (const key in value) filtered[key] = filterRedacted(value[key]);
-	return filtered;
-};
-const Redacted = {
-	make,
-	value,
-	unsafeWipe,
-	isRedacted,
-	filterRedacted
-};
-//#endregion
-Object.defineProperty(exports, "Redacted", {
-	enumerable: true,
-	get: function() {
-		return Redacted;
-	}
-});

package/dist/safe-buffer-B_vMqJWU.js

@@ -1,43 +0,0 @@
-import { i as __toCommonJS, t as __commonJSMin } from "./rolldown-runtime-OvD0k9op.js";
-import { r as init__polyfill_buffer_patch, t as _polyfill_buffer_patch_exports } from "./_polyfill-buffer-patch-yNxN4d5E.js";
-//#region ../../node_modules/safe-buffer/index.js
-var require_safe_buffer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
-	var buffer = (init__polyfill_buffer_patch(), __toCommonJS(_polyfill_buffer_patch_exports));
-	var Buffer = buffer.Buffer;
-	function copyProps(src, dst) {
-		for (var key in src) dst[key] = src[key];
-	}
-	if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) module.exports = buffer;
-	else {
-		copyProps(buffer, exports);
-		exports.Buffer = SafeBuffer;
-	}
-	function SafeBuffer(arg, encodingOrOffset, length) {
-		return Buffer(arg, encodingOrOffset, length);
-	}
-	SafeBuffer.prototype = Object.create(Buffer.prototype);
-	copyProps(Buffer, SafeBuffer);
-	SafeBuffer.from = function(arg, encodingOrOffset, length) {
-		if (typeof arg === "number") throw new TypeError("Argument must not be a number");
-		return Buffer(arg, encodingOrOffset, length);
-	};
-	SafeBuffer.alloc = function(size, fill, encoding) {
-		if (typeof size !== "number") throw new TypeError("Argument must be a number");
-		var buf = Buffer(size);
-		if (fill !== void 0) if (typeof encoding === "string") buf.fill(fill, encoding);
-		else buf.fill(fill);
-		else buf.fill(0);
-		return buf;
-	};
-	SafeBuffer.allocUnsafe = function(size) {
-		if (typeof size !== "number") throw new TypeError("Argument must be a number");
-		return Buffer(size);
-	};
-	SafeBuffer.allocUnsafeSlow = function(size) {
-		if (typeof size !== "number") throw new TypeError("Argument must be a number");
-		return buffer.SlowBuffer(size);
-	};
-}));
-//#endregion
-export { require_safe_buffer as t };

package/dist/safe-buffer-DYOwEfHB.cjs

@@ -1,48 +0,0 @@
-const require_rolldown_runtime = require("./rolldown-runtime-Br2OG8yv.cjs");
-const require__polyfill_buffer_patch = require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
-//#region ../../node_modules/safe-buffer/index.js
-var require_safe_buffer = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
-	/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
-	var buffer = (require__polyfill_buffer_patch.init__polyfill_buffer_patch(), require_rolldown_runtime.__toCommonJS(require__polyfill_buffer_patch._polyfill_buffer_patch_exports));
-	var Buffer = buffer.Buffer;
-	function copyProps(src, dst) {
-		for (var key in src) dst[key] = src[key];
-	}
-	if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) module.exports = buffer;
-	else {
-		copyProps(buffer, exports);
-		exports.Buffer = SafeBuffer;
-	}
-	function SafeBuffer(arg, encodingOrOffset, length) {
-		return Buffer(arg, encodingOrOffset, length);
-	}
-	SafeBuffer.prototype = Object.create(Buffer.prototype);
-	copyProps(Buffer, SafeBuffer);
-	SafeBuffer.from = function(arg, encodingOrOffset, length) {
-		if (typeof arg === "number") throw new TypeError("Argument must not be a number");
-		return Buffer(arg, encodingOrOffset, length);
-	};
-	SafeBuffer.alloc = function(size, fill, encoding) {
-		if (typeof size !== "number") throw new TypeError("Argument must be a number");
-		var buf = Buffer(size);
-		if (fill !== void 0) if (typeof encoding === "string") buf.fill(fill, encoding);
-		else buf.fill(fill);
-		else buf.fill(0);
-		return buf;
-	};
-	SafeBuffer.allocUnsafe = function(size) {
-		if (typeof size !== "number") throw new TypeError("Argument must be a number");
-		return Buffer(size);
-	};
-	SafeBuffer.allocUnsafeSlow = function(size) {
-		if (typeof size !== "number") throw new TypeError("Argument must be a number");
-		return buffer.SlowBuffer(size);
-	};
-}));
-//#endregion
-Object.defineProperty(exports, "require_safe_buffer", {
-	enumerable: true,
-	get: function() {
-		return require_safe_buffer;
-	}
-});