@samual/rolldown-plugin-prettier 0.0.1-7350a61 → 0.0.1-9e1d337

package/index.d.ts

@@ -1,29 +1,28 @@
-/**
- * @file Type definition for rollup-plugin-prettier
- */
-
-import type { Options as PrettierOptions } from 'prettier';
-import type { Plugin } from 'rolldown';
-
-declare namespace prettier {
-  interface Options extends PrettierOptions {
+import type { Plugin } from "rolldown";
+import type { Options as PrettierOptions } from "prettier";
+export interface Options extends PrettierOptions {
     /**
      * Directory to look for a Prettier config file.
      *
      * If omitted, defaults to `process.cwd()`.
      */
     cwd?: string;
-
     /**
      * Whether to generate a sourcemap.
      *
      * Note: This may take some time because rollup-plugin-prettier diffs the
      * output to manually generate a sourcemap.
      */
-    sourcemap?: boolean | 'silent';
-  }
+    sourcemap?: boolean | "silent";
+}
+declare namespace rollupPluginPrettier {
+    export { Options };
 }
-
-declare function prettier(options?: prettier.Options): Plugin;
-
-export = prettier;
+/**
+ * Create rollup plugin compatible with rollup >= 1.0.0
+ *
+ * @param options Plugin options.
+ * @return Plugin instance.
+ */
+declare function rollupPluginPrettier(options: Options): Plugin;
+export { rollupPluginPrettier as default };

package/index.js

@@ -1,10 +1,10 @@
-import { RollupPluginPrettier } from "./rollup-plugin-prettier.js"
+import { t as RollupPluginPrettier } from "./rollup-plugin-prettier-CPzeGZzX.js"
 function rollupPluginPrettier(options) {
 	const plugin = new RollupPluginPrettier(options)
 	return {
 		name: plugin.name,
-		renderChunk: (source, chunkInfo, outputOptions) =>
-			plugin.reformat(source, { sourcemap: outputOptions.sourcemap })
+		renderChunk: (source, _chunkInfo, outputOptions) =>
+			plugin.reformat(source, { sourcemap: !!outputOptions.sourcemap })
 	}
 }
 export { rollupPluginPrettier as default }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@samual/rolldown-plugin-prettier",
-	"version": "0.0.1-7350a61",
+	"version": "0.0.1-9e1d337",
 	"description": "Rolldown plugin for code formatting using Prettier",
 	"author": "Mickael Jeanroy <mickael.jeanroy@gmail.com>",
 	"contributors": [
@@ -28,11 +28,8 @@
 		".": "./index.js"
 	},
 	"dependencies": {
+		"@samual/assert": "0.0.1-da0fbad",
 		"diff": "^8",
-		"lodash.hasin": "^4",
-		"lodash.isempty": "^4",
-		"lodash.isnil": "^4",
-		"lodash.omitby": "^4",
 		"magic-string": "0.30.21",
 		"prettier": "^3",
 		"rolldown": "1.0.0-rc.6"

package/rollup-plugin-prettier-CPzeGZzX.js

@@ -0,0 +1,673 @@
+import { assert } from "@samual/assert"
+import * as diff from "diff"
+import MagicString from "magic-string"
+import path from "node:path"
+import prettier from "prettier"
+function isArrayLike(value) {
+	return (
+		null != value &&
+		"function" != typeof value &&
+		(function (value) {
+			return Number.isSafeInteger(value) && value >= 0
+		})(value.length)
+	)
+}
+function identity$1(x) {
+	return x
+}
+function isUnsafeProperty(key) {
+	return "__proto__" === key
+}
+function isDeepKey(key) {
+	switch (typeof key) {
+		case "number":
+		case "symbol":
+			return !1
+		case "string":
+			return key.includes(".") || key.includes("[") || key.includes("]")
+	}
+}
+function toKey(value) {
+	return "string" == typeof value || "symbol" == typeof value
+		? value
+		: Object.is(value?.valueOf?.(), -0)
+		? "-0"
+		: value + ""
+}
+function toString(value) {
+	if (null == value) return ""
+	if ("string" == typeof value) return value
+	if (Array.isArray(value)) return value.map(toString).join(",")
+	const result = value + ""
+	return "0" === result && Object.is(Number(value), -0) ? "-0" : result
+}
+function toPath(deepKey) {
+	if (Array.isArray(deepKey)) return deepKey.map(toKey)
+	if ("symbol" == typeof deepKey) return [deepKey]
+	const result = [],
+		length = (deepKey = toString(deepKey)).length
+	if (0 === length) return result
+	let index = 0,
+		key = "",
+		quoteChar = "",
+		bracket = !1
+	if (46 === deepKey.charCodeAt(0)) {
+		result.push("")
+		index++
+	}
+	for (; index < length; ) {
+		const char = deepKey[index]
+		if (quoteChar)
+			if ("\\" === char && index + 1 < length) {
+				index++
+				key += deepKey[index]
+			} else char === quoteChar ? (quoteChar = "") : (key += char)
+		else if (bracket)
+			if ('"' === char || "'" === char) quoteChar = char
+			else if ("]" === char) {
+				bracket = !1
+				result.push(key)
+				key = ""
+			} else key += char
+		else if ("[" === char) {
+			bracket = !0
+			if (key) {
+				result.push(key)
+				key = ""
+			}
+		} else if ("." === char) {
+			if (key) {
+				result.push(key)
+				key = ""
+			}
+		} else key += char
+		index++
+	}
+	key && result.push(key)
+	return result
+}
+function get(object, path, defaultValue) {
+	if (null == object) return defaultValue
+	switch (typeof path) {
+		case "string": {
+			if (isUnsafeProperty(path)) return defaultValue
+			const result = object[path]
+			return void 0 === result
+				? isDeepKey(path)
+					? get(object, toPath(path), defaultValue)
+					: defaultValue
+				: result
+		}
+		case "number":
+		case "symbol": {
+			"number" == typeof path && (path = toKey(path))
+			const result = object[path]
+			return void 0 === result ? defaultValue : result
+		}
+		default: {
+			if (Array.isArray(path))
+				return (function (object, path, defaultValue) {
+					if (0 === path.length) return defaultValue
+					let current = object
+					for (let index = 0; index < path.length; index++) {
+						if (null == current) return defaultValue
+						if (isUnsafeProperty(path[index])) return defaultValue
+						current = current[path[index]]
+					}
+					return void 0 === current ? defaultValue : current
+				})(object, path, defaultValue)
+			Object.is(path?.valueOf(), -0) ? (path = "-0") : (path += "")
+			if (isUnsafeProperty(path)) return defaultValue
+			const result = object[path]
+			return void 0 === result ? defaultValue : result
+		}
+	}
+}
+function isPrimitive(value) {
+	return null == value || ("object" != typeof value && "function" != typeof value)
+}
+function isEqualsSameValueZero(value, other) {
+	return value === other || (Number.isNaN(value) && Number.isNaN(other))
+}
+function isMatchWith(target, source, compare) {
+	return "function" != typeof compare
+		? isMatchWith(target, source, () => {})
+		: isMatchWithInternal(
+				target,
+				source,
+				function doesMatch(objValue, srcValue, key, object, source, stack) {
+					const isEqual = compare(objValue, srcValue, key, object, source, stack)
+					return void 0 !== isEqual ? !!isEqual : isMatchWithInternal(objValue, srcValue, doesMatch, stack)
+				},
+				new Map()
+		  )
+}
+function isMatchWithInternal(target, source, compare, stack) {
+	if (source === target) return !0
+	switch (typeof source) {
+		case "object":
+			return (function (target, source, compare, stack) {
+				if (null == source) return !0
+				if (Array.isArray(source)) return isArrayMatch(target, source, compare, stack)
+				if (source instanceof Map)
+					return (function (target, source, compare, stack) {
+						if (0 === source.size) return !0
+						if (!(target instanceof Map)) return !1
+						for (const [key, sourceValue] of source.entries())
+							if (!1 === compare(target.get(key), sourceValue, key, target, source, stack)) return !1
+						return !0
+					})(target, source, compare, stack)
+				if (source instanceof Set)
+					return (function (target, source, compare, stack) {
+						return (
+							0 === source.size ||
+							(target instanceof Set && isArrayMatch([...target], [...source], compare, stack))
+						)
+					})(target, source, compare, stack)
+				const keys = Object.keys(source)
+				if (null == target || isPrimitive(target)) return 0 === keys.length
+				if (0 === keys.length) return !0
+				if (stack?.has(source)) return stack.get(source) === target
+				stack?.set(source, target)
+				try {
+					for (let i = 0; i < keys.length; i++) {
+						const key = keys[i]
+						if (!isPrimitive(target) && !(key in target)) return !1
+						if (void 0 === source[key] && void 0 !== target[key]) return !1
+						if (null === source[key] && null !== target[key]) return !1
+						if (!compare(target[key], source[key], key, target, source, stack)) return !1
+					}
+					return !0
+				} finally {
+					stack?.delete(source)
+				}
+			})(target, source, compare, stack)
+		case "function":
+			return Object.keys(source).length > 0
+				? isMatchWithInternal(target, { ...source }, compare, stack)
+				: isEqualsSameValueZero(target, source)
+		default:
+			return null === (value = target) || ("object" != typeof value && "function" != typeof value)
+				? isEqualsSameValueZero(target, source)
+				: "string" != typeof source || "" === source
+	}
+	var value
+}
+function isArrayMatch(target, source, compare, stack) {
+	if (0 === source.length) return !0
+	if (!Array.isArray(target)) return !1
+	const countedIndex = new Set()
+	for (let i = 0; i < source.length; i++) {
+		const sourceItem = source[i]
+		let found = !1
+		for (let j = 0; j < target.length; j++) {
+			if (countedIndex.has(j)) continue
+			let matches = !1
+			compare(target[j], sourceItem, i, target, source, stack) && (matches = !0)
+			if (matches) {
+				countedIndex.add(j)
+				found = !0
+				break
+			}
+		}
+		if (!found) return !1
+	}
+	return !0
+}
+function isMatch(target, source) {
+	return isMatchWith(target, source, () => {})
+}
+function getSymbols(object) {
+	return Object.getOwnPropertySymbols(object).filter(symbol =>
+		Object.prototype.propertyIsEnumerable.call(object, symbol)
+	)
+}
+function getTag(value) {
+	return null == value
+		? void 0 === value
+			? "[object Undefined]"
+			: "[object Null]"
+		: Object.prototype.toString.call(value)
+}
+function isTypedArray$1(x) {
+	return ArrayBuffer.isView(x) && !(x instanceof DataView)
+}
+function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = new Map(), cloneValue = void 0) {
+	const cloned = cloneValue?.(valueToClone, keyToClone, objectToClone, stack)
+	if (void 0 !== cloned) return cloned
+	if (isPrimitive(valueToClone)) return valueToClone
+	if (stack.has(valueToClone)) return stack.get(valueToClone)
+	if (Array.isArray(valueToClone)) {
+		const result = Array(valueToClone.length)
+		stack.set(valueToClone, result)
+		for (let i = 0; i < valueToClone.length; i++)
+			result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue)
+		Object.hasOwn(valueToClone, "index") && (result.index = valueToClone.index)
+		Object.hasOwn(valueToClone, "input") && (result.input = valueToClone.input)
+		return result
+	}
+	if (valueToClone instanceof Date) return new Date(valueToClone.getTime())
+	if (valueToClone instanceof RegExp) {
+		const result = RegExp(valueToClone.source, valueToClone.flags)
+		result.lastIndex = valueToClone.lastIndex
+		return result
+	}
+	if (valueToClone instanceof Map) {
+		const result = new Map()
+		stack.set(valueToClone, result)
+		for (const [key, value] of valueToClone)
+			result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue))
+		return result
+	}
+	if (valueToClone instanceof Set) {
+		const result = new Set()
+		stack.set(valueToClone, result)
+		for (const value of valueToClone) result.add(cloneDeepWithImpl(value, void 0, objectToClone, stack, cloneValue))
+		return result
+	}
+	if ("undefined" != typeof Buffer && Buffer.isBuffer(valueToClone)) return valueToClone.subarray()
+	if (isTypedArray$1(valueToClone)) {
+		const result = new (Object.getPrototypeOf(valueToClone).constructor)(valueToClone.length)
+		stack.set(valueToClone, result)
+		for (let i = 0; i < valueToClone.length; i++)
+			result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue)
+		return result
+	}
+	if (
+		valueToClone instanceof ArrayBuffer ||
+		("undefined" != typeof SharedArrayBuffer && valueToClone instanceof SharedArrayBuffer)
+	)
+		return valueToClone.slice(0)
+	if (valueToClone instanceof DataView) {
+		const result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength)
+		stack.set(valueToClone, result)
+		copyProperties(result, valueToClone, objectToClone, stack, cloneValue)
+		return result
+	}
+	if ("undefined" != typeof File && valueToClone instanceof File) {
+		const result = new File([valueToClone], valueToClone.name, { type: valueToClone.type })
+		stack.set(valueToClone, result)
+		copyProperties(result, valueToClone, objectToClone, stack, cloneValue)
+		return result
+	}
+	if ("undefined" != typeof Blob && valueToClone instanceof Blob) {
+		const result = new Blob([valueToClone], { type: valueToClone.type })
+		stack.set(valueToClone, result)
+		copyProperties(result, valueToClone, objectToClone, stack, cloneValue)
+		return result
+	}
+	if (valueToClone instanceof Error) {
+		const result = new valueToClone.constructor()
+		stack.set(valueToClone, result)
+		result.message = valueToClone.message
+		result.name = valueToClone.name
+		result.stack = valueToClone.stack
+		result.cause = valueToClone.cause
+		copyProperties(result, valueToClone, objectToClone, stack, cloneValue)
+		return result
+	}
+	if (valueToClone instanceof Boolean) {
+		const result = new Boolean(valueToClone.valueOf())
+		stack.set(valueToClone, result)
+		copyProperties(result, valueToClone, objectToClone, stack, cloneValue)
+		return result
+	}
+	if (valueToClone instanceof Number) {
+		const result = new Number(valueToClone.valueOf())
+		stack.set(valueToClone, result)
+		copyProperties(result, valueToClone, objectToClone, stack, cloneValue)
+		return result
+	}
+	if (valueToClone instanceof String) {
+		const result = new String(valueToClone.valueOf())
+		stack.set(valueToClone, result)
+		copyProperties(result, valueToClone, objectToClone, stack, cloneValue)
+		return result
+	}
+	if (
+		"object" == typeof valueToClone &&
+		(function (object) {
+			switch (getTag(object)) {
+				case "[object Arguments]":
+				case "[object Array]":
+				case "[object ArrayBuffer]":
+				case "[object DataView]":
+				case "[object Boolean]":
+				case "[object Date]":
+				case "[object Float32Array]":
+				case "[object Float64Array]":
+				case "[object Int8Array]":
+				case "[object Int16Array]":
+				case "[object Int32Array]":
+				case "[object Map]":
+				case "[object Number]":
+				case "[object Object]":
+				case "[object RegExp]":
+				case "[object Set]":
+				case "[object String]":
+				case "[object Symbol]":
+				case "[object Uint8Array]":
+				case "[object Uint8ClampedArray]":
+				case "[object Uint16Array]":
+				case "[object Uint32Array]":
+					return !0
+				default:
+					return !1
+			}
+		})(valueToClone)
+	) {
+		const result = Object.create(Object.getPrototypeOf(valueToClone))
+		stack.set(valueToClone, result)
+		copyProperties(result, valueToClone, objectToClone, stack, cloneValue)
+		return result
+	}
+	return valueToClone
+}
+function copyProperties(target, source, objectToClone = target, stack, cloneValue) {
+	const keys = [...Object.keys(source), ...getSymbols(source)]
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i],
+			descriptor = Object.getOwnPropertyDescriptor(target, key)
+		;(null == descriptor || descriptor.writable) &&
+			(target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue))
+	}
+}
+const IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/
+function isIndex(value, length = Number.MAX_SAFE_INTEGER) {
+	switch (typeof value) {
+		case "number":
+			return Number.isInteger(value) && value >= 0 && value < length
+		case "symbol":
+			return !1
+		case "string":
+			return IS_UNSIGNED_INTEGER.test(value)
+	}
+}
+function isArguments(value) {
+	return null !== value && "object" == typeof value && "[object Arguments]" === getTag(value)
+}
+function isSymbol(value) {
+	return "symbol" == typeof value || value instanceof Symbol
+}
+function identity(x) {
+	return x
+}
+function isPrototype(value) {
+	const constructor = value?.constructor
+	return value === ("function" == typeof constructor ? constructor.prototype : Object.prototype)
+}
+function isTypedArray(x) {
+	return isTypedArray$1(x)
+}
+function keysIn(object) {
+	if (null == object) return []
+	switch (typeof object) {
+		case "object":
+		case "function":
+			return isArrayLike(object)
+				? (function (object) {
+						const indices = (function (n, getValue) {
+								if (
+									(n = (function (value) {
+										const finite = (function (value) {
+												return value
+													? Infinity ===
+															(value = (function (value) {
+																return isSymbol(value) ? NaN : Number(value)
+															})(value)) || -Infinity === value
+														? (value < 0 ? -1 : 1) * Number.MAX_VALUE
+														: value == value
+														? value
+														: 0
+													: 0 === value
+													? value
+													: 0
+											})(value),
+											remainder = finite % 1
+										return remainder ? finite - remainder : finite
+									})(n)) < 1 ||
+									!Number.isSafeInteger(n)
+								)
+									return []
+								const result = Array(n)
+								for (let i = 0; i < n; i++) result[i] = getValue(i)
+								return result
+							})(object.length, index => "" + index),
+							filteredKeys = new Set(indices)
+						if (((x = object), "undefined" != typeof Buffer && Buffer.isBuffer(x))) {
+							filteredKeys.add("offset")
+							filteredKeys.add("parent")
+						}
+						var x
+						if (isTypedArray(object)) {
+							filteredKeys.add("buffer")
+							filteredKeys.add("byteLength")
+							filteredKeys.add("byteOffset")
+						}
+						const inheritedKeys = keysInImpl(object).filter(key => !filteredKeys.has(key))
+						return Array.isArray(object)
+							? [...indices, ...inheritedKeys]
+							: [...indices.filter(index => Object.hasOwn(object, index)), ...inheritedKeys]
+				  })(object)
+				: isPrototype(object)
+				? (function (object) {
+						return keysInImpl(object).filter(key => "constructor" !== key)
+				  })(object)
+				: keysInImpl(object)
+		default:
+			return keysInImpl(Object(object))
+	}
+}
+function keysInImpl(object) {
+	const result = []
+	for (const key in object) result.push(key)
+	return result
+}
+function getSymbolsIn(object) {
+	const result = []
+	for (; object; ) {
+		result.push(...getSymbols(object))
+		object = Object.getPrototypeOf(object)
+	}
+	return result
+}
+const OPTIONS = new Set(["sourcemap", "cwd"])
+function resolvePrettierConfig(cwd) {
+	const fromFile = path.join(cwd, "__noop__.js")
+	return prettier.resolveConfig ? prettier.resolveConfig(fromFile) : Promise.resolve(null)
+}
+var RollupPluginPrettier = class {
+	_options
+	_sourcemap
+	constructor(options = {}) {
+		this._options = Promise.resolve(
+			(function (object) {
+				if (null == object) return {}
+				const result = {},
+					predicate = (function (value) {
+						if (null == value) return identity$1
+						switch (typeof value) {
+							case "function":
+								return value
+							case "object":
+								return Array.isArray(value) && 2 === value.length
+									? (function (property, source) {
+											switch (typeof property) {
+												case "object":
+													Object.is(property?.valueOf(), -0) && (property = "-0")
+													break
+												case "number":
+													property = toKey(property)
+											}
+											source = (function (obj, cloneValue) {
+												return cloneDeepWithImpl(obj, void 0, obj, new Map(), cloneValue)
+											})((obj = source), (value, key, object, stack) => {
+												if ("object" == typeof obj) {
+													if (
+														"[object Object]" === getTag(obj) &&
+														"function" != typeof obj.constructor
+													) {
+														const result = {}
+														stack.set(obj, result)
+														copyProperties(result, obj, object, stack)
+														return result
+													}
+													switch (Object.prototype.toString.call(obj)) {
+														case "[object Number]":
+														case "[object String]":
+														case "[object Boolean]": {
+															const result = new obj.constructor(obj?.valueOf())
+															copyProperties(result, obj)
+															return result
+														}
+														case "[object Arguments]": {
+															const result = {}
+															copyProperties(result, obj)
+															result.length = obj.length
+															result[Symbol.iterator] = obj[Symbol.iterator]
+															return result
+														}
+														default:
+															return
+													}
+												}
+											})
+											var obj
+											return function (target) {
+												const result = get(target, property)
+												return void 0 === result
+													? (function (object, path) {
+															let resolvedPath
+															resolvedPath = Array.isArray(path)
+																? path
+																: "string" == typeof path &&
+																  isDeepKey(path) &&
+																  null == object?.[path]
+																? toPath(path)
+																: [path]
+															if (0 === resolvedPath.length) return !1
+															let current = object
+															for (let i = 0; i < resolvedPath.length; i++) {
+																const key = resolvedPath[i]
+																if (
+																	!(
+																		(null != current &&
+																			Object.hasOwn(current, key)) ||
+																		((Array.isArray(current) ||
+																			isArguments(current)) &&
+																			isIndex(key) &&
+																			key < current.length)
+																	)
+																)
+																	return !1
+																current = current[key]
+															}
+															return !0
+													  })(target, property)
+													: void 0 === source
+													? void 0 === result
+													: isMatch(result, source)
+											}
+									  })(value[0], value[1])
+									: (function (source) {
+											source = cloneDeepWithImpl((obj = source), void 0, obj, new Map(), void 0)
+											var obj
+											return target => isMatch(target, source)
+									  })(value)
+							case "string":
+							case "symbol":
+							case "number":
+								return (function (path) {
+									return function (object) {
+										return get(object, path)
+									}
+								})(value)
+						}
+					})(((_value, key) => OPTIONS.has(key)) ?? identity),
+					keys = isArrayLike(object)
+						? (function (start, end, step = 1) {
+								if (null == end) {
+									end = start
+									start = 0
+								}
+								if (!Number.isInteger(step) || 0 === step)
+									throw Error("The step value must be a non-zero integer.")
+								const length = Math.max(Math.ceil((end - start) / step), 0),
+									result = Array(length)
+								for (let i = 0; i < length; i++) result[i] = start + i * step
+								return result
+						  })(0, object.length)
+						: [...keysIn(object), ...getSymbolsIn(object)]
+				for (let i = 0; i < keys.length; i++) {
+					const key = isSymbol(keys[i]) ? keys[i] : keys[i].toString(),
+						value = object[key]
+					predicate(value, key, object) || (result[key] = value)
+				}
+				return result
+			})(options)
+		)
+		const cwd = "cwd" in options ? options.cwd : process.cwd()
+		this._options = Promise.all([resolvePrettierConfig(cwd), this._options]).then(results =>
+			Object.assign({}, ...results.map(result => result || {}))
+		)
+		this._options = this._options.then(opts =>
+			(function (value) {
+				if (null == value) return !0
+				if (isArrayLike(value))
+					return (
+						!!(
+							"function" == typeof value.splice ||
+							"string" == typeof value ||
+							("undefined" != typeof Buffer && Buffer.isBuffer(value)) ||
+							isTypedArray(value) ||
+							isArguments(value)
+						) && 0 === value.length
+					)
+				if ("object" == typeof value) {
+					if (value instanceof Map || value instanceof Set) return 0 === value.size
+					const keys = Object.keys(value)
+					return isPrototype(value) ? 0 === keys.filter(x => "constructor" !== x).length : 0 === keys.length
+				}
+				return !0
+			})(opts)
+				? void 0
+				: opts
+		)
+		this._sourcemap = "sourcemap" in options ? options.sourcemap : null
+	}
+	getSourcemap() {
+		return this._sourcemap
+	}
+	enableSourcemap() {
+		this._sourcemap = !0
+	}
+	async reformat(source, outputOptions) {
+		return this._reformat(source, outputOptions, await this._options)
+	}
+	async _reformat(source, outputOptions, options) {
+		return this._processOutput(source, outputOptions?.sourcemap, await prettier.format(source, options))
+	}
+	_processOutput(source, sourcemap, output) {
+		const defaultSourcemap = null != this._sourcemap && this._sourcemap
+		if (!(sourcemap ?? defaultSourcemap)) return { code: output }
+		if ("silent" !== defaultSourcemap) {
+			console.warn(`[${this.name}] Sourcemap is enabled, computing diff is required`)
+			console.warn(`[${this.name}] This may take a moment (depends on the size of your bundle)`)
+		}
+		const magicString = new MagicString(source),
+			changes = diff.diffChars(source, output)
+		if (changes && changes.length > 0) {
+			let idx = 0
+			changes.forEach(part => {
+				if (part.added) {
+					magicString.prependLeft(idx, part.value)
+					idx -= part.count
+				} else part.removed && magicString.remove(idx, idx + part.count)
+				idx += part.count
+			})
+		}
+		return { code: magicString.toString(), map: magicString.generateMap({ hires: !0 }) }
+	}
+}
+assert(Reflect.defineProperty(RollupPluginPrettier.prototype, "name", { value: "rolldown-plugin-prettier" }))
+export { RollupPluginPrettier as t }

