You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3884 lines
122 KiB
3884 lines
122 KiB
import { createRequire as __prettierCreateRequire } from "module"; |
|
import { fileURLToPath as __prettierFileUrlToPath } from "url"; |
|
import { dirname as __prettierDirname } from "path"; |
|
const require = __prettierCreateRequire(import.meta.url); |
|
const __filename = __prettierFileUrlToPath(import.meta.url); |
|
const __dirname = __prettierDirname(__filename); |
|
|
|
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 __typeError = (msg) => { |
|
throw TypeError(msg); |
|
}; |
|
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { |
|
get: (a, b) => (typeof require !== "undefined" ? require : a)[b] |
|
}) : x)(function(x) { |
|
if (typeof require !== "undefined") return require.apply(this, arguments); |
|
throw Error('Dynamic require of "' + x + '" is not supported'); |
|
}); |
|
var __commonJS = (cb, mod) => function __require2() { |
|
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; |
|
}; |
|
var __copyProps = (to, from, except, desc) => { |
|
if (from && typeof from === "object" || typeof from === "function") { |
|
for (let key of __getOwnPropNames(from)) |
|
if (!__hasOwnProp.call(to, key) && key !== except) |
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); |
|
} |
|
return to; |
|
}; |
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( |
|
// If the importer is in node compatibility mode or this is not an ESM |
|
// file that has been converted to a CommonJS file using a Babel- |
|
// compatible transform (i.e. "__esModule" has not been set), then set |
|
// "default" to the CommonJS "module.exports" for node compatibility. |
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, |
|
mod |
|
)); |
|
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg); |
|
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj)); |
|
var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value); |
|
var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value); |
|
|
|
// node_modules/dashify/index.js |
|
var require_dashify = __commonJS({ |
|
"node_modules/dashify/index.js"(exports, module) { |
|
"use strict"; |
|
module.exports = (str, options) => { |
|
if (typeof str !== "string") throw new TypeError("expected a string"); |
|
return str.trim().replace(/([a-z])([A-Z])/g, "$1-$2").replace(/\W/g, (m) => /[À-ž]/.test(m) ? m : "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, (m) => options && options.condense ? "-" : m).toLowerCase(); |
|
}; |
|
} |
|
}); |
|
|
|
// node_modules/minimist/index.js |
|
var require_minimist = __commonJS({ |
|
"node_modules/minimist/index.js"(exports, module) { |
|
"use strict"; |
|
function hasKey(obj, keys) { |
|
var o = obj; |
|
keys.slice(0, -1).forEach(function(key2) { |
|
o = o[key2] || {}; |
|
}); |
|
var key = keys[keys.length - 1]; |
|
return key in o; |
|
} |
|
function isNumber(x) { |
|
if (typeof x === "number") { |
|
return true; |
|
} |
|
if (/^0x[0-9a-f]+$/i.test(x)) { |
|
return true; |
|
} |
|
return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x); |
|
} |
|
function isConstructorOrProto(obj, key) { |
|
return key === "constructor" && typeof obj[key] === "function" || key === "__proto__"; |
|
} |
|
module.exports = function(args, opts) { |
|
if (!opts) { |
|
opts = {}; |
|
} |
|
var flags = { |
|
bools: {}, |
|
strings: {}, |
|
unknownFn: null |
|
}; |
|
if (typeof opts.unknown === "function") { |
|
flags.unknownFn = opts.unknown; |
|
} |
|
if (typeof opts.boolean === "boolean" && opts.boolean) { |
|
flags.allBools = true; |
|
} else { |
|
[].concat(opts.boolean).filter(Boolean).forEach(function(key2) { |
|
flags.bools[key2] = true; |
|
}); |
|
} |
|
var aliases = {}; |
|
function aliasIsBoolean(key2) { |
|
return aliases[key2].some(function(x) { |
|
return flags.bools[x]; |
|
}); |
|
} |
|
Object.keys(opts.alias || {}).forEach(function(key2) { |
|
aliases[key2] = [].concat(opts.alias[key2]); |
|
aliases[key2].forEach(function(x) { |
|
aliases[x] = [key2].concat(aliases[key2].filter(function(y) { |
|
return x !== y; |
|
})); |
|
}); |
|
}); |
|
[].concat(opts.string).filter(Boolean).forEach(function(key2) { |
|
flags.strings[key2] = true; |
|
if (aliases[key2]) { |
|
[].concat(aliases[key2]).forEach(function(k) { |
|
flags.strings[k] = true; |
|
}); |
|
} |
|
}); |
|
var defaults = opts.default || {}; |
|
var argv = { _: [] }; |
|
function argDefined(key2, arg2) { |
|
return flags.allBools && /^--[^=]+$/.test(arg2) || flags.strings[key2] || flags.bools[key2] || aliases[key2]; |
|
} |
|
function setKey(obj, keys, value2) { |
|
var o = obj; |
|
for (var i2 = 0; i2 < keys.length - 1; i2++) { |
|
var key2 = keys[i2]; |
|
if (isConstructorOrProto(o, key2)) { |
|
return; |
|
} |
|
if (o[key2] === void 0) { |
|
o[key2] = {}; |
|
} |
|
if (o[key2] === Object.prototype || o[key2] === Number.prototype || o[key2] === String.prototype) { |
|
o[key2] = {}; |
|
} |
|
if (o[key2] === Array.prototype) { |
|
o[key2] = []; |
|
} |
|
o = o[key2]; |
|
} |
|
var lastKey = keys[keys.length - 1]; |
|
if (isConstructorOrProto(o, lastKey)) { |
|
return; |
|
} |
|
if (o === Object.prototype || o === Number.prototype || o === String.prototype) { |
|
o = {}; |
|
} |
|
if (o === Array.prototype) { |
|
o = []; |
|
} |
|
if (o[lastKey] === void 0 || flags.bools[lastKey] || typeof o[lastKey] === "boolean") { |
|
o[lastKey] = value2; |
|
} else if (Array.isArray(o[lastKey])) { |
|
o[lastKey].push(value2); |
|
} else { |
|
o[lastKey] = [o[lastKey], value2]; |
|
} |
|
} |
|
function setArg(key2, val, arg2) { |
|
if (arg2 && flags.unknownFn && !argDefined(key2, arg2)) { |
|
if (flags.unknownFn(arg2) === false) { |
|
return; |
|
} |
|
} |
|
var value2 = !flags.strings[key2] && isNumber(val) ? Number(val) : val; |
|
setKey(argv, key2.split("."), value2); |
|
(aliases[key2] || []).forEach(function(x) { |
|
setKey(argv, x.split("."), value2); |
|
}); |
|
} |
|
Object.keys(flags.bools).forEach(function(key2) { |
|
setArg(key2, defaults[key2] === void 0 ? false : defaults[key2]); |
|
}); |
|
var notFlags = []; |
|
if (args.indexOf("--") !== -1) { |
|
notFlags = args.slice(args.indexOf("--") + 1); |
|
args = args.slice(0, args.indexOf("--")); |
|
} |
|
for (var i = 0; i < args.length; i++) { |
|
var arg = args[i]; |
|
var key; |
|
var next; |
|
if (/^--.+=/.test(arg)) { |
|
var m = arg.match(/^--([^=]+)=([\s\S]*)$/); |
|
key = m[1]; |
|
var value = m[2]; |
|
if (flags.bools[key]) { |
|
value = value !== "false"; |
|
} |
|
setArg(key, value, arg); |
|
} else if (/^--no-.+/.test(arg)) { |
|
key = arg.match(/^--no-(.+)/)[1]; |
|
setArg(key, false, arg); |
|
} else if (/^--.+/.test(arg)) { |
|
key = arg.match(/^--(.+)/)[1]; |
|
next = args[i + 1]; |
|
if (next !== void 0 && !/^(-|--)[^-]/.test(next) && !flags.bools[key] && !flags.allBools && (aliases[key] ? !aliasIsBoolean(key) : true)) { |
|
setArg(key, next, arg); |
|
i += 1; |
|
} else if (/^(true|false)$/.test(next)) { |
|
setArg(key, next === "true", arg); |
|
i += 1; |
|
} else { |
|
setArg(key, flags.strings[key] ? "" : true, arg); |
|
} |
|
} else if (/^-[^-]+/.test(arg)) { |
|
var letters = arg.slice(1, -1).split(""); |
|
var broken = false; |
|
for (var j = 0; j < letters.length; j++) { |
|
next = arg.slice(j + 2); |
|
if (next === "-") { |
|
setArg(letters[j], next, arg); |
|
continue; |
|
} |
|
if (/[A-Za-z]/.test(letters[j]) && next[0] === "=") { |
|
setArg(letters[j], next.slice(1), arg); |
|
broken = true; |
|
break; |
|
} |
|
if (/[A-Za-z]/.test(letters[j]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) { |
|
setArg(letters[j], next, arg); |
|
broken = true; |
|
break; |
|
} |
|
if (letters[j + 1] && letters[j + 1].match(/\W/)) { |
|
setArg(letters[j], arg.slice(j + 2), arg); |
|
broken = true; |
|
break; |
|
} else { |
|
setArg(letters[j], flags.strings[letters[j]] ? "" : true, arg); |
|
} |
|
} |
|
key = arg.slice(-1)[0]; |
|
if (!broken && key !== "-") { |
|
if (args[i + 1] && !/^(-|--)[^-]/.test(args[i + 1]) && !flags.bools[key] && (aliases[key] ? !aliasIsBoolean(key) : true)) { |
|
setArg(key, args[i + 1], arg); |
|
i += 1; |
|
} else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) { |
|
setArg(key, args[i + 1] === "true", arg); |
|
i += 1; |
|
} else { |
|
setArg(key, flags.strings[key] ? "" : true, arg); |
|
} |
|
} |
|
} else { |
|
if (!flags.unknownFn || flags.unknownFn(arg) !== false) { |
|
argv._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg)); |
|
} |
|
if (opts.stopEarly) { |
|
argv._.push.apply(argv._, args.slice(i + 1)); |
|
break; |
|
} |
|
} |
|
} |
|
Object.keys(defaults).forEach(function(k) { |
|
if (!hasKey(argv, k.split("."))) { |
|
setKey(argv, k.split("."), defaults[k]); |
|
(aliases[k] || []).forEach(function(x) { |
|
setKey(argv, x.split("."), defaults[k]); |
|
}); |
|
} |
|
}); |
|
if (opts["--"]) { |
|
argv["--"] = notFlags.slice(); |
|
} else { |
|
notFlags.forEach(function(k) { |
|
argv._.push(k); |
|
}); |
|
} |
|
return argv; |
|
}; |
|
} |
|
}); |
|
|
|
// node_modules/fast-json-stable-stringify/index.js |
|
var require_fast_json_stable_stringify = __commonJS({ |
|
"node_modules/fast-json-stable-stringify/index.js"(exports, module) { |
|
"use strict"; |
|
module.exports = function(data, opts) { |
|
if (!opts) opts = {}; |
|
if (typeof opts === "function") opts = { cmp: opts }; |
|
var cycles = typeof opts.cycles === "boolean" ? opts.cycles : false; |
|
var cmp = opts.cmp && /* @__PURE__ */ function(f) { |
|
return function(node) { |
|
return function(a, b) { |
|
var aobj = { key: a, value: node[a] }; |
|
var bobj = { key: b, value: node[b] }; |
|
return f(aobj, bobj); |
|
}; |
|
}; |
|
}(opts.cmp); |
|
var seen = []; |
|
return function stringify4(node) { |
|
if (node && node.toJSON && typeof node.toJSON === "function") { |
|
node = node.toJSON(); |
|
} |
|
if (node === void 0) return; |
|
if (typeof node == "number") return isFinite(node) ? "" + node : "null"; |
|
if (typeof node !== "object") return JSON.stringify(node); |
|
var i, out; |
|
if (Array.isArray(node)) { |
|
out = "["; |
|
for (i = 0; i < node.length; i++) { |
|
if (i) out += ","; |
|
out += stringify4(node[i]) || "null"; |
|
} |
|
return out + "]"; |
|
} |
|
if (node === null) return "null"; |
|
if (seen.indexOf(node) !== -1) { |
|
if (cycles) return JSON.stringify("__cycle__"); |
|
throw new TypeError("Converting circular structure to JSON"); |
|
} |
|
var seenIndex = seen.push(node) - 1; |
|
var keys = Object.keys(node).sort(cmp && cmp(node)); |
|
out = ""; |
|
for (i = 0; i < keys.length; i++) { |
|
var key = keys[i]; |
|
var value = stringify4(node[key]); |
|
if (!value) continue; |
|
if (out) out += ","; |
|
out += JSON.stringify(key) + ":" + value; |
|
} |
|
seen.splice(seenIndex, 1); |
|
return "{" + out + "}"; |
|
}(data); |
|
}; |
|
} |
|
}); |
|
|
|
// node_modules/common-path-prefix/index.js |
|
var require_common_path_prefix = __commonJS({ |
|
"node_modules/common-path-prefix/index.js"(exports, module) { |
|
"use strict"; |
|
var { sep: DEFAULT_SEPARATOR } = __require("path"); |
|
var determineSeparator = (paths) => { |
|
for (const path10 of paths) { |
|
const match = /(\/|\\)/.exec(path10); |
|
if (match !== null) return match[0]; |
|
} |
|
return DEFAULT_SEPARATOR; |
|
}; |
|
module.exports = function commonPathPrefix2(paths, sep = determineSeparator(paths)) { |
|
const [first = "", ...remaining] = paths; |
|
if (first === "" || remaining.length === 0) return ""; |
|
const parts = first.split(sep); |
|
let endOfPrefix = parts.length; |
|
for (const path10 of remaining) { |
|
const compare = path10.split(sep); |
|
for (let i = 0; i < endOfPrefix; i++) { |
|
if (compare[i] !== parts[i]) { |
|
endOfPrefix = i; |
|
} |
|
} |
|
if (endOfPrefix === 0) return ""; |
|
} |
|
const prefix = parts.slice(0, endOfPrefix).join(sep); |
|
return prefix.endsWith(sep) ? prefix : prefix + sep; |
|
}; |
|
} |
|
}); |
|
|
|
// node_modules/json-buffer/index.js |
|
var require_json_buffer = __commonJS({ |
|
"node_modules/json-buffer/index.js"(exports) { |
|
exports.stringify = function stringify4(o) { |
|
if ("undefined" == typeof o) return o; |
|
if (o && Buffer.isBuffer(o)) |
|
return JSON.stringify(":base64:" + o.toString("base64")); |
|
if (o && o.toJSON) |
|
o = o.toJSON(); |
|
if (o && "object" === typeof o) { |
|
var s = ""; |
|
var array2 = Array.isArray(o); |
|
s = array2 ? "[" : "{"; |
|
var first = true; |
|
for (var k in o) { |
|
var ignore = "function" == typeof o[k] || !array2 && "undefined" === typeof o[k]; |
|
if (Object.hasOwnProperty.call(o, k) && !ignore) { |
|
if (!first) |
|
s += ","; |
|
first = false; |
|
if (array2) { |
|
if (o[k] == void 0) |
|
s += "null"; |
|
else |
|
s += stringify4(o[k]); |
|
} else if (o[k] !== void 0) { |
|
s += stringify4(k) + ":" + stringify4(o[k]); |
|
} |
|
} |
|
} |
|
s += array2 ? "]" : "}"; |
|
return s; |
|
} else if ("string" === typeof o) { |
|
return JSON.stringify(/^:/.test(o) ? ":" + o : o); |
|
} else if ("undefined" === typeof o) { |
|
return "null"; |
|
} else |
|
return JSON.stringify(o); |
|
}; |
|
exports.parse = function(s) { |
|
return JSON.parse(s, function(key, value) { |
|
if ("string" === typeof value) { |
|
if (/^:base64:/.test(value)) |
|
return Buffer.from(value.substring(8), "base64"); |
|
else |
|
return /^:/.test(value) ? value.substring(1) : value; |
|
} |
|
return value; |
|
}); |
|
}; |
|
} |
|
}); |
|
|
|
// node_modules/keyv/src/index.js |
|
var require_src = __commonJS({ |
|
"node_modules/keyv/src/index.js"(exports, module) { |
|
"use strict"; |
|
var EventEmitter = __require("events"); |
|
var JSONB = require_json_buffer(); |
|
var loadStore = (options) => { |
|
const adapters = { |
|
redis: "@keyv/redis", |
|
rediss: "@keyv/redis", |
|
mongodb: "@keyv/mongo", |
|
mongo: "@keyv/mongo", |
|
sqlite: "@keyv/sqlite", |
|
postgresql: "@keyv/postgres", |
|
postgres: "@keyv/postgres", |
|
mysql: "@keyv/mysql", |
|
etcd: "@keyv/etcd", |
|
offline: "@keyv/offline", |
|
tiered: "@keyv/tiered" |
|
}; |
|
if (options.adapter || options.uri) { |
|
const adapter = options.adapter || /^[^:+]*/.exec(options.uri)[0]; |
|
return new (__require(adapters[adapter]))(options); |
|
} |
|
return /* @__PURE__ */ new Map(); |
|
}; |
|
var iterableAdapters = [ |
|
"sqlite", |
|
"postgres", |
|
"mysql", |
|
"mongo", |
|
"redis", |
|
"tiered" |
|
]; |
|
var Keyv = class extends EventEmitter { |
|
constructor(uri, { emitErrors = true, ...options } = {}) { |
|
super(); |
|
this.opts = { |
|
namespace: "keyv", |
|
serialize: JSONB.stringify, |
|
deserialize: JSONB.parse, |
|
...typeof uri === "string" ? { uri } : uri, |
|
...options |
|
}; |
|
if (!this.opts.store) { |
|
const adapterOptions = { ...this.opts }; |
|
this.opts.store = loadStore(adapterOptions); |
|
} |
|
if (this.opts.compression) { |
|
const compression = this.opts.compression; |
|
this.opts.serialize = compression.serialize.bind(compression); |
|
this.opts.deserialize = compression.deserialize.bind(compression); |
|
} |
|
if (typeof this.opts.store.on === "function" && emitErrors) { |
|
this.opts.store.on("error", (error) => this.emit("error", error)); |
|
} |
|
this.opts.store.namespace = this.opts.namespace; |
|
const generateIterator = (iterator) => async function* () { |
|
for await (const [key, raw] of typeof iterator === "function" ? iterator(this.opts.store.namespace) : iterator) { |
|
const data = await this.opts.deserialize(raw); |
|
if (this.opts.store.namespace && !key.includes(this.opts.store.namespace)) { |
|
continue; |
|
} |
|
if (typeof data.expires === "number" && Date.now() > data.expires) { |
|
this.delete(key); |
|
continue; |
|
} |
|
yield [this._getKeyUnprefix(key), data.value]; |
|
} |
|
}; |
|
if (typeof this.opts.store[Symbol.iterator] === "function" && this.opts.store instanceof Map) { |
|
this.iterator = generateIterator(this.opts.store); |
|
} else if (typeof this.opts.store.iterator === "function" && this.opts.store.opts && this._checkIterableAdaptar()) { |
|
this.iterator = generateIterator(this.opts.store.iterator.bind(this.opts.store)); |
|
} |
|
} |
|
_checkIterableAdaptar() { |
|
return iterableAdapters.includes(this.opts.store.opts.dialect) || iterableAdapters.findIndex((element) => this.opts.store.opts.url.includes(element)) >= 0; |
|
} |
|
_getKeyPrefix(key) { |
|
return `${this.opts.namespace}:${key}`; |
|
} |
|
_getKeyPrefixArray(keys) { |
|
return keys.map((key) => `${this.opts.namespace}:${key}`); |
|
} |
|
_getKeyUnprefix(key) { |
|
return key.split(":").splice(1).join(":"); |
|
} |
|
get(key, options) { |
|
const { store } = this.opts; |
|
const isArray = Array.isArray(key); |
|
const keyPrefixed = isArray ? this._getKeyPrefixArray(key) : this._getKeyPrefix(key); |
|
if (isArray && store.getMany === void 0) { |
|
const promises = []; |
|
for (const key2 of keyPrefixed) { |
|
promises.push( |
|
Promise.resolve().then(() => store.get(key2)).then((data) => typeof data === "string" ? this.opts.deserialize(data) : this.opts.compression ? this.opts.deserialize(data) : data).then((data) => { |
|
if (data === void 0 || data === null) { |
|
return void 0; |
|
} |
|
if (typeof data.expires === "number" && Date.now() > data.expires) { |
|
return this.delete(key2).then(() => void 0); |
|
} |
|
return options && options.raw ? data : data.value; |
|
}) |
|
); |
|
} |
|
return Promise.allSettled(promises).then((values) => { |
|
const data = []; |
|
for (const value of values) { |
|
data.push(value.value); |
|
} |
|
return data; |
|
}); |
|
} |
|
return Promise.resolve().then(() => isArray ? store.getMany(keyPrefixed) : store.get(keyPrefixed)).then((data) => typeof data === "string" ? this.opts.deserialize(data) : this.opts.compression ? this.opts.deserialize(data) : data).then((data) => { |
|
if (data === void 0 || data === null) { |
|
return void 0; |
|
} |
|
if (isArray) { |
|
return data.map((row, index) => { |
|
if (typeof row === "string") { |
|
row = this.opts.deserialize(row); |
|
} |
|
if (row === void 0 || row === null) { |
|
return void 0; |
|
} |
|
if (typeof row.expires === "number" && Date.now() > row.expires) { |
|
this.delete(key[index]).then(() => void 0); |
|
return void 0; |
|
} |
|
return options && options.raw ? row : row.value; |
|
}); |
|
} |
|
if (typeof data.expires === "number" && Date.now() > data.expires) { |
|
return this.delete(key).then(() => void 0); |
|
} |
|
return options && options.raw ? data : data.value; |
|
}); |
|
} |
|
set(key, value, ttl) { |
|
const keyPrefixed = this._getKeyPrefix(key); |
|
if (typeof ttl === "undefined") { |
|
ttl = this.opts.ttl; |
|
} |
|
if (ttl === 0) { |
|
ttl = void 0; |
|
} |
|
const { store } = this.opts; |
|
return Promise.resolve().then(() => { |
|
const expires = typeof ttl === "number" ? Date.now() + ttl : null; |
|
if (typeof value === "symbol") { |
|
this.emit("error", "symbol cannot be serialized"); |
|
} |
|
value = { value, expires }; |
|
return this.opts.serialize(value); |
|
}).then((value2) => store.set(keyPrefixed, value2, ttl)).then(() => true); |
|
} |
|
delete(key) { |
|
const { store } = this.opts; |
|
if (Array.isArray(key)) { |
|
const keyPrefixed2 = this._getKeyPrefixArray(key); |
|
if (store.deleteMany === void 0) { |
|
const promises = []; |
|
for (const key2 of keyPrefixed2) { |
|
promises.push(store.delete(key2)); |
|
} |
|
return Promise.allSettled(promises).then((values) => values.every((x) => x.value === true)); |
|
} |
|
return Promise.resolve().then(() => store.deleteMany(keyPrefixed2)); |
|
} |
|
const keyPrefixed = this._getKeyPrefix(key); |
|
return Promise.resolve().then(() => store.delete(keyPrefixed)); |
|
} |
|
clear() { |
|
const { store } = this.opts; |
|
return Promise.resolve().then(() => store.clear()); |
|
} |
|
has(key) { |
|
const keyPrefixed = this._getKeyPrefix(key); |
|
const { store } = this.opts; |
|
return Promise.resolve().then(async () => { |
|
if (typeof store.has === "function") { |
|
return store.has(keyPrefixed); |
|
} |
|
const value = await store.get(keyPrefixed); |
|
return value !== void 0; |
|
}); |
|
} |
|
disconnect() { |
|
const { store } = this.opts; |
|
if (typeof store.disconnect === "function") { |
|
return store.disconnect(); |
|
} |
|
} |
|
}; |
|
module.exports = Keyv; |
|
} |
|
}); |
|
|
|
// node_modules/flatted/cjs/index.js |
|
var require_cjs = __commonJS({ |
|
"node_modules/flatted/cjs/index.js"(exports) { |
|
"use strict"; |
|
var { parse: $parse, stringify: $stringify } = JSON; |
|
var { keys } = Object; |
|
var Primitive = String; |
|
var primitive = "string"; |
|
var ignore = {}; |
|
var object = "object"; |
|
var noop = (_, value) => value; |
|
var primitives = (value) => value instanceof Primitive ? Primitive(value) : value; |
|
var Primitives = (_, value) => typeof value === primitive ? new Primitive(value) : value; |
|
var revive = (input, parsed, output, $) => { |
|
const lazy = []; |
|
for (let ke = keys(output), { length } = ke, y = 0; y < length; y++) { |
|
const k = ke[y]; |
|
const value = output[k]; |
|
if (value instanceof Primitive) { |
|
const tmp = input[value]; |
|
if (typeof tmp === object && !parsed.has(tmp)) { |
|
parsed.add(tmp); |
|
output[k] = ignore; |
|
lazy.push({ k, a: [input, parsed, tmp, $] }); |
|
} else |
|
output[k] = $.call(output, k, tmp); |
|
} else if (output[k] !== ignore) |
|
output[k] = $.call(output, k, value); |
|
} |
|
for (let { length } = lazy, i = 0; i < length; i++) { |
|
const { k, a } = lazy[i]; |
|
output[k] = $.call(output, k, revive.apply(null, a)); |
|
} |
|
return output; |
|
}; |
|
var set = (known, input, value) => { |
|
const index = Primitive(input.push(value) - 1); |
|
known.set(value, index); |
|
return index; |
|
}; |
|
var parse = (text, reviver) => { |
|
const input = $parse(text, Primitives).map(primitives); |
|
const value = input[0]; |
|
const $ = reviver || noop; |
|
const tmp = typeof value === object && value ? revive(input, /* @__PURE__ */ new Set(), value, $) : value; |
|
return $.call({ "": tmp }, "", tmp); |
|
}; |
|
exports.parse = parse; |
|
var stringify4 = (value, replacer, space) => { |
|
const $ = replacer && typeof replacer === object ? (k, v) => k === "" || -1 < replacer.indexOf(k) ? v : void 0 : replacer || noop; |
|
const known = /* @__PURE__ */ new Map(); |
|
const input = []; |
|
const output = []; |
|
let i = +set(known, input, $.call({ "": value }, "", value)); |
|
let firstRun = !i; |
|
while (i < input.length) { |
|
firstRun = true; |
|
output[i] = $stringify(input[i++], replace, space); |
|
} |
|
return "[" + output.join(",") + "]"; |
|
function replace(key, value2) { |
|
if (firstRun) { |
|
firstRun = !firstRun; |
|
return value2; |
|
} |
|
const after = $.call(this, key, value2); |
|
switch (typeof after) { |
|
case object: |
|
if (after === null) return after; |
|
case primitive: |
|
return known.get(after) || set(known, input, after); |
|
} |
|
return after; |
|
} |
|
}; |
|
exports.stringify = stringify4; |
|
var toJSON = (value) => $parse(stringify4(value)); |
|
exports.toJSON = toJSON; |
|
var fromJSON = (value) => parse($stringify(value)); |
|
exports.fromJSON = fromJSON; |
|
} |
|
}); |
|
|
|
// node_modules/file-entry-cache/node_modules/flat-cache/src/utils.js |
|
var require_utils = __commonJS({ |
|
"node_modules/file-entry-cache/node_modules/flat-cache/src/utils.js"(exports, module) { |
|
var fs6 = __require("fs"); |
|
var path10 = __require("path"); |
|
var flatted = require_cjs(); |
|
function tryParse(filePath, defaultValue) { |
|
let result; |
|
try { |
|
result = readJSON(filePath); |
|
} catch { |
|
result = defaultValue; |
|
} |
|
return result; |
|
} |
|
function readJSON(filePath) { |
|
return flatted.parse( |
|
fs6.readFileSync(filePath, { |
|
encoding: "utf8" |
|
}) |
|
); |
|
} |
|
function writeJSON(filePath, data) { |
|
fs6.mkdirSync(path10.dirname(filePath), { |
|
recursive: true |
|
}); |
|
fs6.writeFileSync(filePath, flatted.stringify(data)); |
|
} |
|
module.exports = { tryParse, readJSON, writeJSON }; |
|
} |
|
}); |
|
|
|
// node_modules/file-entry-cache/node_modules/flat-cache/src/del.js |
|
var require_del = __commonJS({ |
|
"node_modules/file-entry-cache/node_modules/flat-cache/src/del.js"(exports, module) { |
|
var fs6 = __require("fs"); |
|
var path10 = __require("path"); |
|
function del(targetPath) { |
|
if (!fs6.existsSync(targetPath)) { |
|
return false; |
|
} |
|
try { |
|
if (fs6.statSync(targetPath).isDirectory()) { |
|
for (const file of fs6.readdirSync(targetPath)) { |
|
const currentPath = path10.join(targetPath, file); |
|
if (fs6.statSync(currentPath).isFile()) { |
|
fs6.unlinkSync(currentPath); |
|
} |
|
} |
|
fs6.rmdirSync(targetPath); |
|
} else { |
|
fs6.unlinkSync(targetPath); |
|
} |
|
return true; |
|
} catch (error) { |
|
console.error(`Error while deleting ${targetPath}: ${error.message}`); |
|
} |
|
} |
|
module.exports = { del }; |
|
} |
|
}); |
|
|
|
// node_modules/file-entry-cache/node_modules/flat-cache/src/cache.js |
|
var require_cache = __commonJS({ |
|
"node_modules/file-entry-cache/node_modules/flat-cache/src/cache.js"(exports, module) { |
|
var path10 = __require("path"); |
|
var fs6 = __require("fs"); |
|
var Keyv = require_src(); |
|
var { writeJSON, tryParse } = require_utils(); |
|
var { del } = require_del(); |
|
var cache = { |
|
/** |
|
* Load a cache identified by the given Id. If the element does not exists, then initialize an empty |
|
* cache storage. If specified `cacheDir` will be used as the directory to persist the data to. If omitted |
|
* then the cache module directory `./cache` will be used instead |
|
* |
|
* @method load |
|
* @param docId {String} the id of the cache, would also be used as the name of the file cache |
|
* @param [cacheDir] {String} directory for the cache entry |
|
*/ |
|
load(documentId, cacheDir) { |
|
const me = this; |
|
me.keyv = new Keyv(); |
|
me.__visited = {}; |
|
me.__persisted = {}; |
|
me._pathToFile = cacheDir ? path10.resolve(cacheDir, documentId) : path10.resolve(__dirname, "../.cache/", documentId); |
|
if (fs6.existsSync(me._pathToFile)) { |
|
me._persisted = tryParse(me._pathToFile, {}); |
|
} |
|
}, |
|
get _persisted() { |
|
return this.__persisted; |
|
}, |
|
set _persisted(value) { |
|
this.__persisted = value; |
|
}, |
|
get _visited() { |
|
return this.__visited; |
|
}, |
|
set _visited(value) { |
|
this.__visited = value; |
|
}, |
|
/** |
|
* Load the cache from the provided file |
|
* @method loadFile |
|
* @param {String} pathToFile the path to the file containing the info for the cache |
|
*/ |
|
loadFile(pathToFile) { |
|
const me = this; |
|
const dir = path10.dirname(pathToFile); |
|
const fName = path10.basename(pathToFile); |
|
me.load(fName, dir); |
|
}, |
|
/** |
|
* Returns the entire persisted object |
|
* @method all |
|
* @returns {*} |
|
*/ |
|
all() { |
|
return this._persisted; |
|
}, |
|
keys() { |
|
return Object.keys(this._persisted); |
|
}, |
|
/** |
|
* Sets a key to a given value |
|
* @method setKey |
|
* @param key {string} the key to set |
|
* @param value {object} the value of the key. Could be any object that can be serialized with JSON.stringify |
|
*/ |
|
setKey(key, value) { |
|
this._visited[key] = true; |
|
this._persisted[key] = value; |
|
}, |
|
/** |
|
* Remove a given key from the cache |
|
* @method removeKey |
|
* @param key {String} the key to remove from the object |
|
*/ |
|
removeKey(key) { |
|
delete this._visited[key]; |
|
delete this._persisted[key]; |
|
}, |
|
/** |
|
* Return the value of the provided key |
|
* @method getKey |
|
* @param key {String} the name of the key to retrieve |
|
* @returns {*} the value from the key |
|
*/ |
|
getKey(key) { |
|
this._visited[key] = true; |
|
return this._persisted[key]; |
|
}, |
|
/** |
|
* Remove keys that were not accessed/set since the |
|
* last time the `prune` method was called. |
|
* @method _prune |
|
* @private |
|
*/ |
|
_prune() { |
|
const me = this; |
|
const object = {}; |
|
const keys = Object.keys(me._visited); |
|
if (keys.length === 0) { |
|
return; |
|
} |
|
for (const key of keys) { |
|
object[key] = me._persisted[key]; |
|
} |
|
me._visited = {}; |
|
me._persisted = object; |
|
}, |
|
/** |
|
* Save the state of the cache identified by the docId to disk |
|
* as a JSON structure |
|
* @param [noPrune=false] {Boolean} whether to remove from cache the non visited files |
|
* @method save |
|
*/ |
|
save(noPrune) { |
|
const me = this; |
|
!noPrune && me._prune(); |
|
writeJSON(me._pathToFile, me._persisted); |
|
}, |
|
/** |
|
* Remove the file where the cache is persisted |
|
* @method removeCacheFile |
|
* @return {Boolean} true or false if the file was successfully deleted |
|
*/ |
|
removeCacheFile() { |
|
return del(this._pathToFile); |
|
}, |
|
/** |
|
* Destroy the file cache and cache content. |
|
* @method destroy |
|
*/ |
|
destroy() { |
|
const me = this; |
|
me._visited = {}; |
|
me._persisted = {}; |
|
me.removeCacheFile(); |
|
} |
|
}; |
|
module.exports = { |
|
/** |
|
* Alias for create. Should be considered depreacted. Will be removed in next releases |
|
* |
|
* @method load |
|
* @param docId {String} the id of the cache, would also be used as the name of the file cache |
|
* @param [cacheDir] {String} directory for the cache entry |
|
* @returns {cache} cache instance |
|
*/ |
|
load(documentId, cacheDir) { |
|
return this.create(documentId, cacheDir); |
|
}, |
|
/** |
|
* Load a cache identified by the given Id. If the element does not exists, then initialize an empty |
|
* cache storage. |
|
* |
|
* @method create |
|
* @param docId {String} the id of the cache, would also be used as the name of the file cache |
|
* @param [cacheDir] {String} directory for the cache entry |
|
* @returns {cache} cache instance |
|
*/ |
|
create(documentId, cacheDir) { |
|
const object = Object.create(cache); |
|
object.load(documentId, cacheDir); |
|
return object; |
|
}, |
|
createFromFile(filePath) { |
|
const object = Object.create(cache); |
|
object.loadFile(filePath); |
|
return object; |
|
}, |
|
/** |
|
* Clear the cache identified by the given id. Caches stored in a different cache directory can be deleted directly |
|
* |
|
* @method clearCache |
|
* @param docId {String} the id of the cache, would also be used as the name of the file cache |
|
* @param cacheDir {String} the directory where the cache file was written |
|
* @returns {Boolean} true if the cache folder was deleted. False otherwise |
|
*/ |
|
clearCacheById(documentId, cacheDir) { |
|
const filePath = cacheDir ? path10.resolve(cacheDir, documentId) : path10.resolve(__dirname, "../.cache/", documentId); |
|
return del(filePath); |
|
}, |
|
/** |
|
* Remove all cache stored in the cache directory |
|
* @method clearAll |
|
* @returns {Boolean} true if the cache folder was deleted. False otherwise |
|
*/ |
|
clearAll(cacheDir) { |
|
const filePath = cacheDir ? path10.resolve(cacheDir) : path10.resolve(__dirname, "../.cache/"); |
|
return del(filePath); |
|
} |
|
}; |
|
} |
|
}); |
|
|
|
// node_modules/file-entry-cache/cache.js |
|
var require_cache2 = __commonJS({ |
|
"node_modules/file-entry-cache/cache.js"(exports, module) { |
|
var path10 = __require("path"); |
|
var process5 = __require("process"); |
|
var crypto = __require("crypto"); |
|
module.exports = { |
|
createFromFile(filePath, useChecksum) { |
|
const fname = path10.basename(filePath); |
|
const dir = path10.dirname(filePath); |
|
return this.create(fname, dir, useChecksum); |
|
}, |
|
create(cacheId, _path, useChecksum) { |
|
const fs6 = __require("fs"); |
|
const flatCache = require_cache(); |
|
const cache = flatCache.load(cacheId, _path); |
|
let normalizedEntries = {}; |
|
const removeNotFoundFiles = function removeNotFoundFiles2() { |
|
const cachedEntries = cache.keys(); |
|
for (const fPath of cachedEntries) { |
|
try { |
|
fs6.statSync(fPath); |
|
} catch (error) { |
|
if (error.code === "ENOENT") { |
|
cache.removeKey(fPath); |
|
} |
|
} |
|
} |
|
}; |
|
removeNotFoundFiles(); |
|
return { |
|
/** |
|
* The flat cache storage used to persist the metadata of the `files |
|
* @type {Object} |
|
*/ |
|
cache, |
|
/** |
|
* Given a buffer, calculate md5 hash of its content. |
|
* @method getHash |
|
* @param {Buffer} buffer buffer to calculate hash on |
|
* @return {String} content hash digest |
|
*/ |
|
getHash(buffer) { |
|
return crypto.createHash("md5").update(buffer).digest("hex"); |
|
}, |
|
/** |
|
* Return whether or not a file has changed since last time reconcile was called. |
|
* @method hasFileChanged |
|
* @param {String} file the filepath to check |
|
* @return {Boolean} wheter or not the file has changed |
|
*/ |
|
hasFileChanged(file) { |
|
return this.getFileDescriptor(file).changed; |
|
}, |
|
/** |
|
* Given an array of file paths it return and object with three arrays: |
|
* - changedFiles: Files that changed since previous run |
|
* - notChangedFiles: Files that haven't change |
|
* - notFoundFiles: Files that were not found, probably deleted |
|
* |
|
* @param {Array} files the files to analyze and compare to the previous seen files |
|
* @return {[type]} [description] |
|
*/ |
|
analyzeFiles(files) { |
|
const me = this; |
|
files || (files = []); |
|
const res = { |
|
changedFiles: [], |
|
notFoundFiles: [], |
|
notChangedFiles: [] |
|
}; |
|
for (const entry of me.normalizeEntries(files)) { |
|
if (entry.changed) { |
|
res.changedFiles.push(entry.key); |
|
continue; |
|
} |
|
if (entry.notFound) { |
|
res.notFoundFiles.push(entry.key); |
|
continue; |
|
} |
|
res.notChangedFiles.push(entry.key); |
|
} |
|
return res; |
|
}, |
|
getFileDescriptor(file) { |
|
let fstat; |
|
try { |
|
if (!path10.isAbsolute(file)) { |
|
file = path10.resolve(process5.cwd(), file); |
|
} |
|
fstat = fs6.statSync(file); |
|
} catch (error) { |
|
this.removeEntry(file); |
|
return { key: file, notFound: true, err: error }; |
|
} |
|
if (useChecksum) { |
|
return this._getFileDescriptorUsingChecksum(file); |
|
} |
|
return this._getFileDescriptorUsingMtimeAndSize(file, fstat); |
|
}, |
|
_getFileDescriptorUsingMtimeAndSize(file, fstat) { |
|
let meta = cache.getKey(file); |
|
const cacheExists = Boolean(meta); |
|
const cSize = fstat.size; |
|
const cTime = fstat.mtime.getTime(); |
|
let isDifferentDate; |
|
let isDifferentSize; |
|
if (meta) { |
|
isDifferentDate = cTime !== meta.mtime; |
|
isDifferentSize = cSize !== meta.size; |
|
} else { |
|
meta = { size: cSize, mtime: cTime }; |
|
} |
|
const nEntry = normalizedEntries[file] = { |
|
key: file, |
|
changed: !cacheExists || isDifferentDate || isDifferentSize, |
|
meta |
|
}; |
|
return nEntry; |
|
}, |
|
_getFileDescriptorUsingChecksum(file) { |
|
let meta = cache.getKey(file); |
|
const cacheExists = Boolean(meta); |
|
let contentBuffer; |
|
try { |
|
contentBuffer = fs6.readFileSync(file); |
|
} catch { |
|
contentBuffer = ""; |
|
} |
|
let isDifferent = true; |
|
const hash = this.getHash(contentBuffer); |
|
if (meta) { |
|
isDifferent = hash !== meta.hash; |
|
} else { |
|
meta = { hash }; |
|
} |
|
const nEntry = normalizedEntries[file] = { |
|
key: file, |
|
changed: !cacheExists || isDifferent, |
|
meta |
|
}; |
|
return nEntry; |
|
}, |
|
/** |
|
* Return the list o the files that changed compared |
|
* against the ones stored in the cache |
|
* |
|
* @method getUpdated |
|
* @param files {Array} the array of files to compare against the ones in the cache |
|
* @returns {Array} |
|
*/ |
|
getUpdatedFiles(files) { |
|
const me = this; |
|
files || (files = []); |
|
return me.normalizeEntries(files).filter((entry) => entry.changed).map((entry) => entry.key); |
|
}, |
|
/** |
|
* Return the list of files |
|
* @method normalizeEntries |
|
* @param files |
|
* @returns {*} |
|
*/ |
|
normalizeEntries(files) { |
|
files || (files = []); |
|
const me = this; |
|
const nEntries = files.map((file) => me.getFileDescriptor(file)); |
|
return nEntries; |
|
}, |
|
/** |
|
* Remove an entry from the file-entry-cache. Useful to force the file to still be considered |
|
* modified the next time the process is run |
|
* |
|
* @method removeEntry |
|
* @param entryName |
|
*/ |
|
removeEntry(entryName) { |
|
if (!path10.isAbsolute(entryName)) { |
|
entryName = path10.resolve(process5.cwd(), entryName); |
|
} |
|
delete normalizedEntries[entryName]; |
|
cache.removeKey(entryName); |
|
}, |
|
/** |
|
* Delete the cache file from the disk |
|
* @method deleteCacheFile |
|
*/ |
|
deleteCacheFile() { |
|
cache.removeCacheFile(); |
|
}, |
|
/** |
|
* Remove the cache from the file and clear the memory cache |
|
*/ |
|
destroy() { |
|
normalizedEntries = {}; |
|
cache.destroy(); |
|
}, |
|
_getMetaForFileUsingCheckSum(cacheEntry) { |
|
const contentBuffer = fs6.readFileSync(cacheEntry.key); |
|
const hash = this.getHash(contentBuffer); |
|
const meta = Object.assign(cacheEntry.meta, { hash }); |
|
delete meta.size; |
|
delete meta.mtime; |
|
return meta; |
|
}, |
|
_getMetaForFileUsingMtimeAndSize(cacheEntry) { |
|
const stat = fs6.statSync(cacheEntry.key); |
|
const meta = Object.assign(cacheEntry.meta, { |
|
size: stat.size, |
|
mtime: stat.mtime.getTime() |
|
}); |
|
delete meta.hash; |
|
return meta; |
|
}, |
|
/** |
|
* Sync the files and persist them to the cache |
|
* @method reconcile |
|
*/ |
|
reconcile(noPrune) { |
|
removeNotFoundFiles(); |
|
noPrune = noPrune === void 0 ? true : noPrune; |
|
const entries = normalizedEntries; |
|
const keys = Object.keys(entries); |
|
if (keys.length === 0) { |
|
return; |
|
} |
|
const me = this; |
|
for (const entryName of keys) { |
|
const cacheEntry = entries[entryName]; |
|
try { |
|
const meta = useChecksum ? me._getMetaForFileUsingCheckSum(cacheEntry) : me._getMetaForFileUsingMtimeAndSize(cacheEntry); |
|
cache.setKey(entryName, meta); |
|
} catch (error) { |
|
if (error.code !== "ENOENT") { |
|
throw error; |
|
} |
|
} |
|
} |
|
cache.save(noPrune); |
|
} |
|
}; |
|
} |
|
}; |
|
} |
|
}); |
|
|
|
// node_modules/wcwidth.js/combining.js |
|
var require_combining = __commonJS({ |
|
"node_modules/wcwidth.js/combining.js"(exports, module) { |
|
module.exports = [ |
|
[768, 879], |
|
[1155, 1158], |
|
[1160, 1161], |
|
[1425, 1469], |
|
[1471, 1471], |
|
[1473, 1474], |
|
[1476, 1477], |
|
[1479, 1479], |
|
[1536, 1539], |
|
[1552, 1557], |
|
[1611, 1630], |
|
[1648, 1648], |
|
[1750, 1764], |
|
[1767, 1768], |
|
[1770, 1773], |
|
[1807, 1807], |
|
[1809, 1809], |
|
[1840, 1866], |
|
[1958, 1968], |
|
[2027, 2035], |
|
[2305, 2306], |
|
[2364, 2364], |
|
[2369, 2376], |
|
[2381, 2381], |
|
[2385, 2388], |
|
[2402, 2403], |
|
[2433, 2433], |
|
[2492, 2492], |
|
[2497, 2500], |
|
[2509, 2509], |
|
[2530, 2531], |
|
[2561, 2562], |
|
[2620, 2620], |
|
[2625, 2626], |
|
[2631, 2632], |
|
[2635, 2637], |
|
[2672, 2673], |
|
[2689, 2690], |
|
[2748, 2748], |
|
[2753, 2757], |
|
[2759, 2760], |
|
[2765, 2765], |
|
[2786, 2787], |
|
[2817, 2817], |
|
[2876, 2876], |
|
[2879, 2879], |
|
[2881, 2883], |
|
[2893, 2893], |
|
[2902, 2902], |
|
[2946, 2946], |
|
[3008, 3008], |
|
[3021, 3021], |
|
[3134, 3136], |
|
[3142, 3144], |
|
[3146, 3149], |
|
[3157, 3158], |
|
[3260, 3260], |
|
[3263, 3263], |
|
[3270, 3270], |
|
[3276, 3277], |
|
[3298, 3299], |
|
[3393, 3395], |
|
[3405, 3405], |
|
[3530, 3530], |
|
[3538, 3540], |
|
[3542, 3542], |
|
[3633, 3633], |
|
[3636, 3642], |
|
[3655, 3662], |
|
[3761, 3761], |
|
[3764, 3769], |
|
[3771, 3772], |
|
[3784, 3789], |
|
[3864, 3865], |
|
[3893, 3893], |
|
[3895, 3895], |
|
[3897, 3897], |
|
[3953, 3966], |
|
[3968, 3972], |
|
[3974, 3975], |
|
[3984, 3991], |
|
[3993, 4028], |
|
[4038, 4038], |
|
[4141, 4144], |
|
[4146, 4146], |
|
[4150, 4151], |
|
[4153, 4153], |
|
[4184, 4185], |
|
[4448, 4607], |
|
[4959, 4959], |
|
[5906, 5908], |
|
[5938, 5940], |
|
[5970, 5971], |
|
[6002, 6003], |
|
[6068, 6069], |
|
[6071, 6077], |
|
[6086, 6086], |
|
[6089, 6099], |
|
[6109, 6109], |
|
[6155, 6157], |
|
[6313, 6313], |
|
[6432, 6434], |
|
[6439, 6440], |
|
[6450, 6450], |
|
[6457, 6459], |
|
[6679, 6680], |
|
[6912, 6915], |
|
[6964, 6964], |
|
[6966, 6970], |
|
[6972, 6972], |
|
[6978, 6978], |
|
[7019, 7027], |
|
[7616, 7626], |
|
[7678, 7679], |
|
[8203, 8207], |
|
[8234, 8238], |
|
[8288, 8291], |
|
[8298, 8303], |
|
[8400, 8431], |
|
[12330, 12335], |
|
[12441, 12442], |
|
[43014, 43014], |
|
[43019, 43019], |
|
[43045, 43046], |
|
[64286, 64286], |
|
[65024, 65039], |
|
[65056, 65059], |
|
[65279, 65279], |
|
[65529, 65531], |
|
[68097, 68099], |
|
[68101, 68102], |
|
[68108, 68111], |
|
[68152, 68154], |
|
[68159, 68159], |
|
[119143, 119145], |
|
[119155, 119170], |
|
[119173, 119179], |
|
[119210, 119213], |
|
[119362, 119364], |
|
[917505, 917505], |
|
[917536, 917631], |
|
[917760, 917999] |
|
]; |
|
} |
|
}); |
|
|
|
// node_modules/wcwidth.js/index.js |
|
var require_wcwidth = __commonJS({ |
|
"node_modules/wcwidth.js/index.js"(exports, module) { |
|
var combining = require_combining(); |
|
var DEFAULTS = { |
|
nul: 0, |
|
control: 0 |
|
}; |
|
function bisearch(ucs) { |
|
let min = 0; |
|
let max = combining.length - 1; |
|
let mid; |
|
if (ucs < combining[0][0] || ucs > combining[max][1]) return false; |
|
while (max >= min) { |
|
mid = Math.floor((min + max) / 2); |
|
if (ucs > combining[mid][1]) min = mid + 1; |
|
else if (ucs < combining[mid][0]) max = mid - 1; |
|
else return true; |
|
} |
|
return false; |
|
} |
|
function wcwidth2(ucs, opts) { |
|
if (ucs === 0) return opts.nul; |
|
if (ucs < 32 || ucs >= 127 && ucs < 160) return opts.control; |
|
if (bisearch(ucs)) return 0; |
|
return 1 + (ucs >= 4352 && (ucs <= 4447 || // Hangul Jamo init. consonants |
|
ucs == 9001 || ucs == 9002 || ucs >= 11904 && ucs <= 42191 && ucs != 12351 || // CJK ... Yi |
|
ucs >= 44032 && ucs <= 55203 || // Hangul Syllables |
|
ucs >= 63744 && ucs <= 64255 || // CJK Compatibility Ideographs |
|
ucs >= 65040 && ucs <= 65049 || // Vertical forms |
|
ucs >= 65072 && ucs <= 65135 || // CJK Compatibility Forms |
|
ucs >= 65280 && ucs <= 65376 || // Fullwidth Forms |
|
ucs >= 65504 && ucs <= 65510 || ucs >= 131072 && ucs <= 196605 || ucs >= 196608 && ucs <= 262141)); |
|
} |
|
function wcswidth(str, opts) { |
|
let h; |
|
let l; |
|
let s = 0; |
|
let n; |
|
if (typeof str !== "string") return wcwidth2(str, opts); |
|
for (let i = 0; i < str.length; i++) { |
|
h = str.charCodeAt(i); |
|
if (h >= 55296 && h <= 56319) { |
|
l = str.charCodeAt(++i); |
|
if (l >= 56320 && l <= 57343) { |
|
h = (h - 55296) * 1024 + (l - 56320) + 65536; |
|
} else { |
|
i--; |
|
} |
|
} |
|
n = wcwidth2(h, opts); |
|
if (n < 0) return -1; |
|
s += n; |
|
} |
|
return s; |
|
} |
|
module.exports = (str) => wcswidth(str, DEFAULTS); |
|
module.exports.config = (opts = {}) => { |
|
opts = { |
|
...DEFAULTS, |
|
...opts |
|
}; |
|
return (str) => wcswidth(str, opts); |
|
}; |
|
} |
|
}); |
|
|
|
// src/cli/index.js |
|
import * as prettier2 from "../index.mjs"; |
|
|
|
// scripts/build/shims/at.js |
|
var at = (isOptionalObject, object, index) => { |
|
if (isOptionalObject && (object === void 0 || object === null)) { |
|
return; |
|
} |
|
if (Array.isArray(object) || typeof object === "string") { |
|
return object[index < 0 ? object.length + index : index]; |
|
} |
|
return object.at(index); |
|
}; |
|
var at_default = at; |
|
|
|
// src/cli/options/get-context-options.js |
|
var import_dashify = __toESM(require_dashify(), 1); |
|
import { getSupportInfo } from "../index.mjs"; |
|
|
|
// src/cli/cli-options.evaluate.js |
|
var cli_options_evaluate_default = { |
|
"cache": { |
|
"default": false, |
|
"description": "Only format changed files. Cannot use with --stdin-filepath.", |
|
"type": "boolean" |
|
}, |
|
"cacheLocation": { |
|
"description": "Path to the cache file.", |
|
"type": "path" |
|
}, |
|
"cacheStrategy": { |
|
"choices": [ |
|
{ |
|
"description": "Use the file metadata such as timestamps as cache keys", |
|
"value": "metadata" |
|
}, |
|
{ |
|
"description": "Use the file content as cache keys", |
|
"value": "content" |
|
} |
|
], |
|
"description": "Strategy for the cache to use for detecting changed files.", |
|
"type": "choice" |
|
}, |
|
"check": { |
|
"alias": "c", |
|
"category": "Output", |
|
"description": "Check if the given files are formatted, print a human-friendly summary\nmessage and paths to unformatted files (see also --list-different).", |
|
"type": "boolean" |
|
}, |
|
"color": { |
|
"default": true, |
|
"description": "Colorize error messages.", |
|
"oppositeDescription": "Do not colorize error messages.", |
|
"type": "boolean" |
|
}, |
|
"config": { |
|
"category": "Config", |
|
"description": "Path to a Prettier configuration file (.prettierrc, package.json, prettier.config.js).", |
|
"exception": (value) => value === false, |
|
"oppositeDescription": "Do not look for a configuration file.", |
|
"type": "path" |
|
}, |
|
"configPrecedence": { |
|
"category": "Config", |
|
"choices": [ |
|
{ |
|
"description": "CLI options take precedence over config file", |
|
"value": "cli-override" |
|
}, |
|
{ |
|
"description": "Config file take precedence over CLI options", |
|
"value": "file-override" |
|
}, |
|
{ |
|
"description": "If a config file is found will evaluate it and ignore other CLI options.\nIf no config file is found CLI options will evaluate as normal.", |
|
"value": "prefer-file" |
|
} |
|
], |
|
"default": "cli-override", |
|
"description": "Define in which order config files and CLI options should be evaluated.", |
|
"type": "choice" |
|
}, |
|
"debugBenchmark": { |
|
"type": "boolean" |
|
}, |
|
"debugCheck": { |
|
"type": "boolean" |
|
}, |
|
"debugPrintAst": { |
|
"type": "boolean" |
|
}, |
|
"debugPrintComments": { |
|
"type": "boolean" |
|
}, |
|
"debugPrintDoc": { |
|
"type": "boolean" |
|
}, |
|
"debugRepeat": { |
|
"default": 0, |
|
"type": "int" |
|
}, |
|
"editorconfig": { |
|
"category": "Config", |
|
"default": true, |
|
"description": "Take .editorconfig into account when parsing configuration.", |
|
"oppositeDescription": "Don't take .editorconfig into account when parsing configuration.", |
|
"type": "boolean" |
|
}, |
|
"errorOnUnmatchedPattern": { |
|
"oppositeDescription": "Prevent errors when pattern is unmatched.", |
|
"type": "boolean" |
|
}, |
|
"fileInfo": { |
|
"description": "Extract the following info (as JSON) for a given file path. Reported fields:\n* ignored (boolean) - true if file path is filtered by --ignore-path\n* inferredParser (string | null) - name of parser inferred from file path", |
|
"type": "path" |
|
}, |
|
"findConfigPath": { |
|
"category": "Config", |
|
"description": "Find and print the path to a configuration file for the given input file.", |
|
"type": "path" |
|
}, |
|
"help": { |
|
"alias": "h", |
|
"description": "Show CLI usage, or details about the given flag.\nExample: --help write", |
|
"exception": (value) => value === "", |
|
"type": "flag" |
|
}, |
|
"ignorePath": { |
|
"array": true, |
|
"category": "Config", |
|
"default": [ |
|
{ |
|
"value": [ |
|
".gitignore", |
|
".prettierignore" |
|
] |
|
} |
|
], |
|
"description": "Path to a file with patterns describing files to ignore.\nMultiple values are accepted.", |
|
"type": "path" |
|
}, |
|
"ignoreUnknown": { |
|
"alias": "u", |
|
"description": "Ignore unknown files.", |
|
"type": "boolean" |
|
}, |
|
"listDifferent": { |
|
"alias": "l", |
|
"category": "Output", |
|
"description": "Print the names of files that are different from Prettier's formatting (see also --check).", |
|
"type": "boolean" |
|
}, |
|
"logLevel": { |
|
"choices": [ |
|
"silent", |
|
"error", |
|
"warn", |
|
"log", |
|
"debug" |
|
], |
|
"default": "log", |
|
"description": "What level of logs to report.", |
|
"type": "choice" |
|
}, |
|
"supportInfo": { |
|
"description": "Print support information as JSON.", |
|
"type": "boolean" |
|
}, |
|
"version": { |
|
"alias": "v", |
|
"description": "Print Prettier version.", |
|
"type": "boolean" |
|
}, |
|
"withNodeModules": { |
|
"category": "Config", |
|
"description": "Process files inside 'node_modules' directory.", |
|
"type": "boolean" |
|
}, |
|
"write": { |
|
"alias": "w", |
|
"category": "Output", |
|
"description": "Edit files in-place. (Beware!)", |
|
"type": "boolean" |
|
} |
|
}; |
|
|
|
// src/cli/prettier-internal.js |
|
import { __internal as sharedWithCli } from "../index.mjs"; |
|
var { |
|
errors, |
|
optionCategories, |
|
createIsIgnoredFunction, |
|
formatOptionsHiddenDefaults, |
|
normalizeOptions, |
|
getSupportInfoWithoutPlugins, |
|
normalizeOptionSettings, |
|
vnopts, |
|
fastGlob, |
|
createTwoFilesPatch, |
|
mockable |
|
} = sharedWithCli; |
|
|
|
// src/cli/options/get-context-options.js |
|
var detailedCliOptions = normalizeOptionSettings(cli_options_evaluate_default).map( |
|
(option) => normalizeDetailedOption(option) |
|
); |
|
function apiOptionToCliOption(apiOption) { |
|
const cliOption = { |
|
...apiOption, |
|
description: apiOption.cliDescription ?? apiOption.description, |
|
category: apiOption.cliCategory ?? optionCategories.CATEGORY_FORMAT, |
|
forwardToApi: apiOption.name |
|
}; |
|
if (apiOption.deprecated) { |
|
delete cliOption.forwardToApi; |
|
delete cliOption.description; |
|
delete cliOption.oppositeDescription; |
|
cliOption.deprecated = true; |
|
} |
|
return normalizeDetailedOption(cliOption); |
|
} |
|
function normalizeDetailedOption(option) { |
|
var _a; |
|
return { |
|
category: optionCategories.CATEGORY_OTHER, |
|
...option, |
|
name: option.cliName ?? (0, import_dashify.default)(option.name), |
|
choices: (_a = option.choices) == null ? void 0 : _a.map((choice) => { |
|
const newChoice = { |
|
description: "", |
|
deprecated: false, |
|
...typeof choice === "object" ? choice : { value: choice } |
|
}; |
|
if (newChoice.value === true) { |
|
newChoice.value = ""; |
|
} |
|
return newChoice; |
|
}) |
|
}; |
|
} |
|
function supportInfoToContextOptions({ options: supportOptions, languages }) { |
|
const detailedOptions = [ |
|
...detailedCliOptions, |
|
...supportOptions.map((apiOption) => apiOptionToCliOption(apiOption)) |
|
]; |
|
return { |
|
supportOptions, |
|
languages, |
|
detailedOptions |
|
}; |
|
} |
|
async function getContextOptions(plugins) { |
|
const supportInfo = await getSupportInfo({ |
|
showDeprecated: true, |
|
plugins |
|
}); |
|
return supportInfoToContextOptions(supportInfo); |
|
} |
|
function getContextOptionsWithoutPlugins() { |
|
const supportInfo = getSupportInfoWithoutPlugins(); |
|
return supportInfoToContextOptions(supportInfo); |
|
} |
|
|
|
// scripts/build/shims/string-replace-all.js |
|
var stringReplaceAll = (isOptionalObject, original, pattern, replacement) => { |
|
if (isOptionalObject && (original === void 0 || original === null)) { |
|
return; |
|
} |
|
if (original.replaceAll) { |
|
return original.replaceAll(pattern, replacement); |
|
} |
|
if (pattern.global) { |
|
return original.replace(pattern, replacement); |
|
} |
|
return original.split(pattern).join(replacement); |
|
}; |
|
var string_replace_all_default = stringReplaceAll; |
|
|
|
// node_modules/camelcase/index.js |
|
var UPPERCASE = /[\p{Lu}]/u; |
|
var LOWERCASE = /[\p{Ll}]/u; |
|
var LEADING_CAPITAL = /^[\p{Lu}](?![\p{Lu}])/gu; |
|
var IDENTIFIER = /([\p{Alpha}\p{N}_]|$)/u; |
|
var SEPARATORS = /[_.\- ]+/; |
|
var LEADING_SEPARATORS = new RegExp("^" + SEPARATORS.source); |
|
var SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER.source, "gu"); |
|
var NUMBERS_AND_IDENTIFIER = new RegExp("\\d+" + IDENTIFIER.source, "gu"); |
|
var preserveCamelCase = (string, toLowerCase, toUpperCase, preserveConsecutiveUppercase2) => { |
|
let isLastCharLower = false; |
|
let isLastCharUpper = false; |
|
let isLastLastCharUpper = false; |
|
let isLastLastCharPreserved = false; |
|
for (let index = 0; index < string.length; index++) { |
|
const character = string[index]; |
|
isLastLastCharPreserved = index > 2 ? string[index - 3] === "-" : true; |
|
if (isLastCharLower && UPPERCASE.test(character)) { |
|
string = string.slice(0, index) + "-" + string.slice(index); |
|
isLastCharLower = false; |
|
isLastLastCharUpper = isLastCharUpper; |
|
isLastCharUpper = true; |
|
index++; |
|
} else if (isLastCharUpper && isLastLastCharUpper && LOWERCASE.test(character) && (!isLastLastCharPreserved || preserveConsecutiveUppercase2)) { |
|
string = string.slice(0, index - 1) + "-" + string.slice(index - 1); |
|
isLastLastCharUpper = isLastCharUpper; |
|
isLastCharUpper = false; |
|
isLastCharLower = true; |
|
} else { |
|
isLastCharLower = toLowerCase(character) === character && toUpperCase(character) !== character; |
|
isLastLastCharUpper = isLastCharUpper; |
|
isLastCharUpper = toUpperCase(character) === character && toLowerCase(character) !== character; |
|
} |
|
} |
|
return string; |
|
}; |
|
var preserveConsecutiveUppercase = (input, toLowerCase) => { |
|
LEADING_CAPITAL.lastIndex = 0; |
|
return string_replace_all_default( |
|
/* isOptionalObject */ |
|
false, |
|
input, |
|
LEADING_CAPITAL, |
|
(match) => toLowerCase(match) |
|
); |
|
}; |
|
var postProcess = (input, toUpperCase) => { |
|
SEPARATORS_AND_IDENTIFIER.lastIndex = 0; |
|
NUMBERS_AND_IDENTIFIER.lastIndex = 0; |
|
return string_replace_all_default( |
|
/* isOptionalObject */ |
|
false, |
|
string_replace_all_default( |
|
/* isOptionalObject */ |
|
false, |
|
input, |
|
NUMBERS_AND_IDENTIFIER, |
|
(match, pattern, offset) => ["_", "-"].includes(input.charAt(offset + match.length)) ? match : toUpperCase(match) |
|
), |
|
SEPARATORS_AND_IDENTIFIER, |
|
(_, identifier) => toUpperCase(identifier) |
|
); |
|
}; |
|
function camelCase(input, options) { |
|
if (!(typeof input === "string" || Array.isArray(input))) { |
|
throw new TypeError("Expected the input to be `string | string[]`"); |
|
} |
|
options = { |
|
pascalCase: false, |
|
preserveConsecutiveUppercase: false, |
|
...options |
|
}; |
|
if (Array.isArray(input)) { |
|
input = input.map((x) => x.trim()).filter((x) => x.length).join("-"); |
|
} else { |
|
input = input.trim(); |
|
} |
|
if (input.length === 0) { |
|
return ""; |
|
} |
|
const toLowerCase = options.locale === false ? (string) => string.toLowerCase() : (string) => string.toLocaleLowerCase(options.locale); |
|
const toUpperCase = options.locale === false ? (string) => string.toUpperCase() : (string) => string.toLocaleUpperCase(options.locale); |
|
if (input.length === 1) { |
|
if (SEPARATORS.test(input)) { |
|
return ""; |
|
} |
|
return options.pascalCase ? toUpperCase(input) : toLowerCase(input); |
|
} |
|
const hasUpperCase = input !== toLowerCase(input); |
|
if (hasUpperCase) { |
|
input = preserveCamelCase(input, toLowerCase, toUpperCase, options.preserveConsecutiveUppercase); |
|
} |
|
input = input.replace(LEADING_SEPARATORS, ""); |
|
input = options.preserveConsecutiveUppercase ? preserveConsecutiveUppercase(input, toLowerCase) : toLowerCase(input); |
|
if (options.pascalCase) { |
|
input = toUpperCase(input.charAt(0)) + input.slice(1); |
|
} |
|
return postProcess(input, toUpperCase); |
|
} |
|
|
|
// src/cli/utils.js |
|
import fs from "fs/promises"; |
|
import path from "path"; |
|
|
|
// node_modules/sdbm/index.js |
|
function sdbm(string) { |
|
let hash = 0; |
|
for (let i = 0; i < string.length; i++) { |
|
hash = string.charCodeAt(i) + (hash << 6) + (hash << 16) - hash; |
|
} |
|
return hash >>> 0; |
|
} |
|
|
|
// src/cli/utils.js |
|
import { __internal as sharedWithCli2 } from "../index.mjs"; |
|
var printToScreen = console.log.bind(console); |
|
function groupBy(array2, iteratee) { |
|
const result = /* @__PURE__ */ Object.create(null); |
|
for (const value of array2) { |
|
const key = iteratee(value); |
|
if (Array.isArray(result[key])) { |
|
result[key].push(value); |
|
} else { |
|
result[key] = [value]; |
|
} |
|
} |
|
return result; |
|
} |
|
function pick(object, keys) { |
|
const entries = keys.map((key) => [key, object[key]]); |
|
return Object.fromEntries(entries); |
|
} |
|
function createHash(source) { |
|
return String(sdbm(source)); |
|
} |
|
async function statSafe(filePath) { |
|
try { |
|
return await fs.stat(filePath); |
|
} catch (error) { |
|
if (error.code !== "ENOENT") { |
|
throw error; |
|
} |
|
} |
|
} |
|
async function lstatSafe(filePath) { |
|
try { |
|
return await fs.lstat(filePath); |
|
} catch (error) { |
|
if (error.code !== "ENOENT") { |
|
throw error; |
|
} |
|
} |
|
} |
|
function isJson(value) { |
|
try { |
|
JSON.parse(value); |
|
return true; |
|
} catch { |
|
return false; |
|
} |
|
} |
|
var normalizeToPosix = path.sep === "\\" ? (filepath) => string_replace_all_default( |
|
/* isOptionalObject */ |
|
false, |
|
filepath, |
|
"\\", |
|
"/" |
|
) : (filepath) => filepath; |
|
var { |
|
isNonEmptyArray, |
|
partition, |
|
omit |
|
} = sharedWithCli2.utils; |
|
|
|
// src/cli/options/create-minimist-options.js |
|
function createMinimistOptions(detailedOptions) { |
|
const booleanNames = []; |
|
const stringNames = []; |
|
const defaultValues = {}; |
|
for (const option of detailedOptions) { |
|
const { name, alias, type } = option; |
|
const names = type === "boolean" ? booleanNames : stringNames; |
|
names.push(name); |
|
if (alias) { |
|
names.push(alias); |
|
} |
|
if (!option.deprecated && (!option.forwardToApi || name === "plugin") && option.default !== void 0) { |
|
defaultValues[option.name] = option.default; |
|
} |
|
} |
|
return { |
|
// we use vnopts' AliasSchema to handle aliases for better error messages |
|
alias: {}, |
|
boolean: booleanNames, |
|
string: stringNames, |
|
default: defaultValues |
|
}; |
|
} |
|
|
|
// src/cli/options/minimist.js |
|
var import_minimist = __toESM(require_minimist(), 1); |
|
var PLACEHOLDER = null; |
|
function minimistParse(args, options) { |
|
const boolean = options.boolean ?? []; |
|
const defaults = options.default ?? {}; |
|
const booleanWithoutDefault = boolean.filter((key) => !(key in defaults)); |
|
const newDefaults = { |
|
...defaults, |
|
...Object.fromEntries( |
|
booleanWithoutDefault.map((key) => [key, PLACEHOLDER]) |
|
) |
|
}; |
|
const parsed = (0, import_minimist.default)(args, { ...options, default: newDefaults }); |
|
return Object.fromEntries( |
|
Object.entries(parsed).filter(([, value]) => value !== PLACEHOLDER) |
|
); |
|
} |
|
|
|
// node_modules/chalk/source/vendor/ansi-styles/index.js |
|
var ANSI_BACKGROUND_OFFSET = 10; |
|
var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`; |
|
var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`; |
|
var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`; |
|
var styles = { |
|
modifier: { |
|
reset: [0, 0], |
|
// 21 isn't widely supported and 22 does the same thing |
|
bold: [1, 22], |
|
dim: [2, 22], |
|
italic: [3, 23], |
|
underline: [4, 24], |
|
overline: [53, 55], |
|
inverse: [7, 27], |
|
hidden: [8, 28], |
|
strikethrough: [9, 29] |
|
}, |
|
color: { |
|
black: [30, 39], |
|
red: [31, 39], |
|
green: [32, 39], |
|
yellow: [33, 39], |
|
blue: [34, 39], |
|
magenta: [35, 39], |
|
cyan: [36, 39], |
|
white: [37, 39], |
|
// Bright color |
|
blackBright: [90, 39], |
|
gray: [90, 39], |
|
// Alias of `blackBright` |
|
grey: [90, 39], |
|
// Alias of `blackBright` |
|
redBright: [91, 39], |
|
greenBright: [92, 39], |
|
yellowBright: [93, 39], |
|
blueBright: [94, 39], |
|
magentaBright: [95, 39], |
|
cyanBright: [96, 39], |
|
whiteBright: [97, 39] |
|
}, |
|
bgColor: { |
|
bgBlack: [40, 49], |
|
bgRed: [41, 49], |
|
bgGreen: [42, 49], |
|
bgYellow: [43, 49], |
|
bgBlue: [44, 49], |
|
bgMagenta: [45, 49], |
|
bgCyan: [46, 49], |
|
bgWhite: [47, 49], |
|
// Bright color |
|
bgBlackBright: [100, 49], |
|
bgGray: [100, 49], |
|
// Alias of `bgBlackBright` |
|
bgGrey: [100, 49], |
|
// Alias of `bgBlackBright` |
|
bgRedBright: [101, 49], |
|
bgGreenBright: [102, 49], |
|
bgYellowBright: [103, 49], |
|
bgBlueBright: [104, 49], |
|
bgMagentaBright: [105, 49], |
|
bgCyanBright: [106, 49], |
|
bgWhiteBright: [107, 49] |
|
} |
|
}; |
|
var modifierNames = Object.keys(styles.modifier); |
|
var foregroundColorNames = Object.keys(styles.color); |
|
var backgroundColorNames = Object.keys(styles.bgColor); |
|
var colorNames = [...foregroundColorNames, ...backgroundColorNames]; |
|
function assembleStyles() { |
|
const codes = /* @__PURE__ */ new Map(); |
|
for (const [groupName, group] of Object.entries(styles)) { |
|
for (const [styleName, style] of Object.entries(group)) { |
|
styles[styleName] = { |
|
open: `\x1B[${style[0]}m`, |
|
close: `\x1B[${style[1]}m` |
|
}; |
|
group[styleName] = styles[styleName]; |
|
codes.set(style[0], style[1]); |
|
} |
|
Object.defineProperty(styles, groupName, { |
|
value: group, |
|
enumerable: false |
|
}); |
|
} |
|
Object.defineProperty(styles, "codes", { |
|
value: codes, |
|
enumerable: false |
|
}); |
|
styles.color.close = "\x1B[39m"; |
|
styles.bgColor.close = "\x1B[49m"; |
|
styles.color.ansi = wrapAnsi16(); |
|
styles.color.ansi256 = wrapAnsi256(); |
|
styles.color.ansi16m = wrapAnsi16m(); |
|
styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET); |
|
styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET); |
|
styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET); |
|
Object.defineProperties(styles, { |
|
rgbToAnsi256: { |
|
value(red, green, blue) { |
|
if (red === green && green === blue) { |
|
if (red < 8) { |
|
return 16; |
|
} |
|
if (red > 248) { |
|
return 231; |
|
} |
|
return Math.round((red - 8) / 247 * 24) + 232; |
|
} |
|
return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5); |
|
}, |
|
enumerable: false |
|
}, |
|
hexToRgb: { |
|
value(hex) { |
|
const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16)); |
|
if (!matches) { |
|
return [0, 0, 0]; |
|
} |
|
let [colorString] = matches; |
|
if (colorString.length === 3) { |
|
colorString = [...colorString].map((character) => character + character).join(""); |
|
} |
|
const integer = Number.parseInt(colorString, 16); |
|
return [ |
|
/* eslint-disable no-bitwise */ |
|
integer >> 16 & 255, |
|
integer >> 8 & 255, |
|
integer & 255 |
|
/* eslint-enable no-bitwise */ |
|
]; |
|
}, |
|
enumerable: false |
|
}, |
|
hexToAnsi256: { |
|
value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)), |
|
enumerable: false |
|
}, |
|
ansi256ToAnsi: { |
|
value(code) { |
|
if (code < 8) { |
|
return 30 + code; |
|
} |
|
if (code < 16) { |
|
return 90 + (code - 8); |
|
} |
|
let red; |
|
let green; |
|
let blue; |
|
if (code >= 232) { |
|
red = ((code - 232) * 10 + 8) / 255; |
|
green = red; |
|
blue = red; |
|
} else { |
|
code -= 16; |
|
const remainder = code % 36; |
|
red = Math.floor(code / 36) / 5; |
|
green = Math.floor(remainder / 6) / 5; |
|
blue = remainder % 6 / 5; |
|
} |
|
const value = Math.max(red, green, blue) * 2; |
|
if (value === 0) { |
|
return 30; |
|
} |
|
let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red)); |
|
if (value === 2) { |
|
result += 60; |
|
} |
|
return result; |
|
}, |
|
enumerable: false |
|
}, |
|
rgbToAnsi: { |
|
value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)), |
|
enumerable: false |
|
}, |
|
hexToAnsi: { |
|
value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)), |
|
enumerable: false |
|
} |
|
}); |
|
return styles; |
|
} |
|
var ansiStyles = assembleStyles(); |
|
var ansi_styles_default = ansiStyles; |
|
|
|
// node_modules/chalk/source/vendor/supports-color/index.js |
|
import process2 from "process"; |
|
import os from "os"; |
|
import tty from "tty"; |
|
function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) { |
|
const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--"; |
|
const position = argv.indexOf(prefix + flag); |
|
const terminatorPosition = argv.indexOf("--"); |
|
return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition); |
|
} |
|
var { env } = process2; |
|
var flagForceColor; |
|
if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) { |
|
flagForceColor = 0; |
|
} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) { |
|
flagForceColor = 1; |
|
} |
|
function envForceColor() { |
|
if ("FORCE_COLOR" in env) { |
|
if (env.FORCE_COLOR === "true") { |
|
return 1; |
|
} |
|
if (env.FORCE_COLOR === "false") { |
|
return 0; |
|
} |
|
return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3); |
|
} |
|
} |
|
function translateLevel(level) { |
|
if (level === 0) { |
|
return false; |
|
} |
|
return { |
|
level, |
|
hasBasic: true, |
|
has256: level >= 2, |
|
has16m: level >= 3 |
|
}; |
|
} |
|
function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) { |
|
const noFlagForceColor = envForceColor(); |
|
if (noFlagForceColor !== void 0) { |
|
flagForceColor = noFlagForceColor; |
|
} |
|
const forceColor = sniffFlags ? flagForceColor : noFlagForceColor; |
|
if (forceColor === 0) { |
|
return 0; |
|
} |
|
if (sniffFlags) { |
|
if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) { |
|
return 3; |
|
} |
|
if (hasFlag("color=256")) { |
|
return 2; |
|
} |
|
} |
|
if ("TF_BUILD" in env && "AGENT_NAME" in env) { |
|
return 1; |
|
} |
|
if (haveStream && !streamIsTTY && forceColor === void 0) { |
|
return 0; |
|
} |
|
const min = forceColor || 0; |
|
if (env.TERM === "dumb") { |
|
return min; |
|
} |
|
if (process2.platform === "win32") { |
|
const osRelease = os.release().split("."); |
|
if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) { |
|
return Number(osRelease[2]) >= 14931 ? 3 : 2; |
|
} |
|
return 1; |
|
} |
|
if ("CI" in env) { |
|
if ("GITHUB_ACTIONS" in env || "GITEA_ACTIONS" in env) { |
|
return 3; |
|
} |
|
if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") { |
|
return 1; |
|
} |
|
return min; |
|
} |
|
if ("TEAMCITY_VERSION" in env) { |
|
return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0; |
|
} |
|
if (env.COLORTERM === "truecolor") { |
|
return 3; |
|
} |
|
if (env.TERM === "xterm-kitty") { |
|
return 3; |
|
} |
|
if ("TERM_PROGRAM" in env) { |
|
const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10); |
|
switch (env.TERM_PROGRAM) { |
|
case "iTerm.app": { |
|
return version2 >= 3 ? 3 : 2; |
|
} |
|
case "Apple_Terminal": { |
|
return 2; |
|
} |
|
} |
|
} |
|
if (/-256(color)?$/i.test(env.TERM)) { |
|
return 2; |
|
} |
|
if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) { |
|
return 1; |
|
} |
|
if ("COLORTERM" in env) { |
|
return 1; |
|
} |
|
return min; |
|
} |
|
function createSupportsColor(stream, options = {}) { |
|
const level = _supportsColor(stream, { |
|
streamIsTTY: stream && stream.isTTY, |
|
...options |
|
}); |
|
return translateLevel(level); |
|
} |
|
var supportsColor = { |
|
stdout: createSupportsColor({ isTTY: tty.isatty(1) }), |
|
stderr: createSupportsColor({ isTTY: tty.isatty(2) }) |
|
}; |
|
var supports_color_default = supportsColor; |
|
|
|
// node_modules/chalk/source/utilities.js |
|
function stringReplaceAll2(string, substring, replacer) { |
|
let index = string.indexOf(substring); |
|
if (index === -1) { |
|
return string; |
|
} |
|
const substringLength = substring.length; |
|
let endIndex = 0; |
|
let returnValue = ""; |
|
do { |
|
returnValue += string.slice(endIndex, index) + substring + replacer; |
|
endIndex = index + substringLength; |
|
index = string.indexOf(substring, endIndex); |
|
} while (index !== -1); |
|
returnValue += string.slice(endIndex); |
|
return returnValue; |
|
} |
|
function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) { |
|
let endIndex = 0; |
|
let returnValue = ""; |
|
do { |
|
const gotCR = string[index - 1] === "\r"; |
|
returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix; |
|
endIndex = index + 1; |
|
index = string.indexOf("\n", endIndex); |
|
} while (index !== -1); |
|
returnValue += string.slice(endIndex); |
|
return returnValue; |
|
} |
|
|
|
// node_modules/chalk/source/index.js |
|
var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default; |
|
var GENERATOR = Symbol("GENERATOR"); |
|
var STYLER = Symbol("STYLER"); |
|
var IS_EMPTY = Symbol("IS_EMPTY"); |
|
var levelMapping = [ |
|
"ansi", |
|
"ansi", |
|
"ansi256", |
|
"ansi16m" |
|
]; |
|
var styles2 = /* @__PURE__ */ Object.create(null); |
|
var applyOptions = (object, options = {}) => { |
|
if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) { |
|
throw new Error("The `level` option should be an integer from 0 to 3"); |
|
} |
|
const colorLevel = stdoutColor ? stdoutColor.level : 0; |
|
object.level = options.level === void 0 ? colorLevel : options.level; |
|
}; |
|
var chalkFactory = (options) => { |
|
const chalk2 = (...strings) => strings.join(" "); |
|
applyOptions(chalk2, options); |
|
Object.setPrototypeOf(chalk2, createChalk.prototype); |
|
return chalk2; |
|
}; |
|
function createChalk(options) { |
|
return chalkFactory(options); |
|
} |
|
Object.setPrototypeOf(createChalk.prototype, Function.prototype); |
|
for (const [styleName, style] of Object.entries(ansi_styles_default)) { |
|
styles2[styleName] = { |
|
get() { |
|
const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]); |
|
Object.defineProperty(this, styleName, { value: builder }); |
|
return builder; |
|
} |
|
}; |
|
} |
|
styles2.visible = { |
|
get() { |
|
const builder = createBuilder(this, this[STYLER], true); |
|
Object.defineProperty(this, "visible", { value: builder }); |
|
return builder; |
|
} |
|
}; |
|
var getModelAnsi = (model, level, type, ...arguments_) => { |
|
if (model === "rgb") { |
|
if (level === "ansi16m") { |
|
return ansi_styles_default[type].ansi16m(...arguments_); |
|
} |
|
if (level === "ansi256") { |
|
return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_)); |
|
} |
|
return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_)); |
|
} |
|
if (model === "hex") { |
|
return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_)); |
|
} |
|
return ansi_styles_default[type][model](...arguments_); |
|
}; |
|
var usedModels = ["rgb", "hex", "ansi256"]; |
|
for (const model of usedModels) { |
|
styles2[model] = { |
|
get() { |
|
const { level } = this; |
|
return function(...arguments_) { |
|
const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]); |
|
return createBuilder(this, styler, this[IS_EMPTY]); |
|
}; |
|
} |
|
}; |
|
const bgModel = "bg" + model[0].toUpperCase() + model.slice(1); |
|
styles2[bgModel] = { |
|
get() { |
|
const { level } = this; |
|
return function(...arguments_) { |
|
const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]); |
|
return createBuilder(this, styler, this[IS_EMPTY]); |
|
}; |
|
} |
|
}; |
|
} |
|
var proto = Object.defineProperties(() => { |
|
}, { |
|
...styles2, |
|
level: { |
|
enumerable: true, |
|
get() { |
|
return this[GENERATOR].level; |
|
}, |
|
set(level) { |
|
this[GENERATOR].level = level; |
|
} |
|
} |
|
}); |
|
var createStyler = (open, close, parent) => { |
|
let openAll; |
|
let closeAll; |
|
if (parent === void 0) { |
|
openAll = open; |
|
closeAll = close; |
|
} else { |
|
openAll = parent.openAll + open; |
|
closeAll = close + parent.closeAll; |
|
} |
|
return { |
|
open, |
|
close, |
|
openAll, |
|
closeAll, |
|
parent |
|
}; |
|
}; |
|
var createBuilder = (self, _styler, _isEmpty) => { |
|
const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" ")); |
|
Object.setPrototypeOf(builder, proto); |
|
builder[GENERATOR] = self; |
|
builder[STYLER] = _styler; |
|
builder[IS_EMPTY] = _isEmpty; |
|
return builder; |
|
}; |
|
var applyStyle = (self, string) => { |
|
if (self.level <= 0 || !string) { |
|
return self[IS_EMPTY] ? "" : string; |
|
} |
|
let styler = self[STYLER]; |
|
if (styler === void 0) { |
|
return string; |
|
} |
|
const { openAll, closeAll } = styler; |
|
if (string.includes("\x1B")) { |
|
while (styler !== void 0) { |
|
string = stringReplaceAll2(string, styler.close, styler.open); |
|
styler = styler.parent; |
|
} |
|
} |
|
const lfIndex = string.indexOf("\n"); |
|
if (lfIndex !== -1) { |
|
string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex); |
|
} |
|
return openAll + string + closeAll; |
|
}; |
|
Object.defineProperties(createChalk.prototype, styles2); |
|
var chalk = createChalk(); |
|
var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 }); |
|
var source_default = chalk; |
|
|
|
// node_modules/leven/index.js |
|
var array = []; |
|
var characterCodeCache = []; |
|
function leven(first, second) { |
|
if (first === second) { |
|
return 0; |
|
} |
|
const swap = first; |
|
if (first.length > second.length) { |
|
first = second; |
|
second = swap; |
|
} |
|
let firstLength = first.length; |
|
let secondLength = second.length; |
|
while (firstLength > 0 && first.charCodeAt(~-firstLength) === second.charCodeAt(~-secondLength)) { |
|
firstLength--; |
|
secondLength--; |
|
} |
|
let start = 0; |
|
while (start < firstLength && first.charCodeAt(start) === second.charCodeAt(start)) { |
|
start++; |
|
} |
|
firstLength -= start; |
|
secondLength -= start; |
|
if (firstLength === 0) { |
|
return secondLength; |
|
} |
|
let bCharacterCode; |
|
let result; |
|
let temporary; |
|
let temporary2; |
|
let index = 0; |
|
let index2 = 0; |
|
while (index < firstLength) { |
|
characterCodeCache[index] = first.charCodeAt(start + index); |
|
array[index] = ++index; |
|
} |
|
while (index2 < secondLength) { |
|
bCharacterCode = second.charCodeAt(start + index2); |
|
temporary = index2++; |
|
result = index2; |
|
for (index = 0; index < firstLength; index++) { |
|
temporary2 = bCharacterCode === characterCodeCache[index] ? temporary : temporary + 1; |
|
temporary = array[index]; |
|
result = array[index] = temporary > result ? temporary2 > result ? result + 1 : temporary2 : temporary2 > temporary ? temporary + 1 : temporary2; |
|
} |
|
} |
|
return result; |
|
} |
|
|
|
// src/cli/options/normalize-cli-options.js |
|
var descriptor = { |
|
key: (key) => key.length === 1 ? `-${key}` : `--${key}`, |
|
value: (value) => vnopts.apiDescriptor.value(value), |
|
pair: ({ key, value }) => value === false ? `--no-${key}` : value === true ? descriptor.key(key) : value === "" ? `${descriptor.key(key)} without an argument` : `${descriptor.key(key)}=${value}` |
|
}; |
|
var _flags; |
|
var FlagSchema = class extends vnopts.ChoiceSchema { |
|
constructor({ name, flags }) { |
|
super({ name, choices: flags }); |
|
__privateAdd(this, _flags, []); |
|
__privateSet(this, _flags, [...flags].sort()); |
|
} |
|
preprocess(value, utils) { |
|
if (typeof value === "string" && value.length > 0 && !__privateGet(this, _flags).includes(value)) { |
|
const suggestion = __privateGet(this, _flags).find((flag) => leven(flag, value) < 3); |
|
if (suggestion) { |
|
utils.logger.warn( |
|
[ |
|
`Unknown flag ${source_default.yellow(utils.descriptor.value(value))},`, |
|
`did you mean ${source_default.blue(utils.descriptor.value(suggestion))}?` |
|
].join(" ") |
|
); |
|
return suggestion; |
|
} |
|
} |
|
return value; |
|
} |
|
expected() { |
|
return "a flag"; |
|
} |
|
}; |
|
_flags = new WeakMap(); |
|
function normalizeCliOptions(options, optionInfos, opts) { |
|
return normalizeOptions(options, optionInfos, { |
|
...opts, |
|
isCLI: true, |
|
FlagSchema, |
|
descriptor |
|
}); |
|
} |
|
var normalize_cli_options_default = normalizeCliOptions; |
|
|
|
// src/cli/options/parse-cli-arguments.js |
|
function parseArgv(rawArguments, detailedOptions, logger, keys) { |
|
var _a; |
|
const minimistOptions = createMinimistOptions(detailedOptions); |
|
let argv = minimistParse(rawArguments, minimistOptions); |
|
if (keys) { |
|
detailedOptions = detailedOptions.filter( |
|
(option) => keys.includes(option.name) |
|
); |
|
argv = pick(argv, keys); |
|
} |
|
const normalized = normalize_cli_options_default(argv, detailedOptions, { logger }); |
|
return { |
|
...Object.fromEntries( |
|
Object.entries(normalized).map(([key, value]) => { |
|
const option = detailedOptions.find(({ name }) => name === key) || {}; |
|
return [option.forwardToApi || camelCase(key), value]; |
|
}) |
|
), |
|
_: (_a = normalized._) == null ? void 0 : _a.map(String), |
|
get __raw() { |
|
return argv; |
|
} |
|
}; |
|
} |
|
var { detailedOptions: detailedOptionsWithoutPlugins } = getContextOptionsWithoutPlugins(); |
|
function parseArgvWithoutPlugins(rawArguments, logger, keys) { |
|
return parseArgv( |
|
rawArguments, |
|
detailedOptionsWithoutPlugins, |
|
logger, |
|
typeof keys === "string" ? [keys] : keys |
|
); |
|
} |
|
|
|
// src/cli/context.js |
|
var _stack; |
|
var Context = class { |
|
constructor({ |
|
rawArguments, |
|
logger |
|
}) { |
|
__privateAdd(this, _stack, []); |
|
this.rawArguments = rawArguments; |
|
this.logger = logger; |
|
} |
|
async init() { |
|
const { |
|
rawArguments, |
|
logger |
|
} = this; |
|
const { |
|
plugins |
|
} = parseArgvWithoutPlugins(rawArguments, logger, ["plugin"]); |
|
await this.pushContextPlugins(plugins); |
|
const argv = parseArgv(rawArguments, this.detailedOptions, logger); |
|
this.argv = argv; |
|
this.filePatterns = argv._; |
|
} |
|
/** |
|
* @param {string[]} plugins |
|
*/ |
|
async pushContextPlugins(plugins) { |
|
const options = await getContextOptions(plugins); |
|
__privateGet(this, _stack).push(options); |
|
Object.assign(this, options); |
|
} |
|
popContextPlugins() { |
|
__privateGet(this, _stack).pop(); |
|
Object.assign(this, at_default( |
|
/* isOptionalObject */ |
|
false, |
|
__privateGet(this, _stack), |
|
-1 |
|
)); |
|
} |
|
// eslint-disable-next-line getter-return |
|
get performanceTestFlag() { |
|
const { |
|
debugBenchmark, |
|
debugRepeat |
|
} = this.argv; |
|
if (debugBenchmark) { |
|
return { |
|
name: "--debug-benchmark", |
|
debugBenchmark: true |
|
}; |
|
} |
|
if (debugRepeat > 0) { |
|
return { |
|
name: "--debug-repeat", |
|
debugRepeat |
|
}; |
|
} |
|
const { |
|
PRETTIER_PERF_REPEAT |
|
} = process.env; |
|
if (PRETTIER_PERF_REPEAT && /^\d+$/u.test(PRETTIER_PERF_REPEAT)) { |
|
return { |
|
name: "PRETTIER_PERF_REPEAT (environment variable)", |
|
debugRepeat: Number(PRETTIER_PERF_REPEAT) |
|
}; |
|
} |
|
} |
|
}; |
|
_stack = new WeakMap(); |
|
var context_default = Context; |
|
|
|
// src/cli/file-info.js |
|
var import_fast_json_stable_stringify = __toESM(require_fast_json_stable_stringify(), 1); |
|
import { format, getFileInfo } from "../index.mjs"; |
|
async function logFileInfoOrDie(context) { |
|
const { |
|
fileInfo: file, |
|
ignorePath, |
|
withNodeModules, |
|
plugins, |
|
config |
|
} = context.argv; |
|
const fileInfo = await getFileInfo(file, { |
|
ignorePath, |
|
withNodeModules, |
|
plugins, |
|
resolveConfig: config !== false |
|
}); |
|
printToScreen(await format((0, import_fast_json_stable_stringify.default)(fileInfo), { parser: "json" })); |
|
} |
|
var file_info_default = logFileInfoOrDie; |
|
|
|
// src/cli/find-config-path.js |
|
import path2 from "path"; |
|
import { resolveConfigFile } from "../index.mjs"; |
|
async function logResolvedConfigPathOrDie(context) { |
|
const file = context.argv.findConfigPath; |
|
const configFile = await resolveConfigFile(file); |
|
if (configFile) { |
|
printToScreen(normalizeToPosix(path2.relative(process.cwd(), configFile))); |
|
} else { |
|
throw new Error(`Can not find configure file for "${file}".`); |
|
} |
|
} |
|
var find_config_path_default = logResolvedConfigPathOrDie; |
|
|
|
// src/cli/format.js |
|
import fs5 from "fs/promises"; |
|
import path9 from "path"; |
|
import * as prettier from "../index.mjs"; |
|
|
|
// src/cli/expand-patterns.js |
|
import path3 from "path"; |
|
async function* expandPatterns(context) { |
|
const seen = /* @__PURE__ */ new Set(); |
|
let noResults = true; |
|
for await (const { |
|
filePath, |
|
ignoreUnknown, |
|
error |
|
} of expandPatternsInternal(context)) { |
|
noResults = false; |
|
if (error) { |
|
yield { |
|
error |
|
}; |
|
continue; |
|
} |
|
const filename = path3.resolve(filePath); |
|
if (seen.has(filename)) { |
|
continue; |
|
} |
|
seen.add(filename); |
|
yield { |
|
filename, |
|
ignoreUnknown |
|
}; |
|
} |
|
if (noResults && context.argv.errorOnUnmatchedPattern !== false) { |
|
yield { |
|
error: `No matching files. Patterns: ${context.filePatterns.join(" ")}` |
|
}; |
|
} |
|
} |
|
async function* expandPatternsInternal(context) { |
|
const silentlyIgnoredDirs = [".git", ".sl", ".svn", ".hg"]; |
|
if (context.argv.withNodeModules !== true) { |
|
silentlyIgnoredDirs.push("node_modules"); |
|
} |
|
const globOptions = { |
|
dot: true, |
|
ignore: silentlyIgnoredDirs.map((dir) => "**/" + dir), |
|
followSymbolicLinks: false |
|
}; |
|
const cwd2 = process.cwd(); |
|
const entries = []; |
|
for (const pattern of context.filePatterns) { |
|
const absolutePath = path3.resolve(cwd2, pattern); |
|
if (containsIgnoredPathSegment(absolutePath, cwd2, silentlyIgnoredDirs)) { |
|
continue; |
|
} |
|
const stat = await lstatSafe(absolutePath); |
|
if (stat) { |
|
if (stat.isSymbolicLink()) { |
|
if (context.argv.errorOnUnmatchedPattern !== false) { |
|
yield { |
|
error: `Explicitly specified pattern "${pattern}" is a symbolic link.` |
|
}; |
|
} else { |
|
context.logger.debug(`Skipping pattern "${pattern}", as it is a symbolic link.`); |
|
} |
|
} else if (stat.isFile()) { |
|
entries.push({ |
|
type: "file", |
|
glob: escapePathForGlob(fixWindowsSlashes(pattern)), |
|
input: pattern |
|
}); |
|
} else if (stat.isDirectory()) { |
|
const relativePath = path3.relative(cwd2, absolutePath) || "."; |
|
const prefix = escapePathForGlob(fixWindowsSlashes(relativePath)); |
|
entries.push({ |
|
type: "dir", |
|
glob: `${prefix}/**/*`, |
|
input: pattern, |
|
ignoreUnknown: true |
|
}); |
|
} |
|
} else if (pattern[0] === "!") { |
|
globOptions.ignore.push(fixWindowsSlashes(pattern.slice(1))); |
|
} else { |
|
entries.push({ |
|
type: "glob", |
|
glob: fixWindowsSlashes(pattern), |
|
input: pattern |
|
}); |
|
} |
|
} |
|
for (const { |
|
type, |
|
glob, |
|
input, |
|
ignoreUnknown |
|
} of entries) { |
|
let result; |
|
try { |
|
result = await fastGlob(glob, globOptions); |
|
} catch ({ |
|
message |
|
}) { |
|
yield { |
|
error: `${errorMessages.globError[type]}: "${input}". |
|
${message}` |
|
}; |
|
continue; |
|
} |
|
if (result.length === 0) { |
|
if (context.argv.errorOnUnmatchedPattern !== false) { |
|
yield { |
|
error: `${errorMessages.emptyResults[type]}: "${input}".` |
|
}; |
|
} |
|
} else { |
|
yield* sortPaths(result).map((filePath) => ({ |
|
filePath, |
|
ignoreUnknown |
|
})); |
|
} |
|
} |
|
} |
|
var errorMessages = { |
|
globError: { |
|
file: "Unable to resolve file", |
|
dir: "Unable to expand directory", |
|
glob: "Unable to expand glob pattern" |
|
}, |
|
emptyResults: { |
|
file: "Explicitly specified file was ignored due to negative glob patterns", |
|
dir: "No supported files were found in the directory", |
|
glob: "No files matching the pattern were found" |
|
} |
|
}; |
|
function containsIgnoredPathSegment(absolutePath, cwd2, ignoredDirectories) { |
|
return path3.relative(cwd2, absolutePath).split(path3.sep).some((dir) => ignoredDirectories.includes(dir)); |
|
} |
|
function sortPaths(paths) { |
|
return paths.sort((a, b) => a.localeCompare(b)); |
|
} |
|
function escapePathForGlob(path10) { |
|
return string_replace_all_default( |
|
/* isOptionalObject */ |
|
false, |
|
string_replace_all_default( |
|
/* isOptionalObject */ |
|
false, |
|
fastGlob.escapePath( |
|
string_replace_all_default( |
|
/* isOptionalObject */ |
|
false, |
|
path10, |
|
"\\", |
|
"\0" |
|
) |
|
// Workaround for fast-glob#262 (part 1) |
|
), |
|
String.raw`\!`, |
|
"@(!)" |
|
), |
|
"\0", |
|
String.raw`@(\\)` |
|
); |
|
} |
|
var fixWindowsSlashes = normalizeToPosix; |
|
|
|
// src/cli/find-cache-file.js |
|
import fs4 from "fs/promises"; |
|
import os2 from "os"; |
|
import path8 from "path"; |
|
|
|
// node_modules/find-cache-dir/index.js |
|
var import_common_path_prefix = __toESM(require_common_path_prefix(), 1); |
|
import process4 from "process"; |
|
import path7 from "path"; |
|
import fs3 from "fs"; |
|
|
|
// node_modules/pkg-dir/index.js |
|
import path6 from "path"; |
|
|
|
// node_modules/pkg-dir/node_modules/find-up/index.js |
|
import path5 from "path"; |
|
import { fileURLToPath as fileURLToPath2 } from "url"; |
|
|
|
// node_modules/pkg-dir/node_modules/locate-path/index.js |
|
import process3 from "process"; |
|
import path4 from "path"; |
|
import fs2, { promises as fsPromises } from "fs"; |
|
import { fileURLToPath } from "url"; |
|
var typeMappings = { |
|
directory: "isDirectory", |
|
file: "isFile" |
|
}; |
|
function checkType(type) { |
|
if (Object.hasOwnProperty.call(typeMappings, type)) { |
|
return; |
|
} |
|
throw new Error(`Invalid type specified: ${type}`); |
|
} |
|
var matchType = (type, stat) => stat[typeMappings[type]](); |
|
var toPath = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath; |
|
function locatePathSync(paths, { |
|
cwd: cwd2 = process3.cwd(), |
|
type = "file", |
|
allowSymlinks = true |
|
} = {}) { |
|
checkType(type); |
|
cwd2 = toPath(cwd2); |
|
const statFunction = allowSymlinks ? fs2.statSync : fs2.lstatSync; |
|
for (const path_ of paths) { |
|
try { |
|
const stat = statFunction(path4.resolve(cwd2, path_), { |
|
throwIfNoEntry: false |
|
}); |
|
if (!stat) { |
|
continue; |
|
} |
|
if (matchType(type, stat)) { |
|
return path_; |
|
} |
|
} catch { |
|
} |
|
} |
|
} |
|
|
|
// node_modules/pkg-dir/node_modules/find-up/index.js |
|
var toPath2 = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath2(urlOrPath) : urlOrPath; |
|
var findUpStop = Symbol("findUpStop"); |
|
function findUpMultipleSync(name, options = {}) { |
|
let directory = path5.resolve(toPath2(options.cwd) || ""); |
|
const { root } = path5.parse(directory); |
|
const stopAt = options.stopAt || root; |
|
const limit = options.limit || Number.POSITIVE_INFINITY; |
|
const paths = [name].flat(); |
|
const runMatcher = (locateOptions) => { |
|
if (typeof name !== "function") { |
|
return locatePathSync(paths, locateOptions); |
|
} |
|
const foundPath = name(locateOptions.cwd); |
|
if (typeof foundPath === "string") { |
|
return locatePathSync([foundPath], locateOptions); |
|
} |
|
return foundPath; |
|
}; |
|
const matches = []; |
|
while (true) { |
|
const foundPath = runMatcher({ ...options, cwd: directory }); |
|
if (foundPath === findUpStop) { |
|
break; |
|
} |
|
if (foundPath) { |
|
matches.push(path5.resolve(directory, foundPath)); |
|
} |
|
if (directory === stopAt || matches.length >= limit) { |
|
break; |
|
} |
|
directory = path5.dirname(directory); |
|
} |
|
return matches; |
|
} |
|
function findUpSync(name, options = {}) { |
|
const matches = findUpMultipleSync(name, { ...options, limit: 1 }); |
|
return matches[0]; |
|
} |
|
|
|
// node_modules/pkg-dir/index.js |
|
function packageDirectorySync({ cwd: cwd2 } = {}) { |
|
const filePath = findUpSync("package.json", { cwd: cwd2 }); |
|
return filePath && path6.dirname(filePath); |
|
} |
|
|
|
// node_modules/find-cache-dir/index.js |
|
var { env: env2, cwd } = process4; |
|
var isWritable = (path10) => { |
|
try { |
|
fs3.accessSync(path10, fs3.constants.W_OK); |
|
return true; |
|
} catch { |
|
return false; |
|
} |
|
}; |
|
function useDirectory(directory, options) { |
|
if (options.create) { |
|
fs3.mkdirSync(directory, { recursive: true }); |
|
} |
|
return directory; |
|
} |
|
function getNodeModuleDirectory(directory) { |
|
const nodeModules = path7.join(directory, "node_modules"); |
|
if (!isWritable(nodeModules) && (fs3.existsSync(nodeModules) || !isWritable(path7.join(directory)))) { |
|
return; |
|
} |
|
return nodeModules; |
|
} |
|
function findCacheDirectory(options = {}) { |
|
if (env2.CACHE_DIR && !["true", "false", "1", "0"].includes(env2.CACHE_DIR)) { |
|
return useDirectory(path7.join(env2.CACHE_DIR, options.name), options); |
|
} |
|
let { cwd: directory = cwd(), files } = options; |
|
if (files) { |
|
if (!Array.isArray(files)) { |
|
throw new TypeError(`Expected \`files\` option to be an array, got \`${typeof files}\`.`); |
|
} |
|
directory = (0, import_common_path_prefix.default)(files.map((file) => path7.resolve(directory, file))); |
|
} |
|
directory = packageDirectorySync({ cwd: directory }); |
|
if (!directory) { |
|
return; |
|
} |
|
const nodeModules = getNodeModuleDirectory(directory); |
|
if (!nodeModules) { |
|
return; |
|
} |
|
return useDirectory(path7.join(directory, "node_modules", ".cache", options.name), options); |
|
} |
|
|
|
// src/cli/find-cache-file.js |
|
function findDefaultCacheFile() { |
|
const cacheDir = findCacheDirectory({ name: "prettier", create: true }) || os2.tmpdir(); |
|
const cacheFilePath = path8.join(cacheDir, ".prettier-cache"); |
|
return cacheFilePath; |
|
} |
|
async function findCacheFileFromOption(cacheLocation) { |
|
const cacheFile = path8.resolve(cacheLocation); |
|
const stat = await statSafe(cacheFile); |
|
if (stat) { |
|
if (stat.isDirectory()) { |
|
throw new Error( |
|
`Resolved --cache-location '${cacheFile}' is a directory` |
|
); |
|
} |
|
const data = await fs4.readFile(cacheFile, "utf8"); |
|
if (!isJson(data)) { |
|
throw new Error(`'${cacheFile}' isn't a valid JSON file`); |
|
} |
|
} |
|
return cacheFile; |
|
} |
|
async function findCacheFile(cacheLocation) { |
|
if (!cacheLocation) { |
|
return findDefaultCacheFile(); |
|
} |
|
const cacheFile = await findCacheFileFromOption(cacheLocation); |
|
return cacheFile; |
|
} |
|
var find_cache_file_default = findCacheFile; |
|
|
|
// src/cli/format-results-cache.js |
|
var import_fast_json_stable_stringify2 = __toESM(require_fast_json_stable_stringify(), 1); |
|
var import_file_entry_cache = __toESM(require_cache2(), 1); |
|
import { version as prettierVersion } from "../index.mjs"; |
|
var optionsHashCache = /* @__PURE__ */ new WeakMap(); |
|
var nodeVersion = process.version; |
|
function getHashOfOptions(options) { |
|
if (optionsHashCache.has(options)) { |
|
return optionsHashCache.get(options); |
|
} |
|
const hash = createHash( |
|
`${prettierVersion}_${nodeVersion}_${(0, import_fast_json_stable_stringify2.default)(options)}` |
|
); |
|
optionsHashCache.set(options, hash); |
|
return hash; |
|
} |
|
function getMetadataFromFileDescriptor(fileDescriptor) { |
|
return fileDescriptor.meta; |
|
} |
|
var _fileEntryCache; |
|
var FormatResultsCache = class { |
|
/** |
|
* @param {string} cacheFileLocation The path of cache file location. (default: `node_modules/.cache/prettier/.prettier-cache`) |
|
* @param {string} cacheStrategy |
|
*/ |
|
constructor(cacheFileLocation, cacheStrategy) { |
|
__privateAdd(this, _fileEntryCache); |
|
const useChecksum = cacheStrategy === "content"; |
|
__privateSet(this, _fileEntryCache, import_file_entry_cache.default.create( |
|
/* cacheId */ |
|
cacheFileLocation, |
|
/* directory */ |
|
void 0, |
|
useChecksum |
|
)); |
|
} |
|
/** |
|
* @param {string} filePath |
|
* @param {any} options |
|
*/ |
|
existsAvailableFormatResultsCache(filePath, options) { |
|
const fileDescriptor = __privateGet(this, _fileEntryCache).getFileDescriptor(filePath); |
|
if (fileDescriptor.notFound) { |
|
return false; |
|
} |
|
const hashOfOptions = getHashOfOptions(options); |
|
const meta = getMetadataFromFileDescriptor(fileDescriptor); |
|
const changed = fileDescriptor.changed || meta.hashOfOptions !== hashOfOptions; |
|
return !changed; |
|
} |
|
/** |
|
* @param {string} filePath |
|
* @param {any} options |
|
*/ |
|
setFormatResultsCache(filePath, options) { |
|
const fileDescriptor = __privateGet(this, _fileEntryCache).getFileDescriptor(filePath); |
|
const meta = getMetadataFromFileDescriptor(fileDescriptor); |
|
if (fileDescriptor && !fileDescriptor.notFound) { |
|
meta.hashOfOptions = getHashOfOptions(options); |
|
} |
|
} |
|
/** |
|
* @param {string} filePath |
|
*/ |
|
removeFormatResultsCache(filePath) { |
|
__privateGet(this, _fileEntryCache).removeEntry(filePath); |
|
} |
|
reconcile() { |
|
__privateGet(this, _fileEntryCache).reconcile(); |
|
} |
|
}; |
|
_fileEntryCache = new WeakMap(); |
|
var format_results_cache_default = FormatResultsCache; |
|
|
|
// src/cli/is-tty.js |
|
function isTTY() { |
|
return process.stdout.isTTY && !mockable.isCI(); |
|
} |
|
|
|
// src/cli/options/get-options-for-file.js |
|
var import_dashify2 = __toESM(require_dashify(), 1); |
|
import { resolveConfig } from "../index.mjs"; |
|
function getOptions(argv, detailedOptions) { |
|
return Object.fromEntries( |
|
detailedOptions.filter(({ forwardToApi }) => forwardToApi).map(({ forwardToApi, name }) => [forwardToApi, argv[name]]) |
|
); |
|
} |
|
function cliifyOptions(object, apiDetailedOptionMap) { |
|
return Object.fromEntries( |
|
Object.entries(object || {}).map(([key, value]) => { |
|
const apiOption = apiDetailedOptionMap[key]; |
|
const cliKey = apiOption ? apiOption.name : key; |
|
return [(0, import_dashify2.default)(cliKey), value]; |
|
}) |
|
); |
|
} |
|
function createApiDetailedOptionMap(detailedOptions) { |
|
return Object.fromEntries( |
|
detailedOptions.filter( |
|
(option) => option.forwardToApi && option.forwardToApi !== option.name |
|
).map((option) => [option.forwardToApi, option]) |
|
); |
|
} |
|
function parseArgsToOptions(context, overrideDefaults) { |
|
const minimistOptions = createMinimistOptions(context.detailedOptions); |
|
const apiDetailedOptionMap = createApiDetailedOptionMap( |
|
context.detailedOptions |
|
); |
|
return getOptions( |
|
normalize_cli_options_default( |
|
minimistParse(context.rawArguments, { |
|
string: minimistOptions.string, |
|
boolean: minimistOptions.boolean, |
|
default: cliifyOptions(overrideDefaults, apiDetailedOptionMap) |
|
}), |
|
context.detailedOptions, |
|
{ logger: false } |
|
), |
|
context.detailedOptions |
|
); |
|
} |
|
async function getOptionsOrDie(context, filePath) { |
|
try { |
|
if (context.argv.config === false) { |
|
context.logger.debug( |
|
"'--no-config' option found, skip loading config file." |
|
); |
|
return null; |
|
} |
|
context.logger.debug( |
|
context.argv.config ? `load config file from '${context.argv.config}'` : `resolve config from '${filePath}'` |
|
); |
|
const options = await resolveConfig(filePath, { |
|
editorconfig: context.argv.editorconfig, |
|
config: context.argv.config |
|
}); |
|
context.logger.debug("loaded options `" + JSON.stringify(options) + "`"); |
|
return options; |
|
} catch (error) { |
|
context.logger.error( |
|
`Invalid configuration${filePath ? ` for file "${filePath}"` : ""}: |
|
` + error.message |
|
); |
|
process.exit(2); |
|
} |
|
} |
|
function applyConfigPrecedence(context, options) { |
|
try { |
|
switch (context.argv.configPrecedence) { |
|
case "cli-override": |
|
return parseArgsToOptions(context, options); |
|
case "file-override": |
|
return { ...parseArgsToOptions(context), ...options }; |
|
case "prefer-file": |
|
return options || parseArgsToOptions(context); |
|
} |
|
} catch (error) { |
|
context.logger.error(error.toString()); |
|
process.exit(2); |
|
} |
|
} |
|
async function getOptionsForFile(context, filepath) { |
|
const options = await getOptionsOrDie(context, filepath); |
|
const hasPlugins = options == null ? void 0 : options.plugins; |
|
if (hasPlugins) { |
|
await context.pushContextPlugins(options.plugins); |
|
} |
|
const appliedOptions = { |
|
filepath, |
|
...applyConfigPrecedence( |
|
context, |
|
options && normalizeOptions(options, context.supportOptions, { |
|
logger: context.logger |
|
}) |
|
) |
|
}; |
|
context.logger.debug( |
|
`applied config-precedence (${context.argv.configPrecedence}): ${JSON.stringify(appliedOptions)}` |
|
); |
|
if (hasPlugins) { |
|
context.popContextPlugins(); |
|
} |
|
return appliedOptions; |
|
} |
|
var get_options_for_file_default = getOptionsForFile; |
|
|
|
// src/cli/format.js |
|
var { getStdin, writeFormattedFile } = mockable; |
|
function diff(a, b) { |
|
return createTwoFilesPatch("", "", a, b, "", "", { context: 2 }); |
|
} |
|
var DebugError = class extends Error { |
|
name = "DebugError"; |
|
}; |
|
function handleError(context, filename, error, printedFilename, ignoreUnknown) { |
|
ignoreUnknown || (ignoreUnknown = context.argv.ignoreUnknown); |
|
const errorIsUndefinedParseError = error instanceof errors.UndefinedParserError; |
|
if (printedFilename) { |
|
if ((context.argv.write || ignoreUnknown) && errorIsUndefinedParseError) { |
|
printedFilename.clear(); |
|
} else { |
|
process.stdout.write("\n"); |
|
} |
|
} |
|
if (errorIsUndefinedParseError) { |
|
if (ignoreUnknown) { |
|
return; |
|
} |
|
if (!context.argv.check && !context.argv.listDifferent) { |
|
process.exitCode = 2; |
|
} |
|
context.logger.error(error.message); |
|
return; |
|
} |
|
const isParseError = Boolean(error == null ? void 0 : error.loc); |
|
const isValidationError = /^Invalid \S+ value\./u.test(error == null ? void 0 : error.message); |
|
if (isParseError) { |
|
context.logger.error(`${filename}: ${String(error)}`); |
|
} else if (isValidationError || error instanceof errors.ConfigError) { |
|
context.logger.error(error.message); |
|
process.exit(1); |
|
} else if (error instanceof DebugError) { |
|
context.logger.error(`${filename}: ${error.message}`); |
|
} else { |
|
context.logger.error(filename + ": " + (error.stack || error)); |
|
} |
|
process.exitCode = 2; |
|
} |
|
function writeOutput(context, result, options) { |
|
process.stdout.write( |
|
context.argv.debugCheck ? result.filepath : result.formatted |
|
); |
|
if (options && options.cursorOffset >= 0) { |
|
process.stderr.write(result.cursorOffset + "\n"); |
|
} |
|
} |
|
async function listDifferent(context, input, options, filename) { |
|
if (!context.argv.check && !context.argv.listDifferent) { |
|
return; |
|
} |
|
try { |
|
if (!await prettier.check(input, options) && !context.argv.write) { |
|
context.logger.log(filename); |
|
process.exitCode = 1; |
|
} |
|
} catch (error) { |
|
context.logger.error(error.message); |
|
} |
|
return true; |
|
} |
|
async function format3(context, input, opt) { |
|
if (context.argv.debugPrintDoc) { |
|
const doc = await prettier.__debug.printToDoc(input, opt); |
|
return { formatted: await prettier.__debug.formatDoc(doc) + "\n" }; |
|
} |
|
if (context.argv.debugPrintComments) { |
|
return { |
|
formatted: await prettier.format( |
|
JSON.stringify( |
|
(await prettier.formatWithCursor(input, opt)).comments || [] |
|
), |
|
{ parser: "json" } |
|
) |
|
}; |
|
} |
|
if (context.argv.debugPrintAst) { |
|
const { ast } = await prettier.__debug.parse(input, opt); |
|
return { |
|
formatted: JSON.stringify(ast) |
|
}; |
|
} |
|
if (context.argv.debugCheck) { |
|
const pp = await prettier.format(input, opt); |
|
const pppp = await prettier.format(pp, opt); |
|
if (pp !== pppp) { |
|
throw new DebugError( |
|
"prettier(input) !== prettier(prettier(input))\n" + diff(pp, pppp) |
|
); |
|
} else { |
|
const stringify4 = (obj) => JSON.stringify(obj, null, 2); |
|
const ast = stringify4( |
|
(await prettier.__debug.parse(input, opt, { massage: true })).ast |
|
); |
|
const past = stringify4( |
|
(await prettier.__debug.parse(pp, opt, { massage: true })).ast |
|
); |
|
if (ast !== past) { |
|
const MAX_AST_SIZE = 2097152; |
|
const astDiff = ast.length > MAX_AST_SIZE || past.length > MAX_AST_SIZE ? "AST diff too large to render" : diff(ast, past); |
|
throw new DebugError( |
|
"ast(input) !== ast(prettier(input))\n" + astDiff + "\n" + diff(input, pp) |
|
); |
|
} |
|
} |
|
return { formatted: pp, filepath: opt.filepath || "(stdin)\n" }; |
|
} |
|
const { performanceTestFlag } = context; |
|
if (performanceTestFlag == null ? void 0 : performanceTestFlag.debugBenchmark) { |
|
let benchmark; |
|
try { |
|
({ default: benchmark } = await import("benchmark")); |
|
} catch { |
|
context.logger.debug( |
|
"'--debug-benchmark' requires the 'benchmark' package to be installed." |
|
); |
|
process.exit(2); |
|
} |
|
context.logger.debug( |
|
"'--debug-benchmark' option found, measuring formatWithCursor with 'benchmark' module." |
|
); |
|
const suite = new benchmark.Suite(); |
|
suite.add("format", { |
|
defer: true, |
|
async fn(deferred) { |
|
await prettier.formatWithCursor(input, opt); |
|
deferred.resolve(); |
|
} |
|
}); |
|
const result = await new Promise((resolve) => { |
|
suite.on("complete", (event) => { |
|
resolve({ |
|
benchmark: String(event.target), |
|
hz: event.target.hz, |
|
ms: event.target.times.cycle * 1e3 |
|
}); |
|
}).run({ async: false }); |
|
}); |
|
context.logger.debug( |
|
"'--debug-benchmark' measurements for formatWithCursor: " + JSON.stringify(result, null, 2) |
|
); |
|
} else if (performanceTestFlag == null ? void 0 : performanceTestFlag.debugRepeat) { |
|
const repeat = performanceTestFlag.debugRepeat; |
|
context.logger.debug( |
|
`'${performanceTestFlag.name}' found, running formatWithCursor ${repeat} times.` |
|
); |
|
let totalMs = 0; |
|
for (let i = 0; i < repeat; ++i) { |
|
const startMs = Date.now(); |
|
await prettier.formatWithCursor(input, opt); |
|
totalMs += Date.now() - startMs; |
|
} |
|
const averageMs = totalMs / repeat; |
|
const results = { |
|
repeat, |
|
hz: 1e3 / averageMs, |
|
ms: averageMs |
|
}; |
|
context.logger.debug( |
|
`'${performanceTestFlag.name}' measurements for formatWithCursor: ${JSON.stringify( |
|
results, |
|
null, |
|
2 |
|
)}` |
|
); |
|
} |
|
return prettier.formatWithCursor(input, opt); |
|
} |
|
async function createIsIgnoredFromContextOrDie(context) { |
|
try { |
|
return await createIsIgnoredFunction( |
|
context.argv.ignorePath, |
|
context.argv.withNodeModules |
|
); |
|
} catch (e) { |
|
context.logger.error(e.message); |
|
process.exit(2); |
|
} |
|
} |
|
async function formatStdin(context) { |
|
const { filepath } = context.argv; |
|
try { |
|
const input = await getStdin(); |
|
let isFileIgnored = false; |
|
if (filepath) { |
|
const isIgnored = await createIsIgnoredFromContextOrDie(context); |
|
isFileIgnored = isIgnored(filepath); |
|
} |
|
if (isFileIgnored) { |
|
writeOutput(context, { formatted: input }); |
|
return; |
|
} |
|
const options = await get_options_for_file_default( |
|
context, |
|
filepath ? path9.resolve(filepath) : void 0 |
|
); |
|
if (await listDifferent(context, input, options, "(stdin)")) { |
|
return; |
|
} |
|
const formatted = await format3(context, input, options); |
|
const { performanceTestFlag } = context; |
|
if (performanceTestFlag) { |
|
context.logger.log( |
|
`'${performanceTestFlag.name}' option found, skipped print code to screen.` |
|
); |
|
return; |
|
} |
|
writeOutput(context, formatted, options); |
|
} catch (error) { |
|
handleError(context, filepath || "stdin", error); |
|
} |
|
} |
|
async function formatFiles(context) { |
|
const isIgnored = await createIsIgnoredFromContextOrDie(context); |
|
const cwd2 = process.cwd(); |
|
let numberOfUnformattedFilesFound = 0; |
|
const { performanceTestFlag } = context; |
|
if (context.argv.check && !performanceTestFlag) { |
|
context.logger.log("Checking formatting..."); |
|
} |
|
let formatResultsCache; |
|
const cacheFilePath = await find_cache_file_default(context.argv.cacheLocation); |
|
if (context.argv.cache) { |
|
formatResultsCache = new format_results_cache_default( |
|
cacheFilePath, |
|
context.argv.cacheStrategy || "content" |
|
); |
|
} else if (!context.argv.cacheLocation) { |
|
const stat = await statSafe(cacheFilePath); |
|
if (stat) { |
|
await fs5.unlink(cacheFilePath); |
|
} |
|
} |
|
for await (const { error, filename, ignoreUnknown } of expandPatterns( |
|
context |
|
)) { |
|
if (error) { |
|
context.logger.error(error); |
|
process.exitCode = 2; |
|
continue; |
|
} |
|
const isFileIgnored = isIgnored(filename); |
|
if (isFileIgnored && (context.argv.debugCheck || context.argv.write || context.argv.check || context.argv.listDifferent)) { |
|
continue; |
|
} |
|
const options = { |
|
...await get_options_for_file_default(context, filename), |
|
filepath: filename |
|
}; |
|
const fileNameToDisplay = normalizeToPosix(path9.relative(cwd2, filename)); |
|
let printedFilename; |
|
if (isTTY()) { |
|
printedFilename = context.logger.log(fileNameToDisplay, { |
|
newline: false, |
|
clearable: true |
|
}); |
|
} |
|
let input; |
|
try { |
|
input = await fs5.readFile(filename, "utf8"); |
|
} catch (error2) { |
|
context.logger.log(""); |
|
context.logger.error( |
|
`Unable to read file "${fileNameToDisplay}": |
|
${error2.message}` |
|
); |
|
process.exitCode = 2; |
|
continue; |
|
} |
|
if (isFileIgnored) { |
|
printedFilename == null ? void 0 : printedFilename.clear(); |
|
writeOutput(context, { formatted: input }, options); |
|
continue; |
|
} |
|
const start = Date.now(); |
|
const isCacheExists = formatResultsCache == null ? void 0 : formatResultsCache.existsAvailableFormatResultsCache( |
|
filename, |
|
options |
|
); |
|
let result; |
|
let output; |
|
try { |
|
if (isCacheExists) { |
|
result = { formatted: input }; |
|
} else { |
|
result = await format3(context, input, options); |
|
} |
|
output = result.formatted; |
|
} catch (error2) { |
|
handleError( |
|
context, |
|
fileNameToDisplay, |
|
error2, |
|
printedFilename, |
|
ignoreUnknown |
|
); |
|
continue; |
|
} |
|
const isDifferent = output !== input; |
|
let shouldSetCache = !isDifferent; |
|
printedFilename == null ? void 0 : printedFilename.clear(); |
|
if (performanceTestFlag) { |
|
context.logger.log( |
|
`'${performanceTestFlag.name}' option found, skipped print code or write files.` |
|
); |
|
return; |
|
} |
|
if (context.argv.write) { |
|
if (isDifferent) { |
|
if (!context.argv.check && !context.argv.listDifferent) { |
|
context.logger.log(`${fileNameToDisplay} ${Date.now() - start}ms`); |
|
} |
|
try { |
|
await writeFormattedFile(filename, output); |
|
shouldSetCache = true; |
|
} catch (error2) { |
|
context.logger.error( |
|
`Unable to write file "${fileNameToDisplay}": |
|
${error2.message}` |
|
); |
|
process.exitCode = 2; |
|
} |
|
} else if (!context.argv.check && !context.argv.listDifferent) { |
|
const message = `${source_default.grey(fileNameToDisplay)} ${Date.now() - start}ms (unchanged)`; |
|
if (isCacheExists) { |
|
context.logger.log(`${message} (cached)`); |
|
} else { |
|
context.logger.log(message); |
|
} |
|
} |
|
} else if (context.argv.debugCheck) { |
|
if (result.filepath) { |
|
context.logger.log(fileNameToDisplay); |
|
} else { |
|
process.exitCode = 2; |
|
} |
|
} else if (!context.argv.check && !context.argv.listDifferent) { |
|
writeOutput(context, result, options); |
|
} |
|
if (shouldSetCache) { |
|
formatResultsCache == null ? void 0 : formatResultsCache.setFormatResultsCache(filename, options); |
|
} else { |
|
formatResultsCache == null ? void 0 : formatResultsCache.removeFormatResultsCache(filename); |
|
} |
|
if (isDifferent) { |
|
if (context.argv.check) { |
|
context.logger.warn(fileNameToDisplay); |
|
} else if (context.argv.listDifferent) { |
|
context.logger.log(fileNameToDisplay); |
|
} |
|
numberOfUnformattedFilesFound += 1; |
|
} |
|
} |
|
formatResultsCache == null ? void 0 : formatResultsCache.reconcile(); |
|
if (context.argv.check) { |
|
if (numberOfUnformattedFilesFound === 0) { |
|
context.logger.log("All matched files use Prettier code style!"); |
|
} else { |
|
const files = numberOfUnformattedFilesFound === 1 ? "the above file" : `${numberOfUnformattedFilesFound} files`; |
|
context.logger.warn( |
|
context.argv.write ? `Code style issues fixed in ${files}.` : `Code style issues found in ${files}. Run Prettier with --write to fix.` |
|
); |
|
} |
|
} |
|
if ((context.argv.check || context.argv.listDifferent) && numberOfUnformattedFilesFound > 0 && !process.exitCode && !context.argv.write) { |
|
process.exitCode = 1; |
|
} |
|
} |
|
|
|
// src/cli/logger.js |
|
import readline from "readline"; |
|
|
|
// node_modules/ansi-regex/index.js |
|
function ansiRegex({ onlyFirst = false } = {}) { |
|
const pattern = [ |
|
"[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)", |
|
"(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))" |
|
].join("|"); |
|
return new RegExp(pattern, onlyFirst ? void 0 : "g"); |
|
} |
|
|
|
// node_modules/strip-ansi/index.js |
|
var regex = ansiRegex(); |
|
function stripAnsi(string) { |
|
if (typeof string !== "string") { |
|
throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``); |
|
} |
|
return string.replace(regex, ""); |
|
} |
|
|
|
// src/cli/logger.js |
|
var import_wcwidth = __toESM(require_wcwidth(), 1); |
|
var countLines = (stream, text) => { |
|
const columns = stream.columns || 80; |
|
let lineCount = 0; |
|
for (const line of stripAnsi(text).split("\n")) { |
|
lineCount += Math.max(1, Math.ceil((0, import_wcwidth.default)(line) / columns)); |
|
} |
|
return lineCount; |
|
}; |
|
var clear = (stream, text) => () => { |
|
const lineCount = countLines(stream, text); |
|
for (let line = 0; line < lineCount; line++) { |
|
if (line > 0) { |
|
readline.moveCursor(stream, 0, -1); |
|
} |
|
readline.clearLine(stream, 0); |
|
readline.cursorTo(stream, 0); |
|
} |
|
}; |
|
var emptyLogResult = { |
|
clear() { |
|
} |
|
}; |
|
function createLogger(logLevel = "log") { |
|
return { |
|
logLevel, |
|
warn: createLogFunc("warn", "yellow"), |
|
error: createLogFunc("error", "red"), |
|
debug: createLogFunc("debug", "blue"), |
|
log: createLogFunc("log") |
|
}; |
|
function createLogFunc(loggerName, color) { |
|
if (!shouldLog(loggerName)) { |
|
return () => emptyLogResult; |
|
} |
|
const stream = process[loggerName === "log" ? "stdout" : "stderr"]; |
|
const chalkInstance = loggerName === "log" ? source_default : chalkStderr; |
|
const prefix = color ? `[${chalkInstance[color](loggerName)}] ` : ""; |
|
return (message, options) => { |
|
options = { |
|
newline: true, |
|
clearable: false, |
|
...options |
|
}; |
|
message = string_replace_all_default( |
|
/* isOptionalObject */ |
|
false, |
|
message, |
|
/^/gmu, |
|
prefix |
|
) + (options.newline ? "\n" : ""); |
|
stream.write(message); |
|
if (options.clearable) { |
|
return { |
|
clear: clear(stream, message) |
|
}; |
|
} |
|
}; |
|
} |
|
function shouldLog(loggerName) { |
|
switch (logLevel) { |
|
case "silent": |
|
return false; |
|
case "debug": |
|
if (loggerName === "debug") { |
|
return true; |
|
} |
|
case "log": |
|
if (loggerName === "log") { |
|
return true; |
|
} |
|
case "warn": |
|
if (loggerName === "warn") { |
|
return true; |
|
} |
|
case "error": |
|
return loggerName === "error"; |
|
} |
|
} |
|
} |
|
var logger_default = createLogger; |
|
|
|
// src/cli/print-support-info.js |
|
var import_fast_json_stable_stringify3 = __toESM(require_fast_json_stable_stringify(), 1); |
|
import { format as format4, getSupportInfo as getSupportInfo2 } from "../index.mjs"; |
|
var sortByName = (array2) => array2.sort((a, b) => a.name.localeCompare(b.name)); |
|
async function printSupportInfo() { |
|
const { languages, options } = await getSupportInfo2(); |
|
const supportInfo = { |
|
languages: sortByName(languages), |
|
options: sortByName(options).map( |
|
(option) => omit(option, ["cliName", "cliCategory", "cliDescription"]) |
|
) |
|
}; |
|
printToScreen(await format4((0, import_fast_json_stable_stringify3.default)(supportInfo), { parser: "json" })); |
|
} |
|
var print_support_info_default = printSupportInfo; |
|
|
|
// src/cli/constants.evaluate.js |
|
var categoryOrder = [ |
|
"Output", |
|
"Format", |
|
"Config", |
|
"Editor", |
|
"Other" |
|
]; |
|
var usageSummary = "Usage: prettier [options] [file/dir/glob ...]\n\nBy default, output is written to stdout.\nStdin is read if it is piped to Prettier and no files are given."; |
|
|
|
// src/cli/usage.js |
|
var OPTION_USAGE_THRESHOLD = 25; |
|
var CHOICE_USAGE_MARGIN = 3; |
|
var CHOICE_USAGE_INDENTATION = 2; |
|
function indent(str, spaces) { |
|
return string_replace_all_default( |
|
/* isOptionalObject */ |
|
false, |
|
str, |
|
/^/gmu, |
|
" ".repeat(spaces) |
|
); |
|
} |
|
function createDefaultValueDisplay(value) { |
|
return Array.isArray(value) ? `[${value.map(createDefaultValueDisplay).join(", ")}]` : value; |
|
} |
|
function getOptionDefaultValue(context, optionName) { |
|
var _a; |
|
const option = context.detailedOptions.find(({ |
|
name |
|
}) => name === optionName); |
|
if ((option == null ? void 0 : option.default) !== void 0) { |
|
return option.default; |
|
} |
|
const optionCamelName = camelCase(optionName); |
|
return formatOptionsHiddenDefaults[optionCamelName] ?? ((_a = context.supportOptions.find((option2) => !option2.deprecated && option2.name === optionCamelName)) == null ? void 0 : _a.default); |
|
} |
|
function createOptionUsageHeader(option) { |
|
const name = `--${option.name}`; |
|
const alias = option.alias ? `-${option.alias},` : null; |
|
const type = createOptionUsageType(option); |
|
return [alias, name, type].filter(Boolean).join(" "); |
|
} |
|
function createOptionUsageRow(header, content, threshold) { |
|
const separator = header.length >= threshold ? ` |
|
${" ".repeat(threshold)}` : " ".repeat(threshold - header.length); |
|
const description = string_replace_all_default( |
|
/* isOptionalObject */ |
|
false, |
|
content, |
|
"\n", |
|
` |
|
${" ".repeat(threshold)}` |
|
); |
|
return `${header}${separator}${description}`; |
|
} |
|
function createOptionUsageType(option) { |
|
switch (option.type) { |
|
case "boolean": |
|
return null; |
|
case "choice": |
|
return `<${option.choices.filter((choice) => !choice.deprecated).map((choice) => choice.value).join("|")}>`; |
|
default: |
|
return `<${option.type}>`; |
|
} |
|
} |
|
function createChoiceUsages(choices, margin, indentation) { |
|
const activeChoices = choices.filter((choice) => !choice.deprecated); |
|
const threshold = Math.max(0, ...activeChoices.map((choice) => choice.value.length)) + margin; |
|
return activeChoices.map((choice) => indent(createOptionUsageRow(choice.value, choice.description, threshold), indentation)); |
|
} |
|
function createOptionUsage(context, option, threshold) { |
|
const header = createOptionUsageHeader(option); |
|
const optionDefaultValue = getOptionDefaultValue(context, option.name); |
|
return createOptionUsageRow(header, `${option.description}${optionDefaultValue === void 0 ? "" : ` |
|
Defaults to ${createDefaultValueDisplay(optionDefaultValue)}.`}`, threshold); |
|
} |
|
function getOptionsWithOpposites(options) { |
|
const optionsWithOpposites = options.map((option) => [option.description ? option : null, option.oppositeDescription ? { |
|
...option, |
|
name: `no-${option.name}`, |
|
type: "boolean", |
|
description: option.oppositeDescription |
|
} : null]); |
|
return optionsWithOpposites.flat().filter(Boolean); |
|
} |
|
function createUsage(context) { |
|
const sortedOptions = context.detailedOptions.sort((optionA, optionB) => optionA.name.localeCompare(optionB.name)); |
|
const options = getOptionsWithOpposites(sortedOptions).filter( |
|
// remove unnecessary option (e.g. `semi`, `color`, etc.), which is only used for --help <flag> |
|
(option) => !(option.type === "boolean" && option.oppositeDescription && !option.name.startsWith("no-")) |
|
); |
|
const groupedOptions = groupBy(options, (option) => option.category); |
|
const firstCategories = categoryOrder.slice(0, -1); |
|
const lastCategories = categoryOrder.slice(-1); |
|
const restCategories = Object.keys(groupedOptions).filter((category) => !categoryOrder.includes(category)); |
|
const allCategories = [...firstCategories, ...restCategories, ...lastCategories]; |
|
const optionsUsage = allCategories.map((category) => { |
|
const categoryOptions = groupedOptions[category].map((option) => createOptionUsage(context, option, OPTION_USAGE_THRESHOLD)).join("\n"); |
|
return `${category} options: |
|
|
|
${indent(categoryOptions, 2)}`; |
|
}); |
|
return [usageSummary, ...optionsUsage, ""].join("\n\n"); |
|
} |
|
function createPluginDefaults(pluginDefaults) { |
|
if (!pluginDefaults || Object.keys(pluginDefaults).length === 0) { |
|
return ""; |
|
} |
|
const defaults = Object.entries(pluginDefaults).sort(([pluginNameA], [pluginNameB]) => pluginNameA.localeCompare(pluginNameB)).map(([plugin, value]) => `* ${plugin}: ${createDefaultValueDisplay(value)}`).join("\n"); |
|
return ` |
|
Plugin defaults: |
|
${defaults}`; |
|
} |
|
function createDetailedUsage(context, flag) { |
|
const option = getOptionsWithOpposites(context.detailedOptions).find((option2) => option2.name === flag || option2.alias === flag); |
|
const header = createOptionUsageHeader(option); |
|
const description = ` |
|
|
|
${indent(option.description, 2)}`; |
|
const choices = option.type !== "choice" ? "" : ` |
|
|
|
Valid options: |
|
|
|
${createChoiceUsages(option.choices, CHOICE_USAGE_MARGIN, CHOICE_USAGE_INDENTATION).join("\n")}`; |
|
const optionDefaultValue = getOptionDefaultValue(context, option.name); |
|
const defaults = optionDefaultValue !== void 0 ? ` |
|
|
|
Default: ${createDefaultValueDisplay(optionDefaultValue)}` : ""; |
|
const pluginDefaults = createPluginDefaults(option.pluginDefaults); |
|
return `${header}${description}${choices}${defaults}${pluginDefaults}`; |
|
} |
|
|
|
// src/cli/index.js |
|
async function run(rawArguments = process.argv.slice(2)) { |
|
let logger = logger_default(); |
|
try { |
|
const { logLevel } = parseArgvWithoutPlugins( |
|
rawArguments, |
|
logger, |
|
"log-level" |
|
); |
|
if (logLevel !== logger.logLevel) { |
|
logger = logger_default(logLevel); |
|
} |
|
const context = new context_default({ rawArguments, logger }); |
|
await context.init(); |
|
if (logger.logLevel !== "debug" && context.performanceTestFlag) { |
|
context.logger = logger_default("debug"); |
|
} |
|
await main(context); |
|
} catch (error) { |
|
logger.error(error.message); |
|
process.exitCode = 1; |
|
} |
|
} |
|
async function main(context) { |
|
context.logger.debug(`normalized argv: ${JSON.stringify(context.argv)}`); |
|
if (context.argv.check && context.argv.listDifferent) { |
|
throw new Error("Cannot use --check and --list-different together."); |
|
} |
|
if (context.argv.write && context.argv.debugCheck) { |
|
throw new Error("Cannot use --write and --debug-check together."); |
|
} |
|
if (context.argv.findConfigPath && context.filePatterns.length > 0) { |
|
throw new Error("Cannot use --find-config-path with multiple files"); |
|
} |
|
if (context.argv.fileInfo && context.filePatterns.length > 0) { |
|
throw new Error("Cannot use --file-info with multiple files"); |
|
} |
|
if (!context.argv.cache && context.argv.cacheStrategy) { |
|
throw new Error("`--cache-strategy` cannot be used without `--cache`."); |
|
} |
|
if (context.argv.version) { |
|
printToScreen(prettier2.version); |
|
return; |
|
} |
|
if (context.argv.help !== void 0) { |
|
printToScreen( |
|
typeof context.argv.help === "string" && context.argv.help !== "" ? createDetailedUsage(context, context.argv.help) : createUsage(context) |
|
); |
|
return; |
|
} |
|
if (context.argv.supportInfo) { |
|
return print_support_info_default(); |
|
} |
|
if (context.argv.findConfigPath) { |
|
await find_config_path_default(context); |
|
return; |
|
} |
|
if (context.argv.fileInfo) { |
|
await file_info_default(context); |
|
return; |
|
} |
|
const hasFilePatterns = context.filePatterns.length > 0; |
|
const useStdin = !hasFilePatterns && (!process.stdin.isTTY || context.argv.filepath); |
|
if (useStdin) { |
|
if (context.argv.cache) { |
|
throw new Error("`--cache` cannot be used when formatting stdin."); |
|
} |
|
await formatStdin(context); |
|
return; |
|
} |
|
if (hasFilePatterns) { |
|
await formatFiles(context); |
|
return; |
|
} |
|
process.exitCode = 1; |
|
printToScreen(createUsage(context)); |
|
} |
|
export { |
|
run |
|
};
|
|
|