- API: `pnpm build` bundles dist/ into apps/api/.output (esbuild), with Linux musl native packages for sharp and argon2 kept alongside - docker/api.Dockerfile copies that output; no pnpm install on the server - add dist/migrate.js (prisma migrate deploy equivalent, same _prisma_migrations table and lock) so the Prisma CLI is not needed at runtime - pnpm-workspace: supportedArchitectures for linux/x64/musl - admin: apps/admin/.env.production sets VITE_SITE_URL for the production build - drop NPM_REGISTRY / SITE_URL build args from compose and .env.example - gitignore: anchor node_modules rules so pre-built node_modules are committed - README: describe the pre-built deploy flow Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
726 lines
21 KiB
JavaScript
726 lines
21 KiB
JavaScript
import { createRequire as __bundleCreateRequire } from "node:module"; const require = __bundleCreateRequire(import.meta.url);
|
|
import {
|
|
require_ms
|
|
} from "./chunk-A34KYKJP.js";
|
|
import {
|
|
__commonJS,
|
|
__esm,
|
|
__export,
|
|
__name,
|
|
__require,
|
|
__toCommonJS
|
|
} from "./chunk-T6GW54FI.js";
|
|
|
|
// ../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js
|
|
var require_common = __commonJS({
|
|
"../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js"(exports, module) {
|
|
function setup(env2) {
|
|
createDebug.debug = createDebug;
|
|
createDebug.default = createDebug;
|
|
createDebug.coerce = coerce;
|
|
createDebug.disable = disable;
|
|
createDebug.enable = enable;
|
|
createDebug.enabled = enabled;
|
|
createDebug.humanize = require_ms();
|
|
createDebug.destroy = destroy;
|
|
Object.keys(env2).forEach((key) => {
|
|
createDebug[key] = env2[key];
|
|
});
|
|
createDebug.names = [];
|
|
createDebug.skips = [];
|
|
createDebug.formatters = {};
|
|
function selectColor(namespace) {
|
|
let hash = 0;
|
|
for (let i = 0; i < namespace.length; i++) {
|
|
hash = (hash << 5) - hash + namespace.charCodeAt(i);
|
|
hash |= 0;
|
|
}
|
|
return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
|
|
}
|
|
__name(selectColor, "selectColor");
|
|
createDebug.selectColor = selectColor;
|
|
function createDebug(namespace) {
|
|
let prevTime;
|
|
let enableOverride = null;
|
|
let namespacesCache;
|
|
let enabledCache;
|
|
function debug(...args) {
|
|
if (!debug.enabled) {
|
|
return;
|
|
}
|
|
const self = debug;
|
|
const curr = Number(/* @__PURE__ */ new Date());
|
|
const ms = curr - (prevTime || curr);
|
|
self.diff = ms;
|
|
self.prev = prevTime;
|
|
self.curr = curr;
|
|
prevTime = curr;
|
|
args[0] = createDebug.coerce(args[0]);
|
|
if (typeof args[0] !== "string") {
|
|
args.unshift("%O");
|
|
}
|
|
let index = 0;
|
|
args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
|
|
if (match === "%%") {
|
|
return "%";
|
|
}
|
|
index++;
|
|
const formatter = createDebug.formatters[format];
|
|
if (typeof formatter === "function") {
|
|
const val = args[index];
|
|
match = formatter.call(self, val);
|
|
args.splice(index, 1);
|
|
index--;
|
|
}
|
|
return match;
|
|
});
|
|
createDebug.formatArgs.call(self, args);
|
|
const logFn = self.log || createDebug.log;
|
|
logFn.apply(self, args);
|
|
}
|
|
__name(debug, "debug");
|
|
debug.namespace = namespace;
|
|
debug.useColors = createDebug.useColors();
|
|
debug.color = createDebug.selectColor(namespace);
|
|
debug.extend = extend;
|
|
debug.destroy = createDebug.destroy;
|
|
Object.defineProperty(debug, "enabled", {
|
|
enumerable: true,
|
|
configurable: false,
|
|
get: /* @__PURE__ */ __name(() => {
|
|
if (enableOverride !== null) {
|
|
return enableOverride;
|
|
}
|
|
if (namespacesCache !== createDebug.namespaces) {
|
|
namespacesCache = createDebug.namespaces;
|
|
enabledCache = createDebug.enabled(namespace);
|
|
}
|
|
return enabledCache;
|
|
}, "get"),
|
|
set: /* @__PURE__ */ __name((v) => {
|
|
enableOverride = v;
|
|
}, "set")
|
|
});
|
|
if (typeof createDebug.init === "function") {
|
|
createDebug.init(debug);
|
|
}
|
|
return debug;
|
|
}
|
|
__name(createDebug, "createDebug");
|
|
function extend(namespace, delimiter) {
|
|
const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
|
|
newDebug.log = this.log;
|
|
return newDebug;
|
|
}
|
|
__name(extend, "extend");
|
|
function enable(namespaces) {
|
|
createDebug.save(namespaces);
|
|
createDebug.namespaces = namespaces;
|
|
createDebug.names = [];
|
|
createDebug.skips = [];
|
|
const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
|
|
for (const ns of split) {
|
|
if (ns[0] === "-") {
|
|
createDebug.skips.push(ns.slice(1));
|
|
} else {
|
|
createDebug.names.push(ns);
|
|
}
|
|
}
|
|
}
|
|
__name(enable, "enable");
|
|
function matchesTemplate(search, template) {
|
|
let searchIndex = 0;
|
|
let templateIndex = 0;
|
|
let starIndex = -1;
|
|
let matchIndex = 0;
|
|
while (searchIndex < search.length) {
|
|
if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
|
|
if (template[templateIndex] === "*") {
|
|
starIndex = templateIndex;
|
|
matchIndex = searchIndex;
|
|
templateIndex++;
|
|
} else {
|
|
searchIndex++;
|
|
templateIndex++;
|
|
}
|
|
} else if (starIndex !== -1) {
|
|
templateIndex = starIndex + 1;
|
|
matchIndex++;
|
|
searchIndex = matchIndex;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
while (templateIndex < template.length && template[templateIndex] === "*") {
|
|
templateIndex++;
|
|
}
|
|
return templateIndex === template.length;
|
|
}
|
|
__name(matchesTemplate, "matchesTemplate");
|
|
function disable() {
|
|
const namespaces = [
|
|
...createDebug.names,
|
|
...createDebug.skips.map((namespace) => "-" + namespace)
|
|
].join(",");
|
|
createDebug.enable("");
|
|
return namespaces;
|
|
}
|
|
__name(disable, "disable");
|
|
function enabled(name) {
|
|
for (const skip of createDebug.skips) {
|
|
if (matchesTemplate(name, skip)) {
|
|
return false;
|
|
}
|
|
}
|
|
for (const ns of createDebug.names) {
|
|
if (matchesTemplate(name, ns)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
__name(enabled, "enabled");
|
|
function coerce(val) {
|
|
if (val instanceof Error) {
|
|
return val.stack || val.message;
|
|
}
|
|
return val;
|
|
}
|
|
__name(coerce, "coerce");
|
|
function destroy() {
|
|
console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
|
|
}
|
|
__name(destroy, "destroy");
|
|
createDebug.enable(createDebug.load());
|
|
return createDebug;
|
|
}
|
|
__name(setup, "setup");
|
|
module.exports = setup;
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/browser.js
|
|
var require_browser = __commonJS({
|
|
"../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/browser.js"(exports, module) {
|
|
exports.formatArgs = formatArgs;
|
|
exports.save = save;
|
|
exports.load = load;
|
|
exports.useColors = useColors;
|
|
exports.storage = localstorage();
|
|
exports.destroy = /* @__PURE__ */ (() => {
|
|
let warned = false;
|
|
return () => {
|
|
if (!warned) {
|
|
warned = true;
|
|
console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
|
|
}
|
|
};
|
|
})();
|
|
exports.colors = [
|
|
"#0000CC",
|
|
"#0000FF",
|
|
"#0033CC",
|
|
"#0033FF",
|
|
"#0066CC",
|
|
"#0066FF",
|
|
"#0099CC",
|
|
"#0099FF",
|
|
"#00CC00",
|
|
"#00CC33",
|
|
"#00CC66",
|
|
"#00CC99",
|
|
"#00CCCC",
|
|
"#00CCFF",
|
|
"#3300CC",
|
|
"#3300FF",
|
|
"#3333CC",
|
|
"#3333FF",
|
|
"#3366CC",
|
|
"#3366FF",
|
|
"#3399CC",
|
|
"#3399FF",
|
|
"#33CC00",
|
|
"#33CC33",
|
|
"#33CC66",
|
|
"#33CC99",
|
|
"#33CCCC",
|
|
"#33CCFF",
|
|
"#6600CC",
|
|
"#6600FF",
|
|
"#6633CC",
|
|
"#6633FF",
|
|
"#66CC00",
|
|
"#66CC33",
|
|
"#9900CC",
|
|
"#9900FF",
|
|
"#9933CC",
|
|
"#9933FF",
|
|
"#99CC00",
|
|
"#99CC33",
|
|
"#CC0000",
|
|
"#CC0033",
|
|
"#CC0066",
|
|
"#CC0099",
|
|
"#CC00CC",
|
|
"#CC00FF",
|
|
"#CC3300",
|
|
"#CC3333",
|
|
"#CC3366",
|
|
"#CC3399",
|
|
"#CC33CC",
|
|
"#CC33FF",
|
|
"#CC6600",
|
|
"#CC6633",
|
|
"#CC9900",
|
|
"#CC9933",
|
|
"#CCCC00",
|
|
"#CCCC33",
|
|
"#FF0000",
|
|
"#FF0033",
|
|
"#FF0066",
|
|
"#FF0099",
|
|
"#FF00CC",
|
|
"#FF00FF",
|
|
"#FF3300",
|
|
"#FF3333",
|
|
"#FF3366",
|
|
"#FF3399",
|
|
"#FF33CC",
|
|
"#FF33FF",
|
|
"#FF6600",
|
|
"#FF6633",
|
|
"#FF9900",
|
|
"#FF9933",
|
|
"#FFCC00",
|
|
"#FFCC33"
|
|
];
|
|
function useColors() {
|
|
if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
|
|
return true;
|
|
}
|
|
if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
|
|
return false;
|
|
}
|
|
let m;
|
|
return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
|
|
typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
|
|
// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
|
|
typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
|
|
typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
|
|
}
|
|
__name(useColors, "useColors");
|
|
function formatArgs(args) {
|
|
args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
|
|
if (!this.useColors) {
|
|
return;
|
|
}
|
|
const c = "color: " + this.color;
|
|
args.splice(1, 0, c, "color: inherit");
|
|
let index = 0;
|
|
let lastC = 0;
|
|
args[0].replace(/%[a-zA-Z%]/g, (match) => {
|
|
if (match === "%%") {
|
|
return;
|
|
}
|
|
index++;
|
|
if (match === "%c") {
|
|
lastC = index;
|
|
}
|
|
});
|
|
args.splice(lastC, 0, c);
|
|
}
|
|
__name(formatArgs, "formatArgs");
|
|
exports.log = console.debug || console.log || (() => {
|
|
});
|
|
function save(namespaces) {
|
|
try {
|
|
if (namespaces) {
|
|
exports.storage.setItem("debug", namespaces);
|
|
} else {
|
|
exports.storage.removeItem("debug");
|
|
}
|
|
} catch (error) {
|
|
}
|
|
}
|
|
__name(save, "save");
|
|
function load() {
|
|
let r;
|
|
try {
|
|
r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
|
|
} catch (error) {
|
|
}
|
|
if (!r && typeof process !== "undefined" && "env" in process) {
|
|
r = process.env.DEBUG;
|
|
}
|
|
return r;
|
|
}
|
|
__name(load, "load");
|
|
function localstorage() {
|
|
try {
|
|
return localStorage;
|
|
} catch (error) {
|
|
}
|
|
}
|
|
__name(localstorage, "localstorage");
|
|
module.exports = require_common()(exports);
|
|
var { formatters } = module.exports;
|
|
formatters.j = function(v) {
|
|
try {
|
|
return JSON.stringify(v);
|
|
} catch (error) {
|
|
return "[UnexpectedJSONParseError]: " + error.message;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/.pnpm/supports-color@10.2.2/node_modules/supports-color/index.js
|
|
var supports_color_exports = {};
|
|
__export(supports_color_exports, {
|
|
createSupportsColor: () => createSupportsColor,
|
|
default: () => supports_color_default
|
|
});
|
|
import process2 from "node:process";
|
|
import os from "node:os";
|
|
import tty from "node: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);
|
|
}
|
|
function envForceColor() {
|
|
if (!("FORCE_COLOR" in env)) {
|
|
return;
|
|
}
|
|
if (env.FORCE_COLOR === "true") {
|
|
return 1;
|
|
}
|
|
if (env.FORCE_COLOR === "false") {
|
|
return 0;
|
|
}
|
|
if (env.FORCE_COLOR.length === 0) {
|
|
return 1;
|
|
}
|
|
const level = Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
|
|
if (![0, 1, 2, 3].includes(level)) {
|
|
return;
|
|
}
|
|
return level;
|
|
}
|
|
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", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
|
|
return 3;
|
|
}
|
|
if (["TRAVIS", "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 (env.TERM === "xterm-ghostty") {
|
|
return 3;
|
|
}
|
|
if (env.TERM === "wezterm") {
|
|
return 3;
|
|
}
|
|
if ("TERM_PROGRAM" in env) {
|
|
const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
|
|
switch (env.TERM_PROGRAM) {
|
|
case "iTerm.app": {
|
|
return version >= 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 env, flagForceColor, supportsColor, supports_color_default;
|
|
var init_supports_color = __esm({
|
|
"../../node_modules/.pnpm/supports-color@10.2.2/node_modules/supports-color/index.js"() {
|
|
__name(hasFlag, "hasFlag");
|
|
({ env } = process2);
|
|
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;
|
|
}
|
|
__name(envForceColor, "envForceColor");
|
|
__name(translateLevel, "translateLevel");
|
|
__name(_supportsColor, "_supportsColor");
|
|
__name(createSupportsColor, "createSupportsColor");
|
|
supportsColor = {
|
|
stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
|
|
stderr: createSupportsColor({ isTTY: tty.isatty(2) })
|
|
};
|
|
supports_color_default = supportsColor;
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/node.js
|
|
var require_node = __commonJS({
|
|
"../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/node.js"(exports, module) {
|
|
var tty2 = __require("tty");
|
|
var util = __require("util");
|
|
exports.init = init;
|
|
exports.log = log;
|
|
exports.formatArgs = formatArgs;
|
|
exports.save = save;
|
|
exports.load = load;
|
|
exports.useColors = useColors;
|
|
exports.destroy = util.deprecate(
|
|
() => {
|
|
},
|
|
"Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
|
|
);
|
|
exports.colors = [6, 2, 3, 4, 5, 1];
|
|
try {
|
|
const supportsColor2 = (init_supports_color(), __toCommonJS(supports_color_exports));
|
|
if (supportsColor2 && (supportsColor2.stderr || supportsColor2).level >= 2) {
|
|
exports.colors = [
|
|
20,
|
|
21,
|
|
26,
|
|
27,
|
|
32,
|
|
33,
|
|
38,
|
|
39,
|
|
40,
|
|
41,
|
|
42,
|
|
43,
|
|
44,
|
|
45,
|
|
56,
|
|
57,
|
|
62,
|
|
63,
|
|
68,
|
|
69,
|
|
74,
|
|
75,
|
|
76,
|
|
77,
|
|
78,
|
|
79,
|
|
80,
|
|
81,
|
|
92,
|
|
93,
|
|
98,
|
|
99,
|
|
112,
|
|
113,
|
|
128,
|
|
129,
|
|
134,
|
|
135,
|
|
148,
|
|
149,
|
|
160,
|
|
161,
|
|
162,
|
|
163,
|
|
164,
|
|
165,
|
|
166,
|
|
167,
|
|
168,
|
|
169,
|
|
170,
|
|
171,
|
|
172,
|
|
173,
|
|
178,
|
|
179,
|
|
184,
|
|
185,
|
|
196,
|
|
197,
|
|
198,
|
|
199,
|
|
200,
|
|
201,
|
|
202,
|
|
203,
|
|
204,
|
|
205,
|
|
206,
|
|
207,
|
|
208,
|
|
209,
|
|
214,
|
|
215,
|
|
220,
|
|
221
|
|
];
|
|
}
|
|
} catch (error) {
|
|
}
|
|
exports.inspectOpts = Object.keys(process.env).filter((key) => {
|
|
return /^debug_/i.test(key);
|
|
}).reduce((obj, key) => {
|
|
const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
|
|
return k.toUpperCase();
|
|
});
|
|
let val = process.env[key];
|
|
if (/^(yes|on|true|enabled)$/i.test(val)) {
|
|
val = true;
|
|
} else if (/^(no|off|false|disabled)$/i.test(val)) {
|
|
val = false;
|
|
} else if (val === "null") {
|
|
val = null;
|
|
} else {
|
|
val = Number(val);
|
|
}
|
|
obj[prop] = val;
|
|
return obj;
|
|
}, {});
|
|
function useColors() {
|
|
return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty2.isatty(process.stderr.fd);
|
|
}
|
|
__name(useColors, "useColors");
|
|
function formatArgs(args) {
|
|
const { namespace: name, useColors: useColors2 } = this;
|
|
if (useColors2) {
|
|
const c = this.color;
|
|
const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
|
|
const prefix = ` ${colorCode};1m${name} \x1B[0m`;
|
|
args[0] = prefix + args[0].split("\n").join("\n" + prefix);
|
|
args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
|
|
} else {
|
|
args[0] = getDate() + name + " " + args[0];
|
|
}
|
|
}
|
|
__name(formatArgs, "formatArgs");
|
|
function getDate() {
|
|
if (exports.inspectOpts.hideDate) {
|
|
return "";
|
|
}
|
|
return (/* @__PURE__ */ new Date()).toISOString() + " ";
|
|
}
|
|
__name(getDate, "getDate");
|
|
function log(...args) {
|
|
return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + "\n");
|
|
}
|
|
__name(log, "log");
|
|
function save(namespaces) {
|
|
if (namespaces) {
|
|
process.env.DEBUG = namespaces;
|
|
} else {
|
|
delete process.env.DEBUG;
|
|
}
|
|
}
|
|
__name(save, "save");
|
|
function load() {
|
|
return process.env.DEBUG;
|
|
}
|
|
__name(load, "load");
|
|
function init(debug) {
|
|
debug.inspectOpts = {};
|
|
const keys = Object.keys(exports.inspectOpts);
|
|
for (let i = 0; i < keys.length; i++) {
|
|
debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
|
|
}
|
|
}
|
|
__name(init, "init");
|
|
module.exports = require_common()(exports);
|
|
var { formatters } = module.exports;
|
|
formatters.o = function(v) {
|
|
this.inspectOpts.colors = this.useColors;
|
|
return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
|
|
};
|
|
formatters.O = function(v) {
|
|
this.inspectOpts.colors = this.useColors;
|
|
return util.inspect(v, this.inspectOpts);
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js
|
|
var require_src = __commonJS({
|
|
"../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js"(exports, module) {
|
|
if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
|
|
module.exports = require_browser();
|
|
} else {
|
|
module.exports = require_node();
|
|
}
|
|
}
|
|
});
|
|
|
|
export {
|
|
require_src
|
|
};
|