package/rollup-plugin-prettier.d.ts

@@ -0,0 +1,71 @@
+import type { SourceMapInput } from "rolldown";
+import type { Options } from ".";
+/**
+ * The plugin.
+ *
+ * @class
+ */
+export declare class RollupPluginPrettier {
+    name: string;
+    _options: Promise<Partial<Options> | undefined>;
+    _sourcemap: boolean | `silent` | null;
+    /**
+     * Initialize plugin & prettier.
+     *
+     * @param options Initalization option.
+     */
+    constructor(options?: Options);
+    /**
+     * Get the `sourcemap` value.
+     *
+     * @return The `sourcemap` flag value.
+     */
+    getSourcemap(): boolean | "silent" | null;
+    /**
+     * Disable sourcemap.
+     */
+    enableSourcemap(): void;
+    /**
+     * Reformat source code using prettier.
+     *
+     * @param source The source code to reformat.
+     * @param outputOptions Output options.
+     * @return The transformation result.
+     */
+    reformat(source: string, outputOptions?: {
+        sourcemap: boolean;
+    }): Promise<{
+        code: string;
+        map?: SourceMapInput;
+    }>;
+    /**
+     * Reformat source code using prettier.
+     *
+     * @param source The source code to reformat.
+     * @param outputOptions Output options.
+     * @param options Prettier options.
+     * @returns The reformat response.
+     * @private
+     */
+    _reformat(source: string, outputOptions?: {
+        sourcemap: boolean;
+    }, options?: object): Promise<{
+        code: string;
+        map?: SourceMapInput;
+    }>;
+    /**
+     * Process output generated by prettier:
+     * - Generate sourcemap if need be.
+     * - Otherwise returns prettier output as chunk output.
+     *
+     * @param source The source code to reformat.
+     * @param sourcemap If sourcemap should be generated or not.
+     * @param output Prettier output.
+     * @returns The reformat response.
+     * @private
+     */
+    _processOutput(source: string, sourcemap: boolean | undefined | null, output: string): {
+        code: string;
+        map?: SourceMapInput;
+    };
+}

