@heybox/hb-sdk 0.9.1-alpha.5 → 0.9.1-alpha.6

package/dist/cli-chunks/session-DZrr6RYK.cjs

@@ -1,3404 +0,0 @@
-'use strict';
-
-var index = require('./index-TQwjvNjL.cjs');
-var node_crypto = require('node:crypto');
-var path = require('node:path');
-var require$$0$2 = require('fs');
-var require$$0 = require('constants');
-var require$$0$1 = require('stream');
-var require$$1 = require('util');
-var require$$0$3 = require('assert');
-var require$$1$1 = require('path');
-
-const HEYBOX_API_BASE_URL = 'https://api.xiaoheihe.cn';
-const HEYBOX_LOGIN_BASE_URL = 'https://login.xiaoheihe.cn';
-const TRUSTED_HEYBOX_API_HOST_SUFFIXES = ['.xiaoheihe.cn', '.debugmode.cn'];
-function resolveHeyboxApiBaseUrl(options = {}) {
-    const env = options.env;
-    const baseUrl = normalizeHeyboxOriginUrl(options.apiBaseUrl ?? env?.HB_SDK_API_BASE_URL ?? HEYBOX_API_BASE_URL, 'Heybox API baseUrl');
-    assertSafeHeyboxApiBaseUrl(baseUrl, {
-        allowUnsafeApiBaseUrl: options.allowUnsafeApiBaseUrl === true || isTruthyEnvFlag(env?.HB_SDK_ALLOW_UNSAFE_API_BASE_URL),
-    });
-    return baseUrl;
-}
-function resolveHeyboxLoginBaseUrl(options = {}) {
-    const env = options.env;
-    return normalizeHeyboxOriginUrl(options.loginBaseUrl ?? env?.HB_SDK_LOGIN_BASE_URL ?? HEYBOX_LOGIN_BASE_URL, 'Heybox login baseUrl');
-}
-function normalizeHeyboxOriginUrl(value, label) {
-    const raw = String(value ?? '').trim();
-    if (!raw) {
-        throw new Error(`${label} 不能为空`);
-    }
-    let url;
-    try {
-        url = new URL(raw);
-    }
-    catch {
-        throw new Error(`${label} 必须是合法的 http(s) origin：${raw}`);
-    }
-    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
-        throw new Error(`${label} 只支持 http(s) 协议：${raw}`);
-    }
-    if (url.username || url.password) {
-        throw new Error(`${label} 不允许包含用户名或密码：${raw}`);
-    }
-    const rawSuffix = raw.match(/^[a-z][a-z\d+.-]*:\/\/[^/?#]+(.*)$/i)?.[1] ?? '';
-    if ((rawSuffix && rawSuffix !== '/') || url.search || url.hash) {
-        throw new Error(`${label} 只支持 origin，不允许包含 path、query 或 hash：${raw}`);
-    }
-    return url.origin;
-}
-function assertSafeHeyboxApiBaseUrl(origin, options) {
-    if (options.allowUnsafeApiBaseUrl) {
-        return;
-    }
-    const url = new URL(origin);
-    if (url.protocol !== 'https:' || !isTrustedHeyboxApiHost(url.hostname)) {
-        throw new Error('Heybox API baseUrl 默认只允许 Heybox 受信 HTTPS origin；本地调试请显式使用 --allow-unsafe-api-base-url 或 HB_SDK_ALLOW_UNSAFE_API_BASE_URL=1');
-    }
-}
-function isTrustedHeyboxApiHost(hostname) {
-    return TRUSTED_HEYBOX_API_HOST_SUFFIXES.some((suffix) => hostname === suffix.slice(1) || hostname.endsWith(suffix));
-}
-function isTruthyEnvFlag(value) {
-    return ['1', 'true', 'yes', 'on'].includes(String(value ?? '')
-        .trim()
-        .toLowerCase());
-}
-/** 开放平台网页地址独立于 API 地址，避免跨环境申请。 */
-function resolveHeyboxOpenPlatformBaseUrl(env = process.env) {
-    return normalizeHeyboxOriginUrl(env.HB_SDK_OPEN_PLATFORM_BASE_URL ?? 'https://open.xiaoheihe.cn', '开放平台 baseUrl');
-}
-
-const SIGN_VERSION = '999.0.4';
-const SIGN_CHARSET = 'AB45STUVWZEFGJ6CH01D237IXYPQRKLMN89';
-function createHeyboxOpenPlatformSignParams(pathname, options = {}) {
-    const now = options.now ?? new Date();
-    const time = Math.trunc(now.getTime() / 1000);
-    const nonce = options.nonce ?? md5(`${time}${Date.now()}${node_crypto.randomBytes(16).toString('hex')}`).toUpperCase();
-    return {
-        version: SIGN_VERSION,
-        hkey: generateSignature(pathname, time + 1, nonce),
-        _time: time,
-        nonce,
-    };
-}
-function generateSignature(path, time, nonce) {
-    const normalizedPath = `/${path
-        .split('/')
-        .filter(Boolean)
-        .join('/')}/`;
-    const transformedTime = transformWithOffset(String(time), SIGN_CHARSET, -2);
-    const transformedPath = transform(normalizedPath, SIGN_CHARSET);
-    const transformedNonce = transform(nonce, SIGN_CHARSET);
-    const combined = interleave([transformedTime, transformedPath, transformedNonce]).slice(0, 20);
-    const hash = md5(combined);
-    let sign = `${mixColumns(hash.slice(-6).split('').map((char) => char.charCodeAt(0))).reduce((sum, value) => sum + value, 0) % 100}`;
-    sign = sign.length < 2 ? `0${sign}` : sign;
-    return `${transformWithOffset(hash.substring(0, 5), SIGN_CHARSET, -4)}${sign}`;
-}
-function transformWithOffset(str, charset, offset) {
-    return transform(str, charset.slice(0, offset));
-}
-function transform(str, charset) {
-    let output = '';
-    for (let index = 0; index < str.length; index += 1) {
-        output += charset[str.charCodeAt(index) % charset.length];
-    }
-    return output;
-}
-function interleave(strings) {
-    let output = '';
-    const maxLength = Math.max(...strings.map((str) => str.length));
-    for (let index = 0; index < maxLength; index += 1) {
-        for (const str of strings) {
-            if (index < str.length) {
-                output += str[index];
-            }
-        }
-    }
-    return output;
-}
-function mixColumns(column) {
-    const output = [...column];
-    output[0] = multiplyE(column[0]) ^ multiply4(column[1]) ^ multiply3(column[2]) ^ multiply2(column[3]);
-    output[1] = multiply2(column[0]) ^ multiplyE(column[1]) ^ multiply4(column[2]) ^ multiply3(column[3]);
-    output[2] = multiply3(column[0]) ^ multiply2(column[1]) ^ multiplyE(column[2]) ^ multiply4(column[3]);
-    output[3] = multiply4(column[0]) ^ multiply3(column[1]) ^ multiply2(column[2]) ^ multiplyE(column[3]);
-    return output;
-}
-function multiply1(value) {
-    if (value & 0x80) {
-        return ((value << 1) ^ 0x1b) & 0xff;
-    }
-    return value << 1;
-}
-function multiply2(value) {
-    return multiply1(value) ^ value;
-}
-function multiply3(value) {
-    return multiply2(multiply1(value));
-}
-function multiply4(value) {
-    return multiply3(multiply2(multiply1(value)));
-}
-function multiplyE(value) {
-    return multiply4(value) ^ multiply3(value) ^ multiply2(value);
-}
-function md5(input) {
-    return node_crypto.createHash('md5').update(input).digest('hex');
-}
-
-const DEFAULT_PLATFORM_PARAMS = {
-    os_type: 'web',
-    app: 'heybox',
-    x_client_type: 'web',
-    x_os_type: 'Mac',
-    x_app: 'heybox',
-    x_client_version: '999.999.999',
-};
-const HEYBOX_WEB_REFERER = 'https://www.xiaoheihe.cn/';
-function resolveHeyboxId(session) {
-    if (session.heyboxId.trim()) {
-        return session.heyboxId.trim();
-    }
-    return session.cookieHeader
-        .split(';')
-        .map((part) => part.trim())
-        .find((part) => part.startsWith('heybox_id='))
-        ?.slice('heybox_id='.length);
-}
-function createHeyboxAuthHeaders(session, options = {}) {
-    const serviceTag = index.resolveHeyboxRylaiServiceTag(options.pathWithQuery);
-    return {
-        Cookie: session.cookieHeader,
-        Referer: HEYBOX_WEB_REFERER,
-        ...(options.contentType ? { 'Content-Type': options.contentType } : {}),
-        ...(serviceTag ? { 'x-rylai-service-tag': serviceTag } : {}),
-    };
-}
-function createHeyboxRequestContext(session, options = {}) {
-    const heyboxId = resolveHeyboxId(session);
-    const serviceTag = index.resolveHeyboxRylaiServiceTag(options.pathWithQuery);
-    return {
-        baseUrl: HEYBOX_API_BASE_URL,
-        headers: createHeyboxAuthHeaders(session, options),
-        platformParams: {
-            ...DEFAULT_PLATFORM_PARAMS,
-            ...options.platformParams,
-            ...(heyboxId ? { heybox_id: heyboxId } : {}),
-            ...(serviceTag ? { special_tag: serviceTag } : {}),
-        },
-    };
-}
-function createHeyboxOpenPlatformRequestContext(session, pathWithQuery, options = {}) {
-    return createHeyboxRequestContext(session, {
-        ...options,
-        pathWithQuery,
-        platformParams: {
-            x_app: 'heybox_website',
-            ...createHeyboxOpenPlatformSignParams(getApiPathname(pathWithQuery)),
-            ...options.platformParams,
-        },
-    });
-}
-function createHeyboxApiUrl(baseUrl, pathWithQuery, params) {
-    const url = new URL(pathWithQuery, baseUrl);
-    for (const [key, value] of Object.entries(params)) {
-        if (value !== '') {
-            url.searchParams.set(key, String(value));
-        }
-    }
-    return url.toString();
-}
-function getApiPathname(pathWithQuery) {
-    return new URL(pathWithQuery, HEYBOX_API_BASE_URL).pathname;
-}
-const ENVELOPE_BODY_PREVIEW_LENGTH = 1000;
-/** 网关限流状态码；403（封禁）与 429（限速）走独立错误分支。 */
-const RATE_LIMIT_HTTP_STATUSES = new Set([403, 429]);
-/** HTTP-date 只接受以星期缩写开头的合法形态，避免宽松解析把垃圾值当日期。 */
-const HTTP_DATE_RE = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun)\b/i;
-/** 网关原文里的等待时长；例如 `43200s内请求 ... 6127次，限制访问 86400s`。 */
-const GATEWAY_RETRY_AFTER_PATTERNS = [
-    /限制访问\s*(\d+(?:\.\d+)?)\s*s/i,
-    /retry[\s_-]*after[^0-9]{0,12}(\d+(?:\.\d+)?)\s*s/i,
-    /(\d+(?:\.\d+)?)\s*秒后/,
-];
-async function readHeyboxApiEnvelope(response, options) {
-    const rawBody = await response.text();
-    let envelope = null;
-    let parseError = null;
-    if (rawBody) {
-        try {
-            envelope = JSON.parse(rawBody);
-        }
-        catch (error) {
-            parseError = error;
-        }
-    }
-    const envelopeOk = envelope?.status === 'ok' && (!options.requireResult || envelope?.result !== undefined);
-    if (response.ok && envelopeOk) {
-        return envelope.result;
-    }
-    const { message, verboseMessage } = formatHeyboxEnvelopeError({
-        response,
-        envelope,
-        parseError,
-        rawBody,
-        pathWithQuery: options.pathWithQuery,
-    });
-    if (RATE_LIMIT_HTTP_STATUSES.has(response.status)) {
-        const gatewayMessage = readGatewayRateLimitMessage(envelope, rawBody);
-        const retryAfterMs = readRetryAfterMs(response, gatewayMessage);
-        throw new index.CliRateLimitedError(message, {
-            gatewayMessage,
-            httpStatus: response.status,
-            ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
-            verboseMessage,
-        });
-    }
-    throw new index.CliError(message, verboseMessage, { httpStatus: response.status });
-}
-/**
- * 优先读 `Retry-After` 响应头，其次从网关原文解析等待时长。
- *
- * 只返回**正数毫秒**：`Retry-After: 0`、已过期的 HTTP-date、负数与非法值一律按「网关没有
- * 给出时长」处理，由消费方回落默认窗口（CLI 30s 起、宿主页 30s）。这样两端对同一个状态
- * 的解读一致，也不会出现「宿主页立即重连、CLI 仍在压制」的分歧。
- */
-function readRetryAfterMs(response, gatewayMessage) {
-    const headerValue = response.headers?.get('retry-after')?.trim();
-    if (headerValue) {
-        // 纯数字才是 delta-seconds；其余按 HTTP-date 解析，避免 `Date.parse('-5')` 产出垃圾值。
-        if (/^\d+$/.test(headerValue)) {
-            const headerMs = Number(headerValue) * 1000;
-            if (headerMs > 0)
-                return Math.round(headerMs);
-        }
-        else if (HTTP_DATE_RE.test(headerValue)) {
-            const headerDate = Date.parse(headerValue);
-            if (Number.isFinite(headerDate) && headerDate > Date.now()) {
-                return headerDate - Date.now();
-            }
-        }
-    }
-    for (const pattern of GATEWAY_RETRY_AFTER_PATTERNS) {
-        const matched = gatewayMessage.match(pattern);
-        const seconds = matched ? Number(matched[1]) : Number.NaN;
-        if (Number.isFinite(seconds) && seconds > 0) {
-            return Math.round(seconds * 1000);
-        }
-    }
-    return undefined;
-}
-/** 网关原文：优先 envelope 的 msg，退化为响应体原文，最后回落到通用文案。 */
-function readGatewayRateLimitMessage(envelope, rawBody) {
-    const msg = typeof envelope?.msg === 'string' ? envelope.msg.trim() : '';
-    if (msg)
-        return msg;
-    const sbeUserMessage = readSbeUserMessage(envelope?.result);
-    if (sbeUserMessage)
-        return sbeUserMessage;
-    return rawBody.trim() ? truncate(rawBody.trim(), ENVELOPE_BODY_PREVIEW_LENGTH) : '';
-}
-function formatHeyboxEnvelopeError(input) {
-    const parts = [`Heybox API ${input.pathWithQuery} failed`, `HTTP ${input.response.status}`];
-    if (input.envelope) {
-        const msg = typeof input.envelope.msg === 'string' ? input.envelope.msg.trim() : '';
-        const sbeUserMessage = readSbeUserMessage(input.envelope.result);
-        parts.push(`msg=${msg || '(empty)'}`);
-        if (typeof input.envelope.status === 'string') {
-            parts.push(`envelope.status=${input.envelope.status}`);
-        }
-        const { status: _s, msg: _m, result: _r, ...extras } = input.envelope;
-        if (Object.keys(extras).length > 0) {
-            parts.push(`extras=${truncate(safeJsonStringify(extras), ENVELOPE_BODY_PREVIEW_LENGTH)}`);
-        }
-        if (input.envelope.result !== undefined) {
-            parts.push(`result=${truncate(safeJsonStringify(input.envelope.result), ENVELOPE_BODY_PREVIEW_LENGTH)}`);
-        }
-        return {
-            message: sbeUserMessage || msg || `Heybox API ${input.pathWithQuery} 请求失败`,
-            verboseMessage: parts.join(' '),
-        };
-    }
-    if (input.parseError) {
-        const parseMsg = input.parseError instanceof Error ? input.parseError.message : String(input.parseError);
-        parts.push(`parseError=${parseMsg}`);
-    }
-    parts.push(input.rawBody ? `body=${truncate(input.rawBody, ENVELOPE_BODY_PREVIEW_LENGTH)}` : 'body=(empty)');
-    return {
-        message: `Heybox API ${input.pathWithQuery} 请求失败`,
-        verboseMessage: parts.join(' '),
-    };
-}
-function readSbeUserMessage(result) {
-    if (!result || typeof result !== 'object') {
-        return '';
-    }
-    const sbe = result.sbe;
-    if (!sbe || typeof sbe !== 'object') {
-        return '';
-    }
-    const userMessage = sbe.user_message;
-    return typeof userMessage === 'string' ? userMessage.trim() : '';
-}
-function truncate(value, max) {
-    return value.length > max ? `${value.slice(0, max)}...(+${value.length - max} chars)` : value;
-}
-function safeJsonStringify(value) {
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return String(value);
-    }
-}
-
-var fs$1 = {};
-
-var universalify = {};
-
-var hasRequiredUniversalify;
-
-function requireUniversalify () {
-	if (hasRequiredUniversalify) return universalify;
-	hasRequiredUniversalify = 1;
-
-	universalify.fromCallback = function (fn) {
-	  return Object.defineProperty(function (...args) {
-	    if (typeof args[args.length - 1] === 'function') fn.apply(this, args);
-	    else {
-	      return new Promise((resolve, reject) => {
-	        args.push((err, res) => (err != null) ? reject(err) : resolve(res));
-	        fn.apply(this, args);
-	      })
-	    }
-	  }, 'name', { value: fn.name })
-	};
-
-	universalify.fromPromise = function (fn) {
-	  return Object.defineProperty(function (...args) {
-	    const cb = args[args.length - 1];
-	    if (typeof cb !== 'function') return fn.apply(this, args)
-	    else {
-	      args.pop();
-	      fn.apply(this, args).then(r => cb(null, r), cb);
-	    }
-	  }, 'name', { value: fn.name })
-	};
-	return universalify;
-}
-
-var polyfills;
-var hasRequiredPolyfills;
-
-function requirePolyfills () {
-	if (hasRequiredPolyfills) return polyfills;
-	hasRequiredPolyfills = 1;
-	var constants = require$$0;
-
-	var origCwd = process.cwd;
-	var cwd = null;
-
-	var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
-
-	process.cwd = function() {
-	  if (!cwd)
-	    cwd = origCwd.call(process);
-	  return cwd
-	};
-	try {
-	  process.cwd();
-	} catch (er) {}
-
-	// This check is needed until node.js 12 is required
-	if (typeof process.chdir === 'function') {
-	  var chdir = process.chdir;
-	  process.chdir = function (d) {
-	    cwd = null;
-	    chdir.call(process, d);
-	  };
-	  if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
-	}
-
-	polyfills = patch;
-
-	function patch (fs) {
-	  // (re-)implement some things that are known busted or missing.
-
-	  // lchmod, broken prior to 0.6.2
-	  // back-port the fix here.
-	  if (constants.hasOwnProperty('O_SYMLINK') &&
-	      process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-	    patchLchmod(fs);
-	  }
-
-	  // lutimes implementation, or no-op
-	  if (!fs.lutimes) {
-	    patchLutimes(fs);
-	  }
-
-	  // https://github.com/isaacs/node-graceful-fs/issues/4
-	  // Chown should not fail on einval or eperm if non-root.
-	  // It should not fail on enosys ever, as this just indicates
-	  // that a fs doesn't support the intended operation.
-
-	  fs.chown = chownFix(fs.chown);
-	  fs.fchown = chownFix(fs.fchown);
-	  fs.lchown = chownFix(fs.lchown);
-
-	  fs.chmod = chmodFix(fs.chmod);
-	  fs.fchmod = chmodFix(fs.fchmod);
-	  fs.lchmod = chmodFix(fs.lchmod);
-
-	  fs.chownSync = chownFixSync(fs.chownSync);
-	  fs.fchownSync = chownFixSync(fs.fchownSync);
-	  fs.lchownSync = chownFixSync(fs.lchownSync);
-
-	  fs.chmodSync = chmodFixSync(fs.chmodSync);
-	  fs.fchmodSync = chmodFixSync(fs.fchmodSync);
-	  fs.lchmodSync = chmodFixSync(fs.lchmodSync);
-
-	  fs.stat = statFix(fs.stat);
-	  fs.fstat = statFix(fs.fstat);
-	  fs.lstat = statFix(fs.lstat);
-
-	  fs.statSync = statFixSync(fs.statSync);
-	  fs.fstatSync = statFixSync(fs.fstatSync);
-	  fs.lstatSync = statFixSync(fs.lstatSync);
-
-	  // if lchmod/lchown do not exist, then make them no-ops
-	  if (fs.chmod && !fs.lchmod) {
-	    fs.lchmod = function (path, mode, cb) {
-	      if (cb) process.nextTick(cb);
-	    };
-	    fs.lchmodSync = function () {};
-	  }
-	  if (fs.chown && !fs.lchown) {
-	    fs.lchown = function (path, uid, gid, cb) {
-	      if (cb) process.nextTick(cb);
-	    };
-	    fs.lchownSync = function () {};
-	  }
-
-	  // on Windows, A/V software can lock the directory, causing this
-	  // to fail with an EACCES or EPERM if the directory contains newly
-	  // created files.  Try again on failure, for up to 60 seconds.
-
-	  // Set the timeout this long because some Windows Anti-Virus, such as Parity
-	  // bit9, may lock files for up to a minute, causing npm package install
-	  // failures. Also, take care to yield the scheduler. Windows scheduling gives
-	  // CPU to a busy looping process, which can cause the program causing the lock
-	  // contention to be starved of CPU by node, so the contention doesn't resolve.
-	  if (platform === "win32") {
-	    fs.rename = typeof fs.rename !== 'function' ? fs.rename
-	    : (function (fs$rename) {
-	      function rename (from, to, cb) {
-	        var start = Date.now();
-	        var backoff = 0;
-	        fs$rename(from, to, function CB (er) {
-	          if (er
-	              && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY")
-	              && Date.now() - start < 60000) {
-	            setTimeout(function() {
-	              fs.stat(to, function (stater, st) {
-	                if (stater && stater.code === "ENOENT")
-	                  fs$rename(from, to, CB);
-	                else
-	                  cb(er);
-	              });
-	            }, backoff);
-	            if (backoff < 100)
-	              backoff += 10;
-	            return;
-	          }
-	          if (cb) cb(er);
-	        });
-	      }
-	      if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
-	      return rename
-	    })(fs.rename);
-	  }
-
-	  // if read() returns EAGAIN, then just try it again.
-	  fs.read = typeof fs.read !== 'function' ? fs.read
-	  : (function (fs$read) {
-	    function read (fd, buffer, offset, length, position, callback_) {
-	      var callback;
-	      if (callback_ && typeof callback_ === 'function') {
-	        var eagCounter = 0;
-	        callback = function (er, _, __) {
-	          if (er && er.code === 'EAGAIN' && eagCounter < 10) {
-	            eagCounter ++;
-	            return fs$read.call(fs, fd, buffer, offset, length, position, callback)
-	          }
-	          callback_.apply(this, arguments);
-	        };
-	      }
-	      return fs$read.call(fs, fd, buffer, offset, length, position, callback)
-	    }
-
-	    // This ensures `util.promisify` works as it does for native `fs.read`.
-	    if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
-	    return read
-	  })(fs.read);
-
-	  fs.readSync = typeof fs.readSync !== 'function' ? fs.readSync
-	  : (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
-	    var eagCounter = 0;
-	    while (true) {
-	      try {
-	        return fs$readSync.call(fs, fd, buffer, offset, length, position)
-	      } catch (er) {
-	        if (er.code === 'EAGAIN' && eagCounter < 10) {
-	          eagCounter ++;
-	          continue
-	        }
-	        throw er
-	      }
-	    }
-	  }})(fs.readSync);
-
-	  function patchLchmod (fs) {
-	    fs.lchmod = function (path, mode, callback) {
-	      fs.open( path
-	             , constants.O_WRONLY | constants.O_SYMLINK
-	             , mode
-	             , function (err, fd) {
-	        if (err) {
-	          if (callback) callback(err);
-	          return
-	        }
-	        // prefer to return the chmod error, if one occurs,
-	        // but still try to close, and report closing errors if they occur.
-	        fs.fchmod(fd, mode, function (err) {
-	          fs.close(fd, function(err2) {
-	            if (callback) callback(err || err2);
-	          });
-	        });
-	      });
-	    };
-
-	    fs.lchmodSync = function (path, mode) {
-	      var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
-
-	      // prefer to return the chmod error, if one occurs,
-	      // but still try to close, and report closing errors if they occur.
-	      var threw = true;
-	      var ret;
-	      try {
-	        ret = fs.fchmodSync(fd, mode);
-	        threw = false;
-	      } finally {
-	        if (threw) {
-	          try {
-	            fs.closeSync(fd);
-	          } catch (er) {}
-	        } else {
-	          fs.closeSync(fd);
-	        }
-	      }
-	      return ret
-	    };
-	  }
-
-	  function patchLutimes (fs) {
-	    if (constants.hasOwnProperty("O_SYMLINK") && fs.futimes) {
-	      fs.lutimes = function (path, at, mt, cb) {
-	        fs.open(path, constants.O_SYMLINK, function (er, fd) {
-	          if (er) {
-	            if (cb) cb(er);
-	            return
-	          }
-	          fs.futimes(fd, at, mt, function (er) {
-	            fs.close(fd, function (er2) {
-	              if (cb) cb(er || er2);
-	            });
-	          });
-	        });
-	      };
-
-	      fs.lutimesSync = function (path, at, mt) {
-	        var fd = fs.openSync(path, constants.O_SYMLINK);
-	        var ret;
-	        var threw = true;
-	        try {
-	          ret = fs.futimesSync(fd, at, mt);
-	          threw = false;
-	        } finally {
-	          if (threw) {
-	            try {
-	              fs.closeSync(fd);
-	            } catch (er) {}
-	          } else {
-	            fs.closeSync(fd);
-	          }
-	        }
-	        return ret
-	      };
-
-	    } else if (fs.futimes) {
-	      fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb); };
-	      fs.lutimesSync = function () {};
-	    }
-	  }
-
-	  function chmodFix (orig) {
-	    if (!orig) return orig
-	    return function (target, mode, cb) {
-	      return orig.call(fs, target, mode, function (er) {
-	        if (chownErOk(er)) er = null;
-	        if (cb) cb.apply(this, arguments);
-	      })
-	    }
-	  }
-
-	  function chmodFixSync (orig) {
-	    if (!orig) return orig
-	    return function (target, mode) {
-	      try {
-	        return orig.call(fs, target, mode)
-	      } catch (er) {
-	        if (!chownErOk(er)) throw er
-	      }
-	    }
-	  }
-
-
-	  function chownFix (orig) {
-	    if (!orig) return orig
-	    return function (target, uid, gid, cb) {
-	      return orig.call(fs, target, uid, gid, function (er) {
-	        if (chownErOk(er)) er = null;
-	        if (cb) cb.apply(this, arguments);
-	      })
-	    }
-	  }
-
-	  function chownFixSync (orig) {
-	    if (!orig) return orig
-	    return function (target, uid, gid) {
-	      try {
-	        return orig.call(fs, target, uid, gid)
-	      } catch (er) {
-	        if (!chownErOk(er)) throw er
-	      }
-	    }
-	  }
-
-	  function statFix (orig) {
-	    if (!orig) return orig
-	    // Older versions of Node erroneously returned signed integers for
-	    // uid + gid.
-	    return function (target, options, cb) {
-	      if (typeof options === 'function') {
-	        cb = options;
-	        options = null;
-	      }
-	      function callback (er, stats) {
-	        if (stats) {
-	          if (stats.uid < 0) stats.uid += 0x100000000;
-	          if (stats.gid < 0) stats.gid += 0x100000000;
-	        }
-	        if (cb) cb.apply(this, arguments);
-	      }
-	      return options ? orig.call(fs, target, options, callback)
-	        : orig.call(fs, target, callback)
-	    }
-	  }
-
-	  function statFixSync (orig) {
-	    if (!orig) return orig
-	    // Older versions of Node erroneously returned signed integers for
-	    // uid + gid.
-	    return function (target, options) {
-	      var stats = options ? orig.call(fs, target, options)
-	        : orig.call(fs, target);
-	      if (stats) {
-	        if (stats.uid < 0) stats.uid += 0x100000000;
-	        if (stats.gid < 0) stats.gid += 0x100000000;
-	      }
-	      return stats;
-	    }
-	  }
-
-	  // ENOSYS means that the fs doesn't support the op. Just ignore
-	  // that, because it doesn't matter.
-	  //
-	  // if there's no getuid, or if getuid() is something other
-	  // than 0, and the error is EINVAL or EPERM, then just ignore
-	  // it.
-	  //
-	  // This specific case is a silent failure in cp, install, tar,
-	  // and most other unix tools that manage permissions.
-	  //
-	  // When running as root, or if other types of errors are
-	  // encountered, then it's strict.
-	  function chownErOk (er) {
-	    if (!er)
-	      return true
-
-	    if (er.code === "ENOSYS")
-	      return true
-
-	    var nonroot = !process.getuid || process.getuid() !== 0;
-	    if (nonroot) {
-	      if (er.code === "EINVAL" || er.code === "EPERM")
-	        return true
-	    }
-
-	    return false
-	  }
-	}
-	return polyfills;
-}
-
-var legacyStreams;
-var hasRequiredLegacyStreams;
-
-function requireLegacyStreams () {
-	if (hasRequiredLegacyStreams) return legacyStreams;
-	hasRequiredLegacyStreams = 1;
-	var Stream = require$$0$1.Stream;
-
-	legacyStreams = legacy;
-
-	function legacy (fs) {
-	  return {
-	    ReadStream: ReadStream,
-	    WriteStream: WriteStream
-	  }
-
-	  function ReadStream (path, options) {
-	    if (!(this instanceof ReadStream)) return new ReadStream(path, options);
-
-	    Stream.call(this);
-
-	    var self = this;
-
-	    this.path = path;
-	    this.fd = null;
-	    this.readable = true;
-	    this.paused = false;
-
-	    this.flags = 'r';
-	    this.mode = 438; /*=0666*/
-	    this.bufferSize = 64 * 1024;
-
-	    options = options || {};
-
-	    // Mixin options into this
-	    var keys = Object.keys(options);
-	    for (var index = 0, length = keys.length; index < length; index++) {
-	      var key = keys[index];
-	      this[key] = options[key];
-	    }
-
-	    if (this.encoding) this.setEncoding(this.encoding);
-
-	    if (this.start !== undefined) {
-	      if ('number' !== typeof this.start) {
-	        throw TypeError('start must be a Number');
-	      }
-	      if (this.end === undefined) {
-	        this.end = Infinity;
-	      } else if ('number' !== typeof this.end) {
-	        throw TypeError('end must be a Number');
-	      }
-
-	      if (this.start > this.end) {
-	        throw new Error('start must be <= end');
-	      }
-
-	      this.pos = this.start;
-	    }
-
-	    if (this.fd !== null) {
-	      process.nextTick(function() {
-	        self._read();
-	      });
-	      return;
-	    }
-
-	    fs.open(this.path, this.flags, this.mode, function (err, fd) {
-	      if (err) {
-	        self.emit('error', err);
-	        self.readable = false;
-	        return;
-	      }
-
-	      self.fd = fd;
-	      self.emit('open', fd);
-	      self._read();
-	    });
-	  }
-
-	  function WriteStream (path, options) {
-	    if (!(this instanceof WriteStream)) return new WriteStream(path, options);
-
-	    Stream.call(this);
-
-	    this.path = path;
-	    this.fd = null;
-	    this.writable = true;
-
-	    this.flags = 'w';
-	    this.encoding = 'binary';
-	    this.mode = 438; /*=0666*/
-	    this.bytesWritten = 0;
-
-	    options = options || {};
-
-	    // Mixin options into this
-	    var keys = Object.keys(options);
-	    for (var index = 0, length = keys.length; index < length; index++) {
-	      var key = keys[index];
-	      this[key] = options[key];
-	    }
-
-	    if (this.start !== undefined) {
-	      if ('number' !== typeof this.start) {
-	        throw TypeError('start must be a Number');
-	      }
-	      if (this.start < 0) {
-	        throw new Error('start must be >= zero');
-	      }
-
-	      this.pos = this.start;
-	    }
-
-	    this.busy = false;
-	    this._queue = [];
-
-	    if (this.fd === null) {
-	      this._open = fs.open;
-	      this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
-	      this.flush();
-	    }
-	  }
-	}
-	return legacyStreams;
-}
-
-var clone_1;
-var hasRequiredClone;
-
-function requireClone () {
-	if (hasRequiredClone) return clone_1;
-	hasRequiredClone = 1;
-
-	clone_1 = clone;
-
-	var getPrototypeOf = Object.getPrototypeOf || function (obj) {
-	  return obj.__proto__
-	};
-
-	function clone (obj) {
-	  if (obj === null || typeof obj !== 'object')
-	    return obj
-
-	  if (obj instanceof Object)
-	    var copy = { __proto__: getPrototypeOf(obj) };
-	  else
-	    var copy = Object.create(null);
-
-	  Object.getOwnPropertyNames(obj).forEach(function (key) {
-	    Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
-	  });
-
-	  return copy
-	}
-	return clone_1;
-}
-
-var gracefulFs;
-var hasRequiredGracefulFs;
-
-function requireGracefulFs () {
-	if (hasRequiredGracefulFs) return gracefulFs;
-	hasRequiredGracefulFs = 1;
-	var fs = require$$0$2;
-	var polyfills = requirePolyfills();
-	var legacy = requireLegacyStreams();
-	var clone = requireClone();
-
-	var util = require$$1;
-
-	/* istanbul ignore next - node 0.x polyfill */
-	var gracefulQueue;
-	var previousSymbol;
-
-	/* istanbul ignore else - node 0.x polyfill */
-	if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
-	  gracefulQueue = Symbol.for('graceful-fs.queue');
-	  // This is used in testing by future versions
-	  previousSymbol = Symbol.for('graceful-fs.previous');
-	} else {
-	  gracefulQueue = '___graceful-fs.queue';
-	  previousSymbol = '___graceful-fs.previous';
-	}
-
-	function noop () {}
-
-	function publishQueue(context, queue) {
-	  Object.defineProperty(context, gracefulQueue, {
-	    get: function() {
-	      return queue
-	    }
-	  });
-	}
-
-	var debug = noop;
-	if (util.debuglog)
-	  debug = util.debuglog('gfs4');
-	else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
-	  debug = function() {
-	    var m = util.format.apply(util, arguments);
-	    m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ');
-	    console.error(m);
-	  };
-
-	// Once time initialization
-	if (!fs[gracefulQueue]) {
-	  // This queue can be shared by multiple loaded instances
-	  var queue = index.commonjsGlobal[gracefulQueue] || [];
-	  publishQueue(fs, queue);
-
-	  // Patch fs.close/closeSync to shared queue version, because we need
-	  // to retry() whenever a close happens *anywhere* in the program.
-	  // This is essential when multiple graceful-fs instances are
-	  // in play at the same time.
-	  fs.close = (function (fs$close) {
-	    function close (fd, cb) {
-	      return fs$close.call(fs, fd, function (err) {
-	        // This function uses the graceful-fs shared queue
-	        if (!err) {
-	          resetQueue();
-	        }
-
-	        if (typeof cb === 'function')
-	          cb.apply(this, arguments);
-	      })
-	    }
-
-	    Object.defineProperty(close, previousSymbol, {
-	      value: fs$close
-	    });
-	    return close
-	  })(fs.close);
-
-	  fs.closeSync = (function (fs$closeSync) {
-	    function closeSync (fd) {
-	      // This function uses the graceful-fs shared queue
-	      fs$closeSync.apply(fs, arguments);
-	      resetQueue();
-	    }
-
-	    Object.defineProperty(closeSync, previousSymbol, {
-	      value: fs$closeSync
-	    });
-	    return closeSync
-	  })(fs.closeSync);
-
-	  if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
-	    process.on('exit', function() {
-	      debug(fs[gracefulQueue]);
-	      require$$0$3.equal(fs[gracefulQueue].length, 0);
-	    });
-	  }
-	}
-
-	if (!index.commonjsGlobal[gracefulQueue]) {
-	  publishQueue(index.commonjsGlobal, fs[gracefulQueue]);
-	}
-
-	gracefulFs = patch(clone(fs));
-	if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
-	    gracefulFs = patch(fs);
-	    fs.__patched = true;
-	}
-
-	function patch (fs) {
-	  // Everything that references the open() function needs to be in here
-	  polyfills(fs);
-	  fs.gracefulify = patch;
-
-	  fs.createReadStream = createReadStream;
-	  fs.createWriteStream = createWriteStream;
-	  var fs$readFile = fs.readFile;
-	  fs.readFile = readFile;
-	  function readFile (path, options, cb) {
-	    if (typeof options === 'function')
-	      cb = options, options = null;
-
-	    return go$readFile(path, options, cb)
-
-	    function go$readFile (path, options, cb, startTime) {
-	      return fs$readFile(path, options, function (err) {
-	        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-	          enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()]);
-	        else {
-	          if (typeof cb === 'function')
-	            cb.apply(this, arguments);
-	        }
-	      })
-	    }
-	  }
-
-	  var fs$writeFile = fs.writeFile;
-	  fs.writeFile = writeFile;
-	  function writeFile (path, data, options, cb) {
-	    if (typeof options === 'function')
-	      cb = options, options = null;
-
-	    return go$writeFile(path, data, options, cb)
-
-	    function go$writeFile (path, data, options, cb, startTime) {
-	      return fs$writeFile(path, data, options, function (err) {
-	        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-	          enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()]);
-	        else {
-	          if (typeof cb === 'function')
-	            cb.apply(this, arguments);
-	        }
-	      })
-	    }
-	  }
-
-	  var fs$appendFile = fs.appendFile;
-	  if (fs$appendFile)
-	    fs.appendFile = appendFile;
-	  function appendFile (path, data, options, cb) {
-	    if (typeof options === 'function')
-	      cb = options, options = null;
-
-	    return go$appendFile(path, data, options, cb)
-
-	    function go$appendFile (path, data, options, cb, startTime) {
-	      return fs$appendFile(path, data, options, function (err) {
-	        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-	          enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()]);
-	        else {
-	          if (typeof cb === 'function')
-	            cb.apply(this, arguments);
-	        }
-	      })
-	    }
-	  }
-
-	  var fs$copyFile = fs.copyFile;
-	  if (fs$copyFile)
-	    fs.copyFile = copyFile;
-	  function copyFile (src, dest, flags, cb) {
-	    if (typeof flags === 'function') {
-	      cb = flags;
-	      flags = 0;
-	    }
-	    return go$copyFile(src, dest, flags, cb)
-
-	    function go$copyFile (src, dest, flags, cb, startTime) {
-	      return fs$copyFile(src, dest, flags, function (err) {
-	        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-	          enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()]);
-	        else {
-	          if (typeof cb === 'function')
-	            cb.apply(this, arguments);
-	        }
-	      })
-	    }
-	  }
-
-	  var fs$readdir = fs.readdir;
-	  fs.readdir = readdir;
-	  var noReaddirOptionVersions = /^v[0-5]\./;
-	  function readdir (path, options, cb) {
-	    if (typeof options === 'function')
-	      cb = options, options = null;
-
-	    var go$readdir = noReaddirOptionVersions.test(process.version)
-	      ? function go$readdir (path, options, cb, startTime) {
-	        return fs$readdir(path, fs$readdirCallback(
-	          path, options, cb, startTime
-	        ))
-	      }
-	      : function go$readdir (path, options, cb, startTime) {
-	        return fs$readdir(path, options, fs$readdirCallback(
-	          path, options, cb, startTime
-	        ))
-	      };
-
-	    return go$readdir(path, options, cb)
-
-	    function fs$readdirCallback (path, options, cb, startTime) {
-	      return function (err, files) {
-	        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-	          enqueue([
-	            go$readdir,
-	            [path, options, cb],
-	            err,
-	            startTime || Date.now(),
-	            Date.now()
-	          ]);
-	        else {
-	          if (files && files.sort)
-	            files.sort();
-
-	          if (typeof cb === 'function')
-	            cb.call(this, err, files);
-	        }
-	      }
-	    }
-	  }
-
-	  if (process.version.substr(0, 4) === 'v0.8') {
-	    var legStreams = legacy(fs);
-	    ReadStream = legStreams.ReadStream;
-	    WriteStream = legStreams.WriteStream;
-	  }
-
-	  var fs$ReadStream = fs.ReadStream;
-	  if (fs$ReadStream) {
-	    ReadStream.prototype = Object.create(fs$ReadStream.prototype);
-	    ReadStream.prototype.open = ReadStream$open;
-	  }
-
-	  var fs$WriteStream = fs.WriteStream;
-	  if (fs$WriteStream) {
-	    WriteStream.prototype = Object.create(fs$WriteStream.prototype);
-	    WriteStream.prototype.open = WriteStream$open;
-	  }
-
-	  Object.defineProperty(fs, 'ReadStream', {
-	    get: function () {
-	      return ReadStream
-	    },
-	    set: function (val) {
-	      ReadStream = val;
-	    },
-	    enumerable: true,
-	    configurable: true
-	  });
-	  Object.defineProperty(fs, 'WriteStream', {
-	    get: function () {
-	      return WriteStream
-	    },
-	    set: function (val) {
-	      WriteStream = val;
-	    },
-	    enumerable: true,
-	    configurable: true
-	  });
-
-	  // legacy names
-	  var FileReadStream = ReadStream;
-	  Object.defineProperty(fs, 'FileReadStream', {
-	    get: function () {
-	      return FileReadStream
-	    },
-	    set: function (val) {
-	      FileReadStream = val;
-	    },
-	    enumerable: true,
-	    configurable: true
-	  });
-	  var FileWriteStream = WriteStream;
-	  Object.defineProperty(fs, 'FileWriteStream', {
-	    get: function () {
-	      return FileWriteStream
-	    },
-	    set: function (val) {
-	      FileWriteStream = val;
-	    },
-	    enumerable: true,
-	    configurable: true
-	  });
-
-	  function ReadStream (path, options) {
-	    if (this instanceof ReadStream)
-	      return fs$ReadStream.apply(this, arguments), this
-	    else
-	      return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
-	  }
-
-	  function ReadStream$open () {
-	    var that = this;
-	    open(that.path, that.flags, that.mode, function (err, fd) {
-	      if (err) {
-	        if (that.autoClose)
-	          that.destroy();
-
-	        that.emit('error', err);
-	      } else {
-	        that.fd = fd;
-	        that.emit('open', fd);
-	        that.read();
-	      }
-	    });
-	  }
-
-	  function WriteStream (path, options) {
-	    if (this instanceof WriteStream)
-	      return fs$WriteStream.apply(this, arguments), this
-	    else
-	      return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
-	  }
-
-	  function WriteStream$open () {
-	    var that = this;
-	    open(that.path, that.flags, that.mode, function (err, fd) {
-	      if (err) {
-	        that.destroy();
-	        that.emit('error', err);
-	      } else {
-	        that.fd = fd;
-	        that.emit('open', fd);
-	      }
-	    });
-	  }
-
-	  function createReadStream (path, options) {
-	    return new fs.ReadStream(path, options)
-	  }
-
-	  function createWriteStream (path, options) {
-	    return new fs.WriteStream(path, options)
-	  }
-
-	  var fs$open = fs.open;
-	  fs.open = open;
-	  function open (path, flags, mode, cb) {
-	    if (typeof mode === 'function')
-	      cb = mode, mode = null;
-
-	    return go$open(path, flags, mode, cb)
-
-	    function go$open (path, flags, mode, cb, startTime) {
-	      return fs$open(path, flags, mode, function (err, fd) {
-	        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-	          enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()]);
-	        else {
-	          if (typeof cb === 'function')
-	            cb.apply(this, arguments);
-	        }
-	      })
-	    }
-	  }
-
-	  return fs
-	}
-
-	function enqueue (elem) {
-	  debug('ENQUEUE', elem[0].name, elem[1]);
-	  fs[gracefulQueue].push(elem);
-	  retry();
-	}
-
-	// keep track of the timeout between retry() calls
-	var retryTimer;
-
-	// reset the startTime and lastTime to now
-	// this resets the start of the 60 second overall timeout as well as the
-	// delay between attempts so that we'll retry these jobs sooner
-	function resetQueue () {
-	  var now = Date.now();
-	  for (var i = 0; i < fs[gracefulQueue].length; ++i) {
-	    // entries that are only a length of 2 are from an older version, don't
-	    // bother modifying those since they'll be retried anyway.
-	    if (fs[gracefulQueue][i].length > 2) {
-	      fs[gracefulQueue][i][3] = now; // startTime
-	      fs[gracefulQueue][i][4] = now; // lastTime
-	    }
-	  }
-	  // call retry to make sure we're actively processing the queue
-	  retry();
-	}
-
-	function retry () {
-	  // clear the timer and remove it to help prevent unintended concurrency
-	  clearTimeout(retryTimer);
-	  retryTimer = undefined;
-
-	  if (fs[gracefulQueue].length === 0)
-	    return
-
-	  var elem = fs[gracefulQueue].shift();
-	  var fn = elem[0];
-	  var args = elem[1];
-	  // these items may be unset if they were added by an older graceful-fs
-	  var err = elem[2];
-	  var startTime = elem[3];
-	  var lastTime = elem[4];
-
-	  // if we don't have a startTime we have no way of knowing if we've waited
-	  // long enough, so go ahead and retry this item now
-	  if (startTime === undefined) {
-	    debug('RETRY', fn.name, args);
-	    fn.apply(null, args);
-	  } else if (Date.now() - startTime >= 60000) {
-	    // it's been more than 60 seconds total, bail now
-	    debug('TIMEOUT', fn.name, args);
-	    var cb = args.pop();
-	    if (typeof cb === 'function')
-	      cb.call(null, err);
-	  } else {
-	    // the amount of time between the last attempt and right now
-	    var sinceAttempt = Date.now() - lastTime;
-	    // the amount of time between when we first tried, and when we last tried
-	    // rounded up to at least 1
-	    var sinceStart = Math.max(lastTime - startTime, 1);
-	    // backoff. wait longer than the total time we've been retrying, but only
-	    // up to a maximum of 100ms
-	    var desiredDelay = Math.min(sinceStart * 1.2, 100);
-	    // it's been long enough since the last retry, do it again
-	    if (sinceAttempt >= desiredDelay) {
-	      debug('RETRY', fn.name, args);
-	      fn.apply(null, args.concat([startTime]));
-	    } else {
-	      // if we can't do this job yet, push it to the end of the queue
-	      // and let the next iteration check again
-	      fs[gracefulQueue].push(elem);
-	    }
-	  }
-
-	  // schedule our next run if one isn't already scheduled
-	  if (retryTimer === undefined) {
-	    retryTimer = setTimeout(retry, 0);
-	  }
-	}
-	return gracefulFs;
-}
-
-var hasRequiredFs;
-
-function requireFs () {
-	if (hasRequiredFs) return fs$1;
-	hasRequiredFs = 1;
-	(function (exports) {
-		// This is adapted from https://github.com/normalize/mz
-		// Copyright (c) 2014-2016 Jonathan Ong me@jongleberry.com and Contributors
-		const u = requireUniversalify().fromCallback;
-		const fs = requireGracefulFs();
-
-		const api = [
-		  'access',
-		  'appendFile',
-		  'chmod',
-		  'chown',
-		  'close',
-		  'copyFile',
-		  'cp',
-		  'fchmod',
-		  'fchown',
-		  'fdatasync',
-		  'fstat',
-		  'fsync',
-		  'ftruncate',
-		  'futimes',
-		  'glob',
-		  'lchmod',
-		  'lchown',
-		  'lutimes',
-		  'link',
-		  'lstat',
-		  'mkdir',
-		  'mkdtemp',
-		  'open',
-		  'opendir',
-		  'readdir',
-		  'readFile',
-		  'readlink',
-		  'realpath',
-		  'rename',
-		  'rm',
-		  'rmdir',
-		  'stat',
-		  'statfs',
-		  'symlink',
-		  'truncate',
-		  'unlink',
-		  'utimes',
-		  'writeFile'
-		].filter(key => {
-		  // Some commands are not available on some systems. Ex:
-		  // fs.cp was added in Node.js v16.7.0
-		  // fs.statfs was added in Node v19.6.0, v18.15.0
-		  // fs.glob was added in Node.js v22.0.0
-		  // fs.lchown is not available on at least some Linux
-		  return typeof fs[key] === 'function'
-		});
-
-		// Export cloned fs:
-		Object.assign(exports, fs);
-
-		// Universalify async methods:
-		api.forEach(method => {
-		  exports[method] = u(fs[method]);
-		});
-
-		// We differ from mz/fs in that we still ship the old, broken, fs.exists()
-		// since we are a drop-in replacement for the native module
-		exports.exists = function (filename, callback) {
-		  if (typeof callback === 'function') {
-		    return fs.exists(filename, callback)
-		  }
-		  return new Promise(resolve => {
-		    return fs.exists(filename, resolve)
-		  })
-		};
-
-		// fs.read(), fs.write(), fs.readv(), & fs.writev() need special treatment due to multiple callback args
-
-		exports.read = function (fd, buffer, offset, length, position, callback) {
-		  if (typeof callback === 'function') {
-		    return fs.read(fd, buffer, offset, length, position, callback)
-		  }
-		  return new Promise((resolve, reject) => {
-		    fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer) => {
-		      if (err) return reject(err)
-		      resolve({ bytesRead, buffer });
-		    });
-		  })
-		};
-
-		// Function signature can be
-		// fs.write(fd, buffer[, offset[, length[, position]]], callback)
-		// OR
-		// fs.write(fd, string[, position[, encoding]], callback)
-		// We need to handle both cases, so we use ...args
-		exports.write = function (fd, buffer, ...args) {
-		  if (typeof args[args.length - 1] === 'function') {
-		    return fs.write(fd, buffer, ...args)
-		  }
-
-		  return new Promise((resolve, reject) => {
-		    fs.write(fd, buffer, ...args, (err, bytesWritten, buffer) => {
-		      if (err) return reject(err)
-		      resolve({ bytesWritten, buffer });
-		    });
-		  })
-		};
-
-		// Function signature is
-		// s.readv(fd, buffers[, position], callback)
-		// We need to handle the optional arg, so we use ...args
-		exports.readv = function (fd, buffers, ...args) {
-		  if (typeof args[args.length - 1] === 'function') {
-		    return fs.readv(fd, buffers, ...args)
-		  }
-
-		  return new Promise((resolve, reject) => {
-		    fs.readv(fd, buffers, ...args, (err, bytesRead, buffers) => {
-		      if (err) return reject(err)
-		      resolve({ bytesRead, buffers });
-		    });
-		  })
-		};
-
-		// Function signature is
-		// s.writev(fd, buffers[, position], callback)
-		// We need to handle the optional arg, so we use ...args
-		exports.writev = function (fd, buffers, ...args) {
-		  if (typeof args[args.length - 1] === 'function') {
-		    return fs.writev(fd, buffers, ...args)
-		  }
-
-		  return new Promise((resolve, reject) => {
-		    fs.writev(fd, buffers, ...args, (err, bytesWritten, buffers) => {
-		      if (err) return reject(err)
-		      resolve({ bytesWritten, buffers });
-		    });
-		  })
-		};
-
-		// fs.realpath.native sometimes not available if fs is monkey-patched
-		if (typeof fs.realpath.native === 'function') {
-		  exports.realpath.native = u(fs.realpath.native);
-		} else {
-		  process.emitWarning(
-		    'fs.realpath.native is not a function. Is fs being monkey-patched?',
-		    'Warning', 'fs-extra-WARN0003'
-		  );
-		} 
-	} (fs$1));
-	return fs$1;
-}
-
-var makeDir = {};
-
-var utils$1 = {};
-
-var hasRequiredUtils$1;
-
-function requireUtils$1 () {
-	if (hasRequiredUtils$1) return utils$1;
-	hasRequiredUtils$1 = 1;
-	const path = require$$1$1;
-
-	// https://github.com/nodejs/node/issues/8987
-	// https://github.com/libuv/libuv/pull/1088
-	utils$1.checkPath = function checkPath (pth) {
-	  if (process.platform === 'win32') {
-	    const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ''));
-
-	    if (pathHasInvalidWinCharacters) {
-	      const error = new Error(`Path contains invalid characters: ${pth}`);
-	      error.code = 'EINVAL';
-	      throw error
-	    }
-	  }
-	};
-	return utils$1;
-}
-
-var hasRequiredMakeDir;
-
-function requireMakeDir () {
-	if (hasRequiredMakeDir) return makeDir;
-	hasRequiredMakeDir = 1;
-	const fs = /*@__PURE__*/ requireFs();
-	const { checkPath } = /*@__PURE__*/ requireUtils$1();
-
-	const getMode = options => {
-	  const defaults = { mode: 0o777 };
-	  if (typeof options === 'number') return options
-	  return ({ ...defaults, ...options }).mode
-	};
-
-	makeDir.makeDir = async (dir, options) => {
-	  checkPath(dir);
-
-	  return fs.mkdir(dir, {
-	    mode: getMode(options),
-	    recursive: true
-	  })
-	};
-
-	makeDir.makeDirSync = (dir, options) => {
-	  checkPath(dir);
-
-	  return fs.mkdirSync(dir, {
-	    mode: getMode(options),
-	    recursive: true
-	  })
-	};
-	return makeDir;
-}
-
-var mkdirs;
-var hasRequiredMkdirs;
-
-function requireMkdirs () {
-	if (hasRequiredMkdirs) return mkdirs;
-	hasRequiredMkdirs = 1;
-	const u = requireUniversalify().fromPromise;
-	const { makeDir: _makeDir, makeDirSync } = /*@__PURE__*/ requireMakeDir();
-	const makeDir = u(_makeDir);
-
-	mkdirs = {
-	  mkdirs: makeDir,
-	  mkdirsSync: makeDirSync,
-	  // alias
-	  mkdirp: makeDir,
-	  mkdirpSync: makeDirSync,
-	  ensureDir: makeDir,
-	  ensureDirSync: makeDirSync
-	};
-	return mkdirs;
-}
-
-var pathExists_1;
-var hasRequiredPathExists;
-
-function requirePathExists () {
-	if (hasRequiredPathExists) return pathExists_1;
-	hasRequiredPathExists = 1;
-	const u = requireUniversalify().fromPromise;
-	const fs = /*@__PURE__*/ requireFs();
-
-	function pathExists (path) {
-	  return fs.access(path).then(() => true).catch(() => false)
-	}
-
-	pathExists_1 = {
-	  pathExists: u(pathExists),
-	  pathExistsSync: fs.existsSync
-	};
-	return pathExists_1;
-}
-
-var utimes;
-var hasRequiredUtimes;
-
-function requireUtimes () {
-	if (hasRequiredUtimes) return utimes;
-	hasRequiredUtimes = 1;
-
-	const fs = /*@__PURE__*/ requireFs();
-	const u = requireUniversalify().fromPromise;
-
-	async function utimesMillis (path, atime, mtime) {
-	  const fd = await fs.open(path, 'r+');
-
-	  let error = null;
-
-	  try {
-	    await fs.futimes(fd, atime, mtime);
-	  } catch (futimesErr) {
-	    error = futimesErr;
-	  } finally {
-	    try {
-	      await fs.close(fd);
-	    } catch (closeErr) {
-	      if (!error) error = closeErr;
-	    }
-	  }
-
-	  if (error) {
-	    throw error
-	  }
-	}
-
-	function utimesMillisSync (path, atime, mtime) {
-	  const fd = fs.openSync(path, 'r+');
-
-	  let error = null;
-
-	  try {
-	    fs.futimesSync(fd, atime, mtime);
-	  } catch (futimesErr) {
-	    error = futimesErr;
-	  } finally {
-	    try {
-	      fs.closeSync(fd);
-	    } catch (closeErr) {
-	      if (!error) error = closeErr;
-	    }
-	  }
-
-	  if (error) {
-	    throw error
-	  }
-	}
-
-	utimes = {
-	  utimesMillis: u(utimesMillis),
-	  utimesMillisSync
-	};
-	return utimes;
-}
-
-var stat;
-var hasRequiredStat;
-
-function requireStat () {
-	if (hasRequiredStat) return stat;
-	hasRequiredStat = 1;
-
-	const fs = /*@__PURE__*/ requireFs();
-	const path = require$$1$1;
-	const u = requireUniversalify().fromPromise;
-
-	function getStats (src, dest, opts) {
-	  const statFunc = opts.dereference
-	    ? (file) => fs.stat(file, { bigint: true })
-	    : (file) => fs.lstat(file, { bigint: true });
-	  return Promise.all([
-	    statFunc(src),
-	    statFunc(dest).catch(err => {
-	      if (err.code === 'ENOENT') return null
-	      throw err
-	    })
-	  ]).then(([srcStat, destStat]) => ({ srcStat, destStat }))
-	}
-
-	function getStatsSync (src, dest, opts) {
-	  let destStat;
-	  const statFunc = opts.dereference
-	    ? (file) => fs.statSync(file, { bigint: true })
-	    : (file) => fs.lstatSync(file, { bigint: true });
-	  const srcStat = statFunc(src);
-	  try {
-	    destStat = statFunc(dest);
-	  } catch (err) {
-	    if (err.code === 'ENOENT') return { srcStat, destStat: null }
-	    throw err
-	  }
-	  return { srcStat, destStat }
-	}
-
-	async function checkPaths (src, dest, funcName, opts) {
-	  const { srcStat, destStat } = await getStats(src, dest, opts);
-	  if (destStat) {
-	    if (areIdentical(srcStat, destStat)) {
-	      const srcBaseName = path.basename(src);
-	      const destBaseName = path.basename(dest);
-	      if (funcName === 'move' &&
-	        srcBaseName !== destBaseName &&
-	        srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
-	        return { srcStat, destStat, isChangingCase: true }
-	      }
-	      throw new Error('Source and destination must not be the same.')
-	    }
-	    if (srcStat.isDirectory() && !destStat.isDirectory()) {
-	      throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)
-	    }
-	    if (!srcStat.isDirectory() && destStat.isDirectory()) {
-	      throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`)
-	    }
-	  }
-
-	  if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
-	    throw new Error(errMsg(src, dest, funcName))
-	  }
-
-	  return { srcStat, destStat }
-	}
-
-	function checkPathsSync (src, dest, funcName, opts) {
-	  const { srcStat, destStat } = getStatsSync(src, dest, opts);
-
-	  if (destStat) {
-	    if (areIdentical(srcStat, destStat)) {
-	      const srcBaseName = path.basename(src);
-	      const destBaseName = path.basename(dest);
-	      if (funcName === 'move' &&
-	        srcBaseName !== destBaseName &&
-	        srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
-	        return { srcStat, destStat, isChangingCase: true }
-	      }
-	      throw new Error('Source and destination must not be the same.')
-	    }
-	    if (srcStat.isDirectory() && !destStat.isDirectory()) {
-	      throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)
-	    }
-	    if (!srcStat.isDirectory() && destStat.isDirectory()) {
-	      throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`)
-	    }
-	  }
-
-	  if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
-	    throw new Error(errMsg(src, dest, funcName))
-	  }
-	  return { srcStat, destStat }
-	}
-
-	// recursively check if dest parent is a subdirectory of src.
-	// It works for all file types including symlinks since it
-	// checks the src and dest inodes. It starts from the deepest
-	// parent and stops once it reaches the src parent or the root path.
-	async function checkParentPaths (src, srcStat, dest, funcName) {
-	  const srcParent = path.resolve(path.dirname(src));
-	  const destParent = path.resolve(path.dirname(dest));
-	  if (destParent === srcParent || destParent === path.parse(destParent).root) return
-
-	  let destStat;
-	  try {
-	    destStat = await fs.stat(destParent, { bigint: true });
-	  } catch (err) {
-	    if (err.code === 'ENOENT') return
-	    throw err
-	  }
-
-	  if (areIdentical(srcStat, destStat)) {
-	    throw new Error(errMsg(src, dest, funcName))
-	  }
-
-	  return checkParentPaths(src, srcStat, destParent, funcName)
-	}
-
-	function checkParentPathsSync (src, srcStat, dest, funcName) {
-	  const srcParent = path.resolve(path.dirname(src));
-	  const destParent = path.resolve(path.dirname(dest));
-	  if (destParent === srcParent || destParent === path.parse(destParent).root) return
-	  let destStat;
-	  try {
-	    destStat = fs.statSync(destParent, { bigint: true });
-	  } catch (err) {
-	    if (err.code === 'ENOENT') return
-	    throw err
-	  }
-	  if (areIdentical(srcStat, destStat)) {
-	    throw new Error(errMsg(src, dest, funcName))
-	  }
-	  return checkParentPathsSync(src, srcStat, destParent, funcName)
-	}
-
-	function areIdentical (srcStat, destStat) {
-	  // stat.dev can be 0n on windows when node version >= 22.x.x
-	  return destStat.ino !== undefined && destStat.dev !== undefined && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev
-	}
-
-	// return true if dest is a subdir of src, otherwise false.
-	// It only checks the path strings.
-	function isSrcSubdir (src, dest) {
-	  const srcArr = path.resolve(src).split(path.sep).filter(i => i);
-	  const destArr = path.resolve(dest).split(path.sep).filter(i => i);
-	  return srcArr.every((cur, i) => destArr[i] === cur)
-	}
-
-	function errMsg (src, dest, funcName) {
-	  return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`
-	}
-
-	stat = {
-	  // checkPaths
-	  checkPaths: u(checkPaths),
-	  checkPathsSync,
-	  // checkParent
-	  checkParentPaths: u(checkParentPaths),
-	  checkParentPathsSync,
-	  // Misc
-	  isSrcSubdir,
-	  areIdentical
-	};
-	return stat;
-}
-
-var async;
-var hasRequiredAsync;
-
-function requireAsync () {
-	if (hasRequiredAsync) return async;
-	hasRequiredAsync = 1;
-
-	// https://github.com/jprichardson/node-fs-extra/issues/1056
-	// Performing parallel operations on each item of an async iterator is
-	// surprisingly hard; you need to have handlers in place to avoid getting an
-	// UnhandledPromiseRejectionWarning.
-	// NOTE: This function does not presently handle return values, only errors
-	async function asyncIteratorConcurrentProcess (iterator, fn) {
-	  const promises = [];
-	  for await (const item of iterator) {
-	    promises.push(
-	      fn(item).then(
-	        () => null,
-	        (err) => err ?? new Error('unknown error')
-	      )
-	    );
-	  }
-	  await Promise.all(
-	    promises.map((promise) =>
-	      promise.then((possibleErr) => {
-	        if (possibleErr !== null) throw possibleErr
-	      })
-	    )
-	  );
-	}
-
-	async = {
-	  asyncIteratorConcurrentProcess
-	};
-	return async;
-}
-
-var copy_1;
-var hasRequiredCopy$1;
-
-function requireCopy$1 () {
-	if (hasRequiredCopy$1) return copy_1;
-	hasRequiredCopy$1 = 1;
-
-	const fs = /*@__PURE__*/ requireFs();
-	const path = require$$1$1;
-	const { mkdirs } = /*@__PURE__*/ requireMkdirs();
-	const { pathExists } = /*@__PURE__*/ requirePathExists();
-	const { utimesMillis } = /*@__PURE__*/ requireUtimes();
-	const stat = /*@__PURE__*/ requireStat();
-	const { asyncIteratorConcurrentProcess } = /*@__PURE__*/ requireAsync();
-
-	async function copy (src, dest, opts = {}) {
-	  if (typeof opts === 'function') {
-	    opts = { filter: opts };
-	  }
-
-	  opts.clobber = 'clobber' in opts ? !!opts.clobber : true; // default to true for now
-	  opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber; // overwrite falls back to clobber
-
-	  // Warn about using preserveTimestamps on 32-bit node
-	  if (opts.preserveTimestamps && process.arch === 'ia32') {
-	    process.emitWarning(
-	      'Using the preserveTimestamps option in 32-bit node is not recommended;\n\n' +
-	      '\tsee https://github.com/jprichardson/node-fs-extra/issues/269',
-	      'Warning', 'fs-extra-WARN0001'
-	    );
-	  }
-
-	  const { srcStat, destStat } = await stat.checkPaths(src, dest, 'copy', opts);
-
-	  await stat.checkParentPaths(src, srcStat, dest, 'copy');
-
-	  const include = await runFilter(src, dest, opts);
-
-	  if (!include) return
-
-	  // check if the parent of dest exists, and create it if it doesn't exist
-	  const destParent = path.dirname(dest);
-	  const dirExists = await pathExists(destParent);
-	  if (!dirExists) {
-	    await mkdirs(destParent);
-	  }
-
-	  await getStatsAndPerformCopy(destStat, src, dest, opts);
-	}
-
-	async function runFilter (src, dest, opts) {
-	  if (!opts.filter) return true
-	  return opts.filter(src, dest)
-	}
-
-	async function getStatsAndPerformCopy (destStat, src, dest, opts) {
-	  const statFn = opts.dereference ? fs.stat : fs.lstat;
-	  const srcStat = await statFn(src);
-
-	  if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts)
-
-	  if (
-	    srcStat.isFile() ||
-	    srcStat.isCharacterDevice() ||
-	    srcStat.isBlockDevice()
-	  ) return onFile(srcStat, destStat, src, dest, opts)
-
-	  if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts)
-	  if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`)
-	  if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`)
-	  throw new Error(`Unknown file: ${src}`)
-	}
-
-	async function onFile (srcStat, destStat, src, dest, opts) {
-	  if (!destStat) return copyFile(srcStat, src, dest, opts)
-
-	  if (opts.overwrite) {
-	    await fs.unlink(dest);
-	    return copyFile(srcStat, src, dest, opts)
-	  }
-	  if (opts.errorOnExist) {
-	    throw new Error(`'${dest}' already exists`)
-	  }
-	}
-
-	async function copyFile (srcStat, src, dest, opts) {
-	  await fs.copyFile(src, dest);
-	  if (opts.preserveTimestamps) {
-	    // Make sure the file is writable before setting the timestamp
-	    // otherwise open fails with EPERM when invoked with 'r+'
-	    // (through utimes call)
-	    if (fileIsNotWritable(srcStat.mode)) {
-	      await makeFileWritable(dest, srcStat.mode);
-	    }
-
-	    // Set timestamps and mode correspondingly
-
-	    // Note that The initial srcStat.atime cannot be trusted
-	    // because it is modified by the read(2) system call
-	    // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
-	    const updatedSrcStat = await fs.stat(src);
-	    await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
-	  }
-
-	  return fs.chmod(dest, srcStat.mode)
-	}
-
-	function fileIsNotWritable (srcMode) {
-	  return (srcMode & 0o200) === 0
-	}
-
-	function makeFileWritable (dest, srcMode) {
-	  return fs.chmod(dest, srcMode | 0o200)
-	}
-
-	async function onDir (srcStat, destStat, src, dest, opts) {
-	  // the dest directory might not exist, create it
-	  if (!destStat) {
-	    await fs.mkdir(dest);
-	  }
-
-	  // iterate through the files in the current directory to copy everything
-	  await asyncIteratorConcurrentProcess(await fs.opendir(src), async (item) => {
-	    const srcItem = path.join(src, item.name);
-	    const destItem = path.join(dest, item.name);
-
-	    const include = await runFilter(srcItem, destItem, opts);
-	    // only copy the item if it matches the filter function
-	    if (include) {
-	      const { destStat } = await stat.checkPaths(srcItem, destItem, 'copy', opts);
-	      // If the item is a copyable file, `getStatsAndPerformCopy` will copy it
-	      // If the item is a directory, `getStatsAndPerformCopy` will call `onDir` recursively
-	      await getStatsAndPerformCopy(destStat, srcItem, destItem, opts);
-	    }
-	  });
-
-	  if (!destStat) {
-	    await fs.chmod(dest, srcStat.mode);
-	  }
-	}
-
-	async function onLink (destStat, src, dest, opts) {
-	  let resolvedSrc = await fs.readlink(src);
-	  if (opts.dereference) {
-	    resolvedSrc = path.resolve(process.cwd(), resolvedSrc);
-	  }
-	  if (!destStat) {
-	    return fs.symlink(resolvedSrc, dest)
-	  }
-
-	  let resolvedDest = null;
-	  try {
-	    resolvedDest = await fs.readlink(dest);
-	  } catch (e) {
-	    // dest exists and is a regular file or directory,
-	    // Windows may throw UNKNOWN error. If dest already exists,
-	    // fs throws error anyway, so no need to guard against it here.
-	    if (e.code === 'EINVAL' || e.code === 'UNKNOWN') return fs.symlink(resolvedSrc, dest)
-	    throw e
-	  }
-	  if (opts.dereference) {
-	    resolvedDest = path.resolve(process.cwd(), resolvedDest);
-	  }
-	  // If both symlinks resolve to the same target, they are still distinct symlinks
-	  // that can be copied/overwritten. Only check subdirectory constraints when
-	  // the resolved paths are different.
-	  if (resolvedSrc !== resolvedDest) {
-	    if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
-	      throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`)
-	    }
-
-	    // do not copy if src is a subdir of dest since unlinking
-	    // dest in this case would result in removing src contents
-	    // and therefore a broken symlink would be created.
-	    if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
-	      throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)
-	    }
-	  }
-
-	  // copy the link
-	  await fs.unlink(dest);
-	  return fs.symlink(resolvedSrc, dest)
-	}
-
-	copy_1 = copy;
-	return copy_1;
-}
-
-var copySync_1;
-var hasRequiredCopySync;
-
-function requireCopySync () {
-	if (hasRequiredCopySync) return copySync_1;
-	hasRequiredCopySync = 1;
-
-	const fs = requireGracefulFs();
-	const path = require$$1$1;
-	const mkdirsSync = /*@__PURE__*/ requireMkdirs().mkdirsSync;
-	const utimesMillisSync = /*@__PURE__*/ requireUtimes().utimesMillisSync;
-	const stat = /*@__PURE__*/ requireStat();
-
-	function copySync (src, dest, opts) {
-	  if (typeof opts === 'function') {
-	    opts = { filter: opts };
-	  }
-
-	  opts = opts || {};
-	  opts.clobber = 'clobber' in opts ? !!opts.clobber : true; // default to true for now
-	  opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber; // overwrite falls back to clobber
-
-	  // Warn about using preserveTimestamps on 32-bit node
-	  if (opts.preserveTimestamps && process.arch === 'ia32') {
-	    process.emitWarning(
-	      'Using the preserveTimestamps option in 32-bit node is not recommended;\n\n' +
-	      '\tsee https://github.com/jprichardson/node-fs-extra/issues/269',
-	      'Warning', 'fs-extra-WARN0002'
-	    );
-	  }
-
-	  const { srcStat, destStat } = stat.checkPathsSync(src, dest, 'copy', opts);
-	  stat.checkParentPathsSync(src, srcStat, dest, 'copy');
-	  if (opts.filter && !opts.filter(src, dest)) return
-	  const destParent = path.dirname(dest);
-	  if (!fs.existsSync(destParent)) mkdirsSync(destParent);
-	  return getStats(destStat, src, dest, opts)
-	}
-
-	function getStats (destStat, src, dest, opts) {
-	  const statSync = opts.dereference ? fs.statSync : fs.lstatSync;
-	  const srcStat = statSync(src);
-
-	  if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts)
-	  else if (srcStat.isFile() ||
-	           srcStat.isCharacterDevice() ||
-	           srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts)
-	  else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts)
-	  else if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`)
-	  else if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`)
-	  throw new Error(`Unknown file: ${src}`)
-	}
-
-	function onFile (srcStat, destStat, src, dest, opts) {
-	  if (!destStat) return copyFile(srcStat, src, dest, opts)
-	  return mayCopyFile(srcStat, src, dest, opts)
-	}
-
-	function mayCopyFile (srcStat, src, dest, opts) {
-	  if (opts.overwrite) {
-	    fs.unlinkSync(dest);
-	    return copyFile(srcStat, src, dest, opts)
-	  } else if (opts.errorOnExist) {
-	    throw new Error(`'${dest}' already exists`)
-	  }
-	}
-
-	function copyFile (srcStat, src, dest, opts) {
-	  fs.copyFileSync(src, dest);
-	  if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
-	  return setDestMode(dest, srcStat.mode)
-	}
-
-	function handleTimestamps (srcMode, src, dest) {
-	  // Make sure the file is writable before setting the timestamp
-	  // otherwise open fails with EPERM when invoked with 'r+'
-	  // (through utimes call)
-	  if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode);
-	  return setDestTimestamps(src, dest)
-	}
-
-	function fileIsNotWritable (srcMode) {
-	  return (srcMode & 0o200) === 0
-	}
-
-	function makeFileWritable (dest, srcMode) {
-	  return setDestMode(dest, srcMode | 0o200)
-	}
-
-	function setDestMode (dest, srcMode) {
-	  return fs.chmodSync(dest, srcMode)
-	}
-
-	function setDestTimestamps (src, dest) {
-	  // The initial srcStat.atime cannot be trusted
-	  // because it is modified by the read(2) system call
-	  // (See https://nodejs.org/api/fs.html#fs_stat_time_values)
-	  const updatedSrcStat = fs.statSync(src);
-	  return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime)
-	}
-
-	function onDir (srcStat, destStat, src, dest, opts) {
-	  if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts)
-	  return copyDir(src, dest, opts)
-	}
-
-	function mkDirAndCopy (srcMode, src, dest, opts) {
-	  fs.mkdirSync(dest);
-	  copyDir(src, dest, opts);
-	  return setDestMode(dest, srcMode)
-	}
-
-	function copyDir (src, dest, opts) {
-	  const dir = fs.opendirSync(src);
-
-	  try {
-	    let dirent;
-
-	    while ((dirent = dir.readSync()) !== null) {
-	      copyDirItem(dirent.name, src, dest, opts);
-	    }
-	  } finally {
-	    dir.closeSync();
-	  }
-	}
-
-	function copyDirItem (item, src, dest, opts) {
-	  const srcItem = path.join(src, item);
-	  const destItem = path.join(dest, item);
-	  if (opts.filter && !opts.filter(srcItem, destItem)) return
-	  const { destStat } = stat.checkPathsSync(srcItem, destItem, 'copy', opts);
-	  return getStats(destStat, srcItem, destItem, opts)
-	}
-
-	function onLink (destStat, src, dest, opts) {
-	  let resolvedSrc = fs.readlinkSync(src);
-	  if (opts.dereference) {
-	    resolvedSrc = path.resolve(process.cwd(), resolvedSrc);
-	  }
-
-	  if (!destStat) {
-	    return fs.symlinkSync(resolvedSrc, dest)
-	  } else {
-	    let resolvedDest;
-	    try {
-	      resolvedDest = fs.readlinkSync(dest);
-	    } catch (err) {
-	      // dest exists and is a regular file or directory,
-	      // Windows may throw UNKNOWN error. If dest already exists,
-	      // fs throws error anyway, so no need to guard against it here.
-	      if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs.symlinkSync(resolvedSrc, dest)
-	      throw err
-	    }
-	    if (opts.dereference) {
-	      resolvedDest = path.resolve(process.cwd(), resolvedDest);
-	    }
-	    // If both symlinks resolve to the same target, they are still distinct symlinks
-	    // that can be copied/overwritten. Only check subdirectory constraints when
-	    // the resolved paths are different.
-	    if (resolvedSrc !== resolvedDest) {
-	      if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
-	        throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`)
-	      }
-
-	      // prevent copy if src is a subdir of dest since unlinking
-	      // dest in this case would result in removing src contents
-	      // and therefore a broken symlink would be created.
-	      if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
-	        throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)
-	      }
-	    }
-	    return copyLink(resolvedSrc, dest)
-	  }
-	}
-
-	function copyLink (resolvedSrc, dest) {
-	  fs.unlinkSync(dest);
-	  return fs.symlinkSync(resolvedSrc, dest)
-	}
-
-	copySync_1 = copySync;
-	return copySync_1;
-}
-
-var copy;
-var hasRequiredCopy;
-
-function requireCopy () {
-	if (hasRequiredCopy) return copy;
-	hasRequiredCopy = 1;
-
-	const u = requireUniversalify().fromPromise;
-	copy = {
-	  copy: u(/*@__PURE__*/ requireCopy$1()),
-	  copySync: /*@__PURE__*/ requireCopySync()
-	};
-	return copy;
-}
-
-var remove_1;
-var hasRequiredRemove;
-
-function requireRemove () {
-	if (hasRequiredRemove) return remove_1;
-	hasRequiredRemove = 1;
-
-	const fs = requireGracefulFs();
-	const u = requireUniversalify().fromCallback;
-
-	function remove (path, callback) {
-	  fs.rm(path, { recursive: true, force: true }, callback);
-	}
-
-	function removeSync (path) {
-	  fs.rmSync(path, { recursive: true, force: true });
-	}
-
-	remove_1 = {
-	  remove: u(remove),
-	  removeSync
-	};
-	return remove_1;
-}
-
-var empty;
-var hasRequiredEmpty;
-
-function requireEmpty () {
-	if (hasRequiredEmpty) return empty;
-	hasRequiredEmpty = 1;
-
-	const u = requireUniversalify().fromPromise;
-	const fs = /*@__PURE__*/ requireFs();
-	const path = require$$1$1;
-	const mkdir = /*@__PURE__*/ requireMkdirs();
-	const remove = /*@__PURE__*/ requireRemove();
-
-	const emptyDir = u(async function emptyDir (dir) {
-	  let items;
-	  try {
-	    items = await fs.readdir(dir);
-	  } catch {
-	    return mkdir.mkdirs(dir)
-	  }
-
-	  return Promise.all(items.map(item => remove.remove(path.join(dir, item))))
-	});
-
-	function emptyDirSync (dir) {
-	  let items;
-	  try {
-	    items = fs.readdirSync(dir);
-	  } catch {
-	    return mkdir.mkdirsSync(dir)
-	  }
-
-	  items.forEach(item => {
-	    item = path.join(dir, item);
-	    remove.removeSync(item);
-	  });
-	}
-
-	empty = {
-	  emptyDirSync,
-	  emptydirSync: emptyDirSync,
-	  emptyDir,
-	  emptydir: emptyDir
-	};
-	return empty;
-}
-
-var file;
-var hasRequiredFile;
-
-function requireFile () {
-	if (hasRequiredFile) return file;
-	hasRequiredFile = 1;
-
-	const u = requireUniversalify().fromPromise;
-	const path = require$$1$1;
-	const fs = /*@__PURE__*/ requireFs();
-	const mkdir = /*@__PURE__*/ requireMkdirs();
-
-	async function createFile (file) {
-	  let stats;
-	  try {
-	    stats = await fs.stat(file);
-	  } catch { }
-	  if (stats && stats.isFile()) return
-
-	  const dir = path.dirname(file);
-
-	  let dirStats = null;
-	  try {
-	    dirStats = await fs.stat(dir);
-	  } catch (err) {
-	    // if the directory doesn't exist, make it
-	    if (err.code === 'ENOENT') {
-	      await mkdir.mkdirs(dir);
-	      await fs.writeFile(file, '');
-	      return
-	    } else {
-	      throw err
-	    }
-	  }
-
-	  if (dirStats.isDirectory()) {
-	    await fs.writeFile(file, '');
-	  } else {
-	    // parent is not a directory
-	    // This is just to cause an internal ENOTDIR error to be thrown
-	    await fs.readdir(dir);
-	  }
-	}
-
-	function createFileSync (file) {
-	  let stats;
-	  try {
-	    stats = fs.statSync(file);
-	  } catch { }
-	  if (stats && stats.isFile()) return
-
-	  const dir = path.dirname(file);
-	  try {
-	    if (!fs.statSync(dir).isDirectory()) {
-	      // parent is not a directory
-	      // This is just to cause an internal ENOTDIR error to be thrown
-	      fs.readdirSync(dir);
-	    }
-	  } catch (err) {
-	    // If the stat call above failed because the directory doesn't exist, create it
-	    if (err && err.code === 'ENOENT') mkdir.mkdirsSync(dir);
-	    else throw err
-	  }
-
-	  fs.writeFileSync(file, '');
-	}
-
-	file = {
-	  createFile: u(createFile),
-	  createFileSync
-	};
-	return file;
-}
-
-var link;
-var hasRequiredLink;
-
-function requireLink () {
-	if (hasRequiredLink) return link;
-	hasRequiredLink = 1;
-
-	const u = requireUniversalify().fromPromise;
-	const path = require$$1$1;
-	const fs = /*@__PURE__*/ requireFs();
-	const mkdir = /*@__PURE__*/ requireMkdirs();
-	const { pathExists } = /*@__PURE__*/ requirePathExists();
-	const { areIdentical } = /*@__PURE__*/ requireStat();
-
-	async function createLink (srcpath, dstpath) {
-	  let dstStat;
-	  try {
-	    dstStat = await fs.lstat(dstpath, { bigint: true });
-	  } catch {
-	    // ignore error
-	  }
-
-	  let srcStat;
-	  try {
-	    srcStat = await fs.lstat(srcpath, { bigint: true });
-	  } catch (err) {
-	    err.message = err.message.replace('lstat', 'ensureLink');
-	    throw err
-	  }
-
-	  if (dstStat && areIdentical(srcStat, dstStat)) return
-
-	  const dir = path.dirname(dstpath);
-
-	  const dirExists = await pathExists(dir);
-
-	  if (!dirExists) {
-	    await mkdir.mkdirs(dir);
-	  }
-
-	  await fs.link(srcpath, dstpath);
-	}
-
-	function createLinkSync (srcpath, dstpath) {
-	  let dstStat;
-	  try {
-	    dstStat = fs.lstatSync(dstpath, { bigint: true });
-	  } catch {}
-
-	  try {
-	    const srcStat = fs.lstatSync(srcpath, { bigint: true });
-	    if (dstStat && areIdentical(srcStat, dstStat)) return
-	  } catch (err) {
-	    err.message = err.message.replace('lstat', 'ensureLink');
-	    throw err
-	  }
-
-	  const dir = path.dirname(dstpath);
-	  const dirExists = fs.existsSync(dir);
-	  if (dirExists) return fs.linkSync(srcpath, dstpath)
-	  mkdir.mkdirsSync(dir);
-
-	  return fs.linkSync(srcpath, dstpath)
-	}
-
-	link = {
-	  createLink: u(createLink),
-	  createLinkSync
-	};
-	return link;
-}
-
-var symlinkPaths_1;
-var hasRequiredSymlinkPaths;
-
-function requireSymlinkPaths () {
-	if (hasRequiredSymlinkPaths) return symlinkPaths_1;
-	hasRequiredSymlinkPaths = 1;
-
-	const path = require$$1$1;
-	const fs = /*@__PURE__*/ requireFs();
-	const { pathExists } = /*@__PURE__*/ requirePathExists();
-
-	const u = requireUniversalify().fromPromise;
-
-	/**
-	 * Function that returns two types of paths, one relative to symlink, and one
-	 * relative to the current working directory. Checks if path is absolute or
-	 * relative. If the path is relative, this function checks if the path is
-	 * relative to symlink or relative to current working directory. This is an
-	 * initiative to find a smarter `srcpath` to supply when building symlinks.
-	 * This allows you to determine which path to use out of one of three possible
-	 * types of source paths. The first is an absolute path. This is detected by
-	 * `path.isAbsolute()`. When an absolute path is provided, it is checked to
-	 * see if it exists. If it does it's used, if not an error is returned
-	 * (callback)/ thrown (sync). The other two options for `srcpath` are a
-	 * relative url. By default Node's `fs.symlink` works by creating a symlink
-	 * using `dstpath` and expects the `srcpath` to be relative to the newly
-	 * created symlink. If you provide a `srcpath` that does not exist on the file
-	 * system it results in a broken symlink. To minimize this, the function
-	 * checks to see if the 'relative to symlink' source file exists, and if it
-	 * does it will use it. If it does not, it checks if there's a file that
-	 * exists that is relative to the current working directory, if does its used.
-	 * This preserves the expectations of the original fs.symlink spec and adds
-	 * the ability to pass in `relative to current working direcotry` paths.
-	 */
-
-	async function symlinkPaths (srcpath, dstpath) {
-	  if (path.isAbsolute(srcpath)) {
-	    try {
-	      await fs.lstat(srcpath);
-	    } catch (err) {
-	      err.message = err.message.replace('lstat', 'ensureSymlink');
-	      throw err
-	    }
-
-	    return {
-	      toCwd: srcpath,
-	      toDst: srcpath
-	    }
-	  }
-
-	  const dstdir = path.dirname(dstpath);
-	  const relativeToDst = path.join(dstdir, srcpath);
-
-	  const exists = await pathExists(relativeToDst);
-	  if (exists) {
-	    return {
-	      toCwd: relativeToDst,
-	      toDst: srcpath
-	    }
-	  }
-
-	  try {
-	    await fs.lstat(srcpath);
-	  } catch (err) {
-	    err.message = err.message.replace('lstat', 'ensureSymlink');
-	    throw err
-	  }
-
-	  return {
-	    toCwd: srcpath,
-	    toDst: path.relative(dstdir, srcpath)
-	  }
-	}
-
-	function symlinkPathsSync (srcpath, dstpath) {
-	  if (path.isAbsolute(srcpath)) {
-	    const exists = fs.existsSync(srcpath);
-	    if (!exists) throw new Error('absolute srcpath does not exist')
-	    return {
-	      toCwd: srcpath,
-	      toDst: srcpath
-	    }
-	  }
-
-	  const dstdir = path.dirname(dstpath);
-	  const relativeToDst = path.join(dstdir, srcpath);
-	  const exists = fs.existsSync(relativeToDst);
-	  if (exists) {
-	    return {
-	      toCwd: relativeToDst,
-	      toDst: srcpath
-	    }
-	  }
-
-	  const srcExists = fs.existsSync(srcpath);
-	  if (!srcExists) throw new Error('relative srcpath does not exist')
-	  return {
-	    toCwd: srcpath,
-	    toDst: path.relative(dstdir, srcpath)
-	  }
-	}
-
-	symlinkPaths_1 = {
-	  symlinkPaths: u(symlinkPaths),
-	  symlinkPathsSync
-	};
-	return symlinkPaths_1;
-}
-
-var symlinkType_1;
-var hasRequiredSymlinkType;
-
-function requireSymlinkType () {
-	if (hasRequiredSymlinkType) return symlinkType_1;
-	hasRequiredSymlinkType = 1;
-
-	const fs = /*@__PURE__*/ requireFs();
-	const u = requireUniversalify().fromPromise;
-
-	async function symlinkType (srcpath, type) {
-	  if (type) return type
-
-	  let stats;
-	  try {
-	    stats = await fs.lstat(srcpath);
-	  } catch {
-	    return 'file'
-	  }
-
-	  return (stats && stats.isDirectory()) ? 'dir' : 'file'
-	}
-
-	function symlinkTypeSync (srcpath, type) {
-	  if (type) return type
-
-	  let stats;
-	  try {
-	    stats = fs.lstatSync(srcpath);
-	  } catch {
-	    return 'file'
-	  }
-	  return (stats && stats.isDirectory()) ? 'dir' : 'file'
-	}
-
-	symlinkType_1 = {
-	  symlinkType: u(symlinkType),
-	  symlinkTypeSync
-	};
-	return symlinkType_1;
-}
-
-var symlink;
-var hasRequiredSymlink;
-
-function requireSymlink () {
-	if (hasRequiredSymlink) return symlink;
-	hasRequiredSymlink = 1;
-
-	const u = requireUniversalify().fromPromise;
-	const path = require$$1$1;
-	const fs = /*@__PURE__*/ requireFs();
-
-	const { mkdirs, mkdirsSync } = /*@__PURE__*/ requireMkdirs();
-
-	const { symlinkPaths, symlinkPathsSync } = /*@__PURE__*/ requireSymlinkPaths();
-	const { symlinkType, symlinkTypeSync } = /*@__PURE__*/ requireSymlinkType();
-
-	const { pathExists } = /*@__PURE__*/ requirePathExists();
-
-	const { areIdentical } = /*@__PURE__*/ requireStat();
-
-	async function createSymlink (srcpath, dstpath, type) {
-	  let stats;
-	  try {
-	    stats = await fs.lstat(dstpath);
-	  } catch { }
-
-	  if (stats && stats.isSymbolicLink()) {
-	    // When srcpath is relative, resolve it relative to dstpath's directory
-	    // (standard symlink behavior) or fall back to cwd if that doesn't exist
-	    let srcStat;
-	    if (path.isAbsolute(srcpath)) {
-	      srcStat = await fs.stat(srcpath, { bigint: true });
-	    } else {
-	      const dstdir = path.dirname(dstpath);
-	      const relativeToDst = path.join(dstdir, srcpath);
-	      try {
-	        srcStat = await fs.stat(relativeToDst, { bigint: true });
-	      } catch {
-	        srcStat = await fs.stat(srcpath, { bigint: true });
-	      }
-	    }
-
-	    const dstStat = await fs.stat(dstpath, { bigint: true });
-	    if (areIdentical(srcStat, dstStat)) return
-	  }
-
-	  const relative = await symlinkPaths(srcpath, dstpath);
-	  srcpath = relative.toDst;
-	  const toType = await symlinkType(relative.toCwd, type);
-	  const dir = path.dirname(dstpath);
-
-	  if (!(await pathExists(dir))) {
-	    await mkdirs(dir);
-	  }
-
-	  return fs.symlink(srcpath, dstpath, toType)
-	}
-
-	function createSymlinkSync (srcpath, dstpath, type) {
-	  let stats;
-	  try {
-	    stats = fs.lstatSync(dstpath);
-	  } catch { }
-	  if (stats && stats.isSymbolicLink()) {
-	    // When srcpath is relative, resolve it relative to dstpath's directory
-	    // (standard symlink behavior) or fall back to cwd if that doesn't exist
-	    let srcStat;
-	    if (path.isAbsolute(srcpath)) {
-	      srcStat = fs.statSync(srcpath, { bigint: true });
-	    } else {
-	      const dstdir = path.dirname(dstpath);
-	      const relativeToDst = path.join(dstdir, srcpath);
-	      try {
-	        srcStat = fs.statSync(relativeToDst, { bigint: true });
-	      } catch {
-	        srcStat = fs.statSync(srcpath, { bigint: true });
-	      }
-	    }
-
-	    const dstStat = fs.statSync(dstpath, { bigint: true });
-	    if (areIdentical(srcStat, dstStat)) return
-	  }
-
-	  const relative = symlinkPathsSync(srcpath, dstpath);
-	  srcpath = relative.toDst;
-	  type = symlinkTypeSync(relative.toCwd, type);
-	  const dir = path.dirname(dstpath);
-	  const exists = fs.existsSync(dir);
-	  if (exists) return fs.symlinkSync(srcpath, dstpath, type)
-	  mkdirsSync(dir);
-	  return fs.symlinkSync(srcpath, dstpath, type)
-	}
-
-	symlink = {
-	  createSymlink: u(createSymlink),
-	  createSymlinkSync
-	};
-	return symlink;
-}
-
-var ensure;
-var hasRequiredEnsure;
-
-function requireEnsure () {
-	if (hasRequiredEnsure) return ensure;
-	hasRequiredEnsure = 1;
-
-	const { createFile, createFileSync } = /*@__PURE__*/ requireFile();
-	const { createLink, createLinkSync } = /*@__PURE__*/ requireLink();
-	const { createSymlink, createSymlinkSync } = /*@__PURE__*/ requireSymlink();
-
-	ensure = {
-	  // file
-	  createFile,
-	  createFileSync,
-	  ensureFile: createFile,
-	  ensureFileSync: createFileSync,
-	  // link
-	  createLink,
-	  createLinkSync,
-	  ensureLink: createLink,
-	  ensureLinkSync: createLinkSync,
-	  // symlink
-	  createSymlink,
-	  createSymlinkSync,
-	  ensureSymlink: createSymlink,
-	  ensureSymlinkSync: createSymlinkSync
-	};
-	return ensure;
-}
-
-var utils;
-var hasRequiredUtils;
-
-function requireUtils () {
-	if (hasRequiredUtils) return utils;
-	hasRequiredUtils = 1;
-	function stringify (obj, { EOL = '\n', finalEOL = true, replacer = null, spaces } = {}) {
-	  const EOF = finalEOL ? EOL : '';
-	  const str = JSON.stringify(obj, replacer, spaces);
-
-	  if (str === undefined) {
-	    throw new TypeError(`Converting ${typeof obj} value to JSON is not supported`)
-	  }
-
-	  return str.replace(/\n/g, EOL) + EOF
-	}
-
-	function stripBom (content) {
-	  // we do this because JSON.parse would convert it to a utf8 string if encoding wasn't specified
-	  if (Buffer.isBuffer(content)) content = content.toString('utf8');
-	  return content.replace(/^\uFEFF/, '')
-	}
-
-	utils = { stringify, stripBom };
-	return utils;
-}
-
-var jsonfile$1;
-var hasRequiredJsonfile$1;
-
-function requireJsonfile$1 () {
-	if (hasRequiredJsonfile$1) return jsonfile$1;
-	hasRequiredJsonfile$1 = 1;
-	let _fs;
-	try {
-	  _fs = requireGracefulFs();
-	} catch (_) {
-	  _fs = require$$0$2;
-	}
-	const universalify = requireUniversalify();
-	const { stringify, stripBom } = requireUtils();
-
-	async function _readFile (file, options = {}) {
-	  if (typeof options === 'string') {
-	    options = { encoding: options };
-	  }
-
-	  const fs = options.fs || _fs;
-
-	  const shouldThrow = 'throws' in options ? options.throws : true;
-
-	  let data = await universalify.fromCallback(fs.readFile)(file, options);
-
-	  data = stripBom(data);
-
-	  let obj;
-	  try {
-	    obj = JSON.parse(data, options ? options.reviver : null);
-	  } catch (err) {
-	    if (shouldThrow) {
-	      err.message = `${file}: ${err.message}`;
-	      throw err
-	    } else {
-	      return null
-	    }
-	  }
-
-	  return obj
-	}
-
-	const readFile = universalify.fromPromise(_readFile);
-
-	function readFileSync (file, options = {}) {
-	  if (typeof options === 'string') {
-	    options = { encoding: options };
-	  }
-
-	  const fs = options.fs || _fs;
-
-	  const shouldThrow = 'throws' in options ? options.throws : true;
-
-	  try {
-	    let content = fs.readFileSync(file, options);
-	    content = stripBom(content);
-	    return JSON.parse(content, options.reviver)
-	  } catch (err) {
-	    if (shouldThrow) {
-	      err.message = `${file}: ${err.message}`;
-	      throw err
-	    } else {
-	      return null
-	    }
-	  }
-	}
-
-	async function _writeFile (file, obj, options = {}) {
-	  const fs = options.fs || _fs;
-
-	  const str = stringify(obj, options);
-
-	  await universalify.fromCallback(fs.writeFile)(file, str, options);
-	}
-
-	const writeFile = universalify.fromPromise(_writeFile);
-
-	function writeFileSync (file, obj, options = {}) {
-	  const fs = options.fs || _fs;
-
-	  const str = stringify(obj, options);
-	  // not sure if fs.writeFileSync returns anything, but just in case
-	  return fs.writeFileSync(file, str, options)
-	}
-
-	// NOTE: do not change this export format; required for ESM compat
-	// see https://github.com/jprichardson/node-jsonfile/pull/162 for details
-	jsonfile$1 = {
-	  readFile,
-	  readFileSync,
-	  writeFile,
-	  writeFileSync
-	};
-	return jsonfile$1;
-}
-
-var jsonfile;
-var hasRequiredJsonfile;
-
-function requireJsonfile () {
-	if (hasRequiredJsonfile) return jsonfile;
-	hasRequiredJsonfile = 1;
-
-	const jsonFile = requireJsonfile$1();
-
-	jsonfile = {
-	  // jsonfile exports
-	  readJson: jsonFile.readFile,
-	  readJsonSync: jsonFile.readFileSync,
-	  writeJson: jsonFile.writeFile,
-	  writeJsonSync: jsonFile.writeFileSync
-	};
-	return jsonfile;
-}
-
-var outputFile_1;
-var hasRequiredOutputFile;
-
-function requireOutputFile () {
-	if (hasRequiredOutputFile) return outputFile_1;
-	hasRequiredOutputFile = 1;
-
-	const u = requireUniversalify().fromPromise;
-	const fs = /*@__PURE__*/ requireFs();
-	const path = require$$1$1;
-	const mkdir = /*@__PURE__*/ requireMkdirs();
-	const pathExists = /*@__PURE__*/ requirePathExists().pathExists;
-
-	async function outputFile (file, data, encoding = 'utf-8') {
-	  const dir = path.dirname(file);
-
-	  if (!(await pathExists(dir))) {
-	    await mkdir.mkdirs(dir);
-	  }
-
-	  return fs.writeFile(file, data, encoding)
-	}
-
-	function outputFileSync (file, ...args) {
-	  const dir = path.dirname(file);
-	  if (!fs.existsSync(dir)) {
-	    mkdir.mkdirsSync(dir);
-	  }
-
-	  fs.writeFileSync(file, ...args);
-	}
-
-	outputFile_1 = {
-	  outputFile: u(outputFile),
-	  outputFileSync
-	};
-	return outputFile_1;
-}
-
-var outputJson_1;
-var hasRequiredOutputJson;
-
-function requireOutputJson () {
-	if (hasRequiredOutputJson) return outputJson_1;
-	hasRequiredOutputJson = 1;
-
-	const { stringify } = requireUtils();
-	const { outputFile } = /*@__PURE__*/ requireOutputFile();
-
-	async function outputJson (file, data, options = {}) {
-	  const str = stringify(data, options);
-
-	  await outputFile(file, str, options);
-	}
-
-	outputJson_1 = outputJson;
-	return outputJson_1;
-}
-
-var outputJsonSync_1;
-var hasRequiredOutputJsonSync;
-
-function requireOutputJsonSync () {
-	if (hasRequiredOutputJsonSync) return outputJsonSync_1;
-	hasRequiredOutputJsonSync = 1;
-
-	const { stringify } = requireUtils();
-	const { outputFileSync } = /*@__PURE__*/ requireOutputFile();
-
-	function outputJsonSync (file, data, options) {
-	  const str = stringify(data, options);
-
-	  outputFileSync(file, str, options);
-	}
-
-	outputJsonSync_1 = outputJsonSync;
-	return outputJsonSync_1;
-}
-
-var json;
-var hasRequiredJson;
-
-function requireJson () {
-	if (hasRequiredJson) return json;
-	hasRequiredJson = 1;
-
-	const u = requireUniversalify().fromPromise;
-	const jsonFile = /*@__PURE__*/ requireJsonfile();
-
-	jsonFile.outputJson = u(/*@__PURE__*/ requireOutputJson());
-	jsonFile.outputJsonSync = /*@__PURE__*/ requireOutputJsonSync();
-	// aliases
-	jsonFile.outputJSON = jsonFile.outputJson;
-	jsonFile.outputJSONSync = jsonFile.outputJsonSync;
-	jsonFile.writeJSON = jsonFile.writeJson;
-	jsonFile.writeJSONSync = jsonFile.writeJsonSync;
-	jsonFile.readJSON = jsonFile.readJson;
-	jsonFile.readJSONSync = jsonFile.readJsonSync;
-
-	json = jsonFile;
-	return json;
-}
-
-var move_1;
-var hasRequiredMove$1;
-
-function requireMove$1 () {
-	if (hasRequiredMove$1) return move_1;
-	hasRequiredMove$1 = 1;
-
-	const fs = /*@__PURE__*/ requireFs();
-	const path = require$$1$1;
-	const { copy } = /*@__PURE__*/ requireCopy();
-	const { remove } = /*@__PURE__*/ requireRemove();
-	const { mkdirp } = /*@__PURE__*/ requireMkdirs();
-	const { pathExists } = /*@__PURE__*/ requirePathExists();
-	const stat = /*@__PURE__*/ requireStat();
-
-	async function move (src, dest, opts = {}) {
-	  const overwrite = opts.overwrite || opts.clobber || false;
-
-	  const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, 'move', opts);
-
-	  await stat.checkParentPaths(src, srcStat, dest, 'move');
-
-	  // If the parent of dest is not root, make sure it exists before proceeding
-	  const destParent = path.dirname(dest);
-	  const parsedParentPath = path.parse(destParent);
-	  if (parsedParentPath.root !== destParent) {
-	    await mkdirp(destParent);
-	  }
-
-	  return doRename(src, dest, overwrite, isChangingCase)
-	}
-
-	async function doRename (src, dest, overwrite, isChangingCase) {
-	  if (!isChangingCase) {
-	    if (overwrite) {
-	      await remove(dest);
-	    } else if (await pathExists(dest)) {
-	      throw new Error('dest already exists.')
-	    }
-	  }
-
-	  try {
-	    // Try w/ rename first, and try copy + remove if EXDEV
-	    await fs.rename(src, dest);
-	  } catch (err) {
-	    if (err.code !== 'EXDEV') {
-	      throw err
-	    }
-	    await moveAcrossDevice(src, dest, overwrite);
-	  }
-	}
-
-	async function moveAcrossDevice (src, dest, overwrite) {
-	  const opts = {
-	    overwrite,
-	    errorOnExist: true,
-	    preserveTimestamps: true
-	  };
-
-	  await copy(src, dest, opts);
-	  return remove(src)
-	}
-
-	move_1 = move;
-	return move_1;
-}
-
-var moveSync_1;
-var hasRequiredMoveSync;
-
-function requireMoveSync () {
-	if (hasRequiredMoveSync) return moveSync_1;
-	hasRequiredMoveSync = 1;
-
-	const fs = requireGracefulFs();
-	const path = require$$1$1;
-	const copySync = /*@__PURE__*/ requireCopy().copySync;
-	const removeSync = /*@__PURE__*/ requireRemove().removeSync;
-	const mkdirpSync = /*@__PURE__*/ requireMkdirs().mkdirpSync;
-	const stat = /*@__PURE__*/ requireStat();
-
-	function moveSync (src, dest, opts) {
-	  opts = opts || {};
-	  const overwrite = opts.overwrite || opts.clobber || false;
-
-	  const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, 'move', opts);
-	  stat.checkParentPathsSync(src, srcStat, dest, 'move');
-	  if (!isParentRoot(dest)) mkdirpSync(path.dirname(dest));
-	  return doRename(src, dest, overwrite, isChangingCase)
-	}
-
-	function isParentRoot (dest) {
-	  const parent = path.dirname(dest);
-	  const parsedPath = path.parse(parent);
-	  return parsedPath.root === parent
-	}
-
-	function doRename (src, dest, overwrite, isChangingCase) {
-	  if (isChangingCase) return rename(src, dest, overwrite)
-	  if (overwrite) {
-	    removeSync(dest);
-	    return rename(src, dest, overwrite)
-	  }
-	  if (fs.existsSync(dest)) throw new Error('dest already exists.')
-	  return rename(src, dest, overwrite)
-	}
-
-	function rename (src, dest, overwrite) {
-	  try {
-	    fs.renameSync(src, dest);
-	  } catch (err) {
-	    if (err.code !== 'EXDEV') throw err
-	    return moveAcrossDevice(src, dest, overwrite)
-	  }
-	}
-
-	function moveAcrossDevice (src, dest, overwrite) {
-	  const opts = {
-	    overwrite,
-	    errorOnExist: true,
-	    preserveTimestamps: true
-	  };
-	  copySync(src, dest, opts);
-	  return removeSync(src)
-	}
-
-	moveSync_1 = moveSync;
-	return moveSync_1;
-}
-
-var move;
-var hasRequiredMove;
-
-function requireMove () {
-	if (hasRequiredMove) return move;
-	hasRequiredMove = 1;
-
-	const u = requireUniversalify().fromPromise;
-	move = {
-	  move: u(/*@__PURE__*/ requireMove$1()),
-	  moveSync: /*@__PURE__*/ requireMoveSync()
-	};
-	return move;
-}
-
-var lib;
-var hasRequiredLib;
-
-function requireLib () {
-	if (hasRequiredLib) return lib;
-	hasRequiredLib = 1;
-
-	lib = {
-	  // Export promiseified graceful-fs:
-	  .../*@__PURE__*/ requireFs(),
-	  // Export extra methods:
-	  .../*@__PURE__*/ requireCopy(),
-	  .../*@__PURE__*/ requireEmpty(),
-	  .../*@__PURE__*/ requireEnsure(),
-	  .../*@__PURE__*/ requireJson(),
-	  .../*@__PURE__*/ requireMkdirs(),
-	  .../*@__PURE__*/ requireMove(),
-	  .../*@__PURE__*/ requireOutputFile(),
-	  .../*@__PURE__*/ requirePathExists(),
-	  .../*@__PURE__*/ requireRemove()
-	};
-	return lib;
-}
-
-var libExports = /*@__PURE__*/ requireLib();
-var fs = /*@__PURE__*/index.getDefaultExportFromCjs(libExports);
-
-class AuthSessionError extends Error {
-    code;
-    constructor(message, code) {
-        super(message);
-        this.code = code;
-        this.name = 'AuthSessionError';
-    }
-}
-const AUTH_CACHE_VERSION = 1;
-const paths = index.envPaths('hb-sdk', { suffix: '' });
-function getAuthCacheFilePath(options = {}) {
-    return options.cacheFile ?? path.join(paths.cache, 'auth.json');
-}
-function createHeyboxAuthSession(payload, options = {}) {
-    return {
-        heyboxId: payload.heyboxId,
-        pkey: payload.pkey,
-        xXhhHeyboxId: payload.xXhhHeyboxId,
-        cookieHeader: createHeyboxCookieHeader(payload),
-        loginBaseUrl: resolveHeyboxLoginBaseUrl(options),
-        loggedInAt: (options.now?.() ?? new Date()).toISOString(),
-    };
-}
-async function readAuthCache(options = {}) {
-    const cacheFile = getAuthCacheFilePath(options);
-    if (!(await fs.pathExists(cacheFile))) {
-        return createEmptyAuthCache(options);
-    }
-    const parsed = (await fs.readJson(cacheFile));
-    if (parsed.version !== AUTH_CACHE_VERSION) {
-        throw new Error(`hb-sdk 登录缓存格式不受支持: version=${String(parsed.version)}`);
-    }
-    return {
-        version: AUTH_CACHE_VERSION,
-        updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : new Date(0).toISOString(),
-        ...(isHeyboxAuthSession(parsed.heybox) ? { heybox: normalizeHeyboxAuthSession(parsed.heybox) } : {}),
-    };
-}
-async function readHeyboxAuthSession(options = {}) {
-    const cache = await readAuthCache(options);
-    return cache.heybox;
-}
-async function requireHeyboxAuthSession(options = {}) {
-    const session = await readHeyboxAuthSession(options);
-    if (!session) {
-        throw new AuthSessionError('未发现 Heybox 登录态，请先运行 hb-sdk login', 'AUTH_SESSION_MISSING');
-    }
-    const expectedLoginBaseUrl = resolveHeyboxLoginBaseUrl(options);
-    if (session.loginBaseUrl !== expectedLoginBaseUrl) {
-        throw new Error([
-            'Heybox CLI 登录环境不匹配。',
-            `当前登录态: ${session.loginBaseUrl}`,
-            `当前命令期望: ${expectedLoginBaseUrl}`,
-            `请运行: hb-sdk login --login-base-url ${expectedLoginBaseUrl}`,
-        ].join('\n'));
-    }
-    return session;
-}
-async function writeHeyboxAuthSession(session, options = {}) {
-    const cache = {
-        version: AUTH_CACHE_VERSION,
-        updatedAt: (options.now?.() ?? new Date()).toISOString(),
-        heybox: session,
-    };
-    return writeAuthCache(cache, options);
-}
-async function clearHeyboxAuthSession(options = {}) {
-    await fs.remove(getAuthCacheFilePath(options));
-}
-function createSelectedDeveloperEntitySnapshot(input, options = {}) {
-    return {
-        entityId: input.entityId,
-        entityName: input.entityName,
-        ...(input.ownerHeyboxId === undefined ? {} : { ownerHeyboxId: input.ownerHeyboxId }),
-        selectedAt: (options.now?.() ?? new Date()).toISOString(),
-    };
-}
-async function setSelectedDeveloperEntitySnapshot(input, options = {}) {
-    const cache = await readAuthCache(options);
-    if (!cache.heybox) {
-        throw new AuthSessionError('未发现 Heybox 登录态，请先运行 hb-sdk login', 'AUTH_SESSION_MISSING');
-    }
-    const selectedEntity = createSelectedDeveloperEntitySnapshot(input, options);
-    return writeAuthCache({
-        version: AUTH_CACHE_VERSION,
-        updatedAt: (options.now?.() ?? new Date()).toISOString(),
-        heybox: {
-            ...cache.heybox,
-            selectedEntity,
-        },
-    }, options);
-}
-async function readRedactedHeyboxAuthStatus(options = {}) {
-    const cacheFile = getAuthCacheFilePath(options);
-    const session = await readHeyboxAuthSession(options);
-    if (!session) {
-        return {
-            cacheFile,
-            loggedIn: false,
-        };
-    }
-    return {
-        cacheFile,
-        heyboxId: session.heyboxId,
-        loginBaseUrl: session.loginBaseUrl,
-        loggedIn: true,
-        loggedInAt: session.loggedInAt,
-        ...(session.selectedEntity ? { selectedEntity: session.selectedEntity } : {}),
-    };
-}
-async function writeAuthCache(cache, options = {}) {
-    const cacheFile = getAuthCacheFilePath(options);
-    await fs.ensureDir(path.dirname(cacheFile));
-    await fs.writeJson(cacheFile, cache, { spaces: 2 });
-    await fs.chmod(cacheFile, 0o600);
-    return cache;
-}
-function createEmptyAuthCache(options = {}) {
-    return {
-        version: AUTH_CACHE_VERSION,
-        updatedAt: (options.now?.() ?? new Date(0)).toISOString(),
-    };
-}
-function createHeyboxCookieHeader(payload) {
-    return [
-        createCookie('heybox_id', payload.heyboxId),
-        createCookie('user_heybox_id', payload.heyboxId),
-        createCookie('pkey', payload.pkey),
-        createCookie('user_pkey', payload.pkey),
-        createCookie('x_xhh_heyboxid', payload.xXhhHeyboxId),
-    ].join('; ');
-}
-function createCookie(name, value) {
-    return `${name}=${value}`;
-}
-function isHeyboxAuthSession(value) {
-    if (!isRecord(value)) {
-        return false;
-    }
-    return (typeof value.heyboxId === 'string' &&
-        typeof value.pkey === 'string' &&
-        typeof value.xXhhHeyboxId === 'string' &&
-        typeof value.cookieHeader === 'string' &&
-        (value.loginBaseUrl === undefined || typeof value.loginBaseUrl === 'string') &&
-        typeof value.loggedInAt === 'string');
-}
-function normalizeHeyboxAuthSession(session) {
-    const normalized = {
-        heyboxId: session.heyboxId,
-        pkey: session.pkey,
-        xXhhHeyboxId: session.xXhhHeyboxId,
-        cookieHeader: session.cookieHeader,
-        loggedInAt: session.loggedInAt,
-        loginBaseUrl: resolveHeyboxLoginBaseUrl({ loginBaseUrl: session.loginBaseUrl }),
-    };
-    const selectedEntity = normalizeSelectedDeveloperEntitySnapshot(session.selectedEntity);
-    if (selectedEntity) {
-        normalized.selectedEntity = selectedEntity;
-    }
-    return normalized;
-}
-function normalizeSelectedDeveloperEntitySnapshot(value) {
-    if (!isRecord(value)) {
-        return undefined;
-    }
-    if (typeof value.entityId !== 'number' || !Number.isFinite(value.entityId)) {
-        return undefined;
-    }
-    if (typeof value.entityName !== 'string' || value.entityName.length === 0) {
-        return undefined;
-    }
-    if (value.ownerHeyboxId !== undefined && (typeof value.ownerHeyboxId !== 'number' || !Number.isFinite(value.ownerHeyboxId))) {
-        return undefined;
-    }
-    if (typeof value.selectedAt !== 'string' || value.selectedAt.length === 0) {
-        return undefined;
-    }
-    return {
-        entityId: value.entityId,
-        entityName: value.entityName,
-        ...(value.ownerHeyboxId === undefined ? {} : { ownerHeyboxId: value.ownerHeyboxId }),
-        selectedAt: value.selectedAt,
-    };
-}
-function isRecord(value) {
-    return Object.prototype.toString.call(value) === '[object Object]';
-}
-
-exports.HEYBOX_API_BASE_URL = HEYBOX_API_BASE_URL;
-exports.clearHeyboxAuthSession = clearHeyboxAuthSession;
-exports.createHeyboxApiUrl = createHeyboxApiUrl;
-exports.createHeyboxAuthSession = createHeyboxAuthSession;
-exports.createHeyboxOpenPlatformRequestContext = createHeyboxOpenPlatformRequestContext;
-exports.getAuthCacheFilePath = getAuthCacheFilePath;
-exports.readHeyboxApiEnvelope = readHeyboxApiEnvelope;
-exports.readHeyboxAuthSession = readHeyboxAuthSession;
-exports.readRedactedHeyboxAuthStatus = readRedactedHeyboxAuthStatus;
-exports.requireHeyboxAuthSession = requireHeyboxAuthSession;
-exports.resolveHeyboxApiBaseUrl = resolveHeyboxApiBaseUrl;
-exports.resolveHeyboxLoginBaseUrl = resolveHeyboxLoginBaseUrl;
-exports.resolveHeyboxOpenPlatformBaseUrl = resolveHeyboxOpenPlatformBaseUrl;
-exports.setSelectedDeveloperEntitySnapshot = setSelectedDeveloperEntitySnapshot;
-exports.writeHeyboxAuthSession = writeHeyboxAuthSession;