package/rollup-plugin-prettier.js

@@ -1,66 +1,2 @@
-import path from "node:path"
-import hasIn from "lodash.hasin"
-import isEmpty from "lodash.isempty"
-import isNil from "lodash.isnil"
-import omitBy from "lodash.omitby"
-import MagicString from "magic-string"
-import * as diff from "diff"
-import prettier from "prettier"
-const OPTIONS = new Set(["sourcemap", "cwd"])
-function resolvePrettierConfig(cwd) {
-	const fromFile = path.join(cwd, "__noop__.js")
-	return prettier.resolveConfig
-		? prettier.resolveConfig(fromFile)
-		: prettier.resolveConfigSync
-		? Promise.resolve(prettier.resolveConfigSync(cwd))
-		: Promise.resolve(null)
-}
-var RollupPluginPrettier = class {
-	constructor(options = {}) {
-		this.name = "rollup-plugin-prettier"
-		this._options = Promise.resolve(omitBy(options, (value, key) => OPTIONS.has(key)))
-		const cwd = hasIn(options, "cwd") ? options.cwd : process.cwd()
-		this._options = Promise.all([resolvePrettierConfig(cwd), this._options]).then(results =>
-			Object.assign({}, ...results.map(result => result || {}))
-		)
-		this._options = this._options.then(opts => (isEmpty(opts) ? void 0 : opts))
-		this._sourcemap = hasIn(options, "sourcemap") ? options.sourcemap : null
-	}
-	getSourcemap() {
-		return this._sourcemap
-	}
-	enableSourcemap() {
-		this._sourcemap = !0
-	}
-	reformat(source, outputOptions) {
-		return this._options.then(options => this._reformat(source, outputOptions, options))
-	}
-	_reformat(source, outputOptions, options) {
-		const { sourcemap } = outputOptions || {}
-		return Promise.resolve(prettier.format(source, options)).then(output =>
-			this._processOutput(source, sourcemap, output)
-		)
-	}
-	_processOutput(source, sourcemap, output) {
-		const defaultSourcemap = !isNil(this._sourcemap) && this._sourcemap
-		if (!(isNil(sourcemap) ? defaultSourcemap : sourcemap)) return { code: output }
-		if ("silent" !== defaultSourcemap) {
-			console.warn(`[${this.name}] Sourcemap is enabled, computing diff is required`)
-			console.warn(`[${this.name}] This may take a moment (depends on the size of your bundle)`)
-		}
-		const magicString = new MagicString(source),
-			changes = diff.diffChars(source, output)
-		if (changes && changes.length > 0) {
-			let idx = 0
-			changes.forEach(part => {
-				if (part.added) {
-					magicString.prependLeft(idx, part.value)
-					idx -= part.count
-				} else part.removed && magicString.remove(idx, idx + part.count)
-				idx += part.count
-			})
-		}
-		return { code: magicString.toString(), map: magicString.generateMap({ hires: !0 }) }
-	}
-}
+import { t as RollupPluginPrettier } from "./rollup-plugin-prettier-CPzeGZzX.js"
 export { RollupPluginPrettier }