@visulima/fs 2.3.5 → 2.3.6

package/dist/packem_shared/WalkError-B7_AVs7d.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class WalkError extends Error {
+  static {
+    __name(this, "WalkError");
+  }
+  /** File path of the root that's being walked. */
+  root;
+  /** Constructs a new instance. */
+  constructor(cause, root) {
+    super(`${cause instanceof Error ? cause.message : cause} for path "${root}"`);
+    this.cause = cause;
+    this.root = root;
+  }
+  // eslint-disable-next-line class-methods-use-this
+  get name() {
+    return "WalkError";
+  }
+  // eslint-disable-next-line class-methods-use-this,@typescript-eslint/explicit-module-boundary-types
+  set name(_name) {
+    throw new Error("Cannot overwrite name of WalkError");
+  }
+}
+
+module.exports = WalkError;

package/dist/packem_shared/WalkError-H9EuRv7O.mjs

@@ -0,0 +1,25 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class WalkError extends Error {
+  static {
+    __name(this, "WalkError");
+  }
+  /** File path of the root that's being walked. */
+  root;
+  /** Constructs a new instance. */
+  constructor(cause, root) {
+    super(`${cause instanceof Error ? cause.message : cause} for path "${root}"`);
+    this.cause = cause;
+    this.root = root;
+  }
+  // eslint-disable-next-line class-methods-use-this
+  get name() {
+    return "WalkError";
+  }
+  // eslint-disable-next-line class-methods-use-this,@typescript-eslint/explicit-module-boundary-types
+  set name(_name) {
+    throw new Error("Cannot overwrite name of WalkError");
+  }
+}
+
+export { WalkError as default };

package/dist/packem_shared/assertValidFileContents-CRVvyM6b.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const assertValidFileContents = /* @__PURE__ */ __name((contents) => {
+  if (typeof contents !== "string" && !(contents instanceof ArrayBuffer) && !ArrayBuffer.isView(contents)) {
+    throw new TypeError("File contents must be a string, ArrayBuffer, or ArrayBuffer view.");
+  }
+}, "assertValidFileContents");
+
+module.exports = assertValidFileContents;

package/dist/packem_shared/assertValidFileContents-Ox-ScfeK.mjs

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const assertValidFileContents = /* @__PURE__ */ __name((contents) => {
+  if (typeof contents !== "string" && !(contents instanceof ArrayBuffer) && !ArrayBuffer.isView(contents)) {
+    throw new TypeError("File contents must be a string, ArrayBuffer, or ArrayBuffer view.");
+  }
+}, "assertValidFileContents");
+
+export { assertValidFileContents as default };

package/dist/packem_shared/assertValidFileOrDirectoryPath-BMbgA-eI.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const assertValidFileOrDirectoryPath = /* @__PURE__ */ __name((fileOrDirectoryPath) => {
+  if (!fileOrDirectoryPath || !(fileOrDirectoryPath instanceof URL) && typeof fileOrDirectoryPath !== "string") {
+    throw new TypeError("Path must be a non-empty string or URL.");
+  }
+}, "assertValidFileOrDirectoryPath");
+
+module.exports = assertValidFileOrDirectoryPath;

package/dist/packem_shared/assertValidFileOrDirectoryPath-BWWgA1wj.mjs

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const assertValidFileOrDirectoryPath = /* @__PURE__ */ __name((fileOrDirectoryPath) => {
+  if (!fileOrDirectoryPath || !(fileOrDirectoryPath instanceof URL) && typeof fileOrDirectoryPath !== "string") {
+    throw new TypeError("Path must be a non-empty string or URL.");
+  }
+}, "assertValidFileOrDirectoryPath");
+
+export { assertValidFileOrDirectoryPath as default };

package/dist/packem_shared/collect-BtDVJEOm.mjs

@@ -0,0 +1,16 @@
+import walk from './walk-CNcSYQVq.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const collect = /* @__PURE__ */ __name(async (directory, options = {}) => {
+  if (!Array.isArray(options.extensions)) {
+    options.extensions = ["js", "mjs", "cjs", "ts"];
+  }
+  const entries = [];
+  for await (const entry of walk(directory, options)) {
+    entries.push(entry.path);
+  }
+  return entries;
+}, "collect");
+
+export { collect as default };

package/dist/packem_shared/collect-DxUriHCH.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+const walk = require('./walk-BW7b4GXI.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const collect = /* @__PURE__ */ __name(async (directory, options = {}) => {
+  if (!Array.isArray(options.extensions)) {
+    options.extensions = ["js", "mjs", "cjs", "ts"];
+  }
+  const entries = [];
+  for await (const entry of walk(directory, options)) {
+    entries.push(entry.path);
+  }
+  return entries;
+}, "collect");
+
+module.exports = collect;

package/dist/packem_shared/collectSync-BaA0s001.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+const walkSync = require('./walkSync-DgPj93NL.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const collectSync = /* @__PURE__ */ __name((directory, options = {}) => {
+  if (!Array.isArray(options.extensions)) {
+    options.extensions = ["js", "mjs", "cjs", "ts"];
+  }
+  const entries = [];
+  for (const entry of walkSync(directory, options)) {
+    entries.push(entry.path);
+  }
+  return entries;
+}, "collectSync");
+
+module.exports = collectSync;

package/dist/packem_shared/collectSync-CGjdb50I.mjs

@@ -0,0 +1,16 @@
+import walkSync from './walkSync-BzxdFWLU.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const collectSync = /* @__PURE__ */ __name((directory, options = {}) => {
+  if (!Array.isArray(options.extensions)) {
+    options.extensions = ["js", "mjs", "cjs", "ts"];
+  }
+  const entries = [];
+  for (const entry of walkSync(directory, options)) {
+    entries.push(entry.path);
+  }
+  return entries;
+}, "collectSync");
+
+export { collectSync as default };

package/dist/packem_shared/emptyDir-DcCfiNcf.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const promises = require('node:fs/promises');
+const path = require('@visulima/path');
+const utils = require('@visulima/path/utils');
+const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const emptyDir = /* @__PURE__ */ __name(async (dir, options) => {
+  assertValidFileOrDirectoryPath(dir);
+  if (!node_fs.existsSync(dir)) {
+    await promises.mkdir(dir, { recursive: true });
+    return;
+  }
+  for await (const item of await promises.readdir(dir)) {
+    await promises.rm(path.join(utils.toPath(dir), item), { ...options, force: true, recursive: true });
+  }
+}, "emptyDir");
+
+module.exports = emptyDir;

package/dist/packem_shared/emptyDir-Dw5xSBox.mjs

@@ -0,0 +1,20 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readdir, rm } from 'node:fs/promises';
+import { join } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const emptyDir = /* @__PURE__ */ __name(async (dir, options) => {
+  assertValidFileOrDirectoryPath(dir);
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true });
+    return;
+  }
+  for await (const item of await readdir(dir)) {
+    await rm(join(toPath(dir), item), { ...options, force: true, recursive: true });
+  }
+}, "emptyDir");
+
+export { emptyDir as default };

package/dist/packem_shared/emptyDirSync-BoknkGUe.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const path = require('@visulima/path');
+const utils = require('@visulima/path/utils');
+const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const emptyDir = /* @__PURE__ */ __name((dir, options) => {
+  assertValidFileOrDirectoryPath(dir);
+  if (!node_fs.existsSync(dir)) {
+    node_fs.mkdirSync(dir, { recursive: true });
+    return;
+  }
+  for (const item of node_fs.readdirSync(dir)) {
+    node_fs.rmSync(path.join(utils.toPath(dir), item), { ...options, force: true, recursive: true });
+  }
+}, "emptyDir");
+
+module.exports = emptyDir;

package/dist/packem_shared/emptyDirSync-DTGPXQ3v.mjs

@@ -0,0 +1,19 @@
+import { existsSync, mkdirSync, readdirSync, rmSync } from 'node:fs';
+import { join } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const emptyDir = /* @__PURE__ */ __name((dir, options) => {
+  assertValidFileOrDirectoryPath(dir);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+    return;
+  }
+  for (const item of readdirSync(dir)) {
+    rmSync(join(toPath(dir), item), { ...options, force: true, recursive: true });
+  }
+}, "emptyDir");
+
+export { emptyDir as default };

package/dist/packem_shared/ensureDir-XiBlkOLR.mjs

@@ -0,0 +1,33 @@
+import { lstat, mkdir } from 'node:fs/promises';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+import { g as getFileInfoType } from './get-file-info-type-CeiZ6n6g.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const ensureDir = /* @__PURE__ */ __name(async (directory) => {
+  assertValidFileOrDirectoryPath(directory);
+  try {
+    const fileInfo = await lstat(directory);
+    if (!fileInfo.isDirectory()) {
+      throw new Error(`Ensure path exists, expected 'dir', got '${getFileInfoType(fileInfo)}'`);
+    }
+    return;
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  try {
+    await mkdir(directory, { recursive: true });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+    const fileInfo = await lstat(directory);
+    if (!fileInfo.isDirectory()) {
+      throw new Error(`Ensure path exists, expected 'dir', got '${getFileInfoType(fileInfo)}'`);
+    }
+  }
+}, "ensureDir");
+
+export { ensureDir as default };

package/dist/packem_shared/ensureDir-iUK2ga5M.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+const promises = require('node:fs/promises');
+const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+const getFileInfoType = require('./get-file-info-type-BpRzQHvd.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const ensureDir = /* @__PURE__ */ __name(async (directory) => {
+  assertValidFileOrDirectoryPath(directory);
+  try {
+    const fileInfo = await promises.lstat(directory);
+    if (!fileInfo.isDirectory()) {
+      throw new Error(`Ensure path exists, expected 'dir', got '${getFileInfoType.getFileInfoType(fileInfo)}'`);
+    }
+    return;
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  try {
+    await promises.mkdir(directory, { recursive: true });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+    const fileInfo = await promises.lstat(directory);
+    if (!fileInfo.isDirectory()) {
+      throw new Error(`Ensure path exists, expected 'dir', got '${getFileInfoType.getFileInfoType(fileInfo)}'`);
+    }
+  }
+}, "ensureDir");
+
+module.exports = ensureDir;

package/dist/packem_shared/ensureDirSync-2IFUHFK2.mjs

@@ -0,0 +1,33 @@
+import { lstatSync, mkdirSync } from 'node:fs';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+import { g as getFileInfoType } from './get-file-info-type-CeiZ6n6g.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const ensureDirSync = /* @__PURE__ */ __name((directory) => {
+  assertValidFileOrDirectoryPath(directory);
+  try {
+    const fileInfo = lstatSync(directory);
+    if (!fileInfo.isDirectory()) {
+      throw new Error(`Ensure path exists, expected 'dir', got '${getFileInfoType(fileInfo)}'`);
+    }
+    return;
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  try {
+    mkdirSync(directory, { recursive: true });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+    const fileInfo = lstatSync(directory);
+    if (!fileInfo.isDirectory()) {
+      throw new Error(`Ensure path exists, expected 'dir', got '${getFileInfoType(fileInfo)}'`);
+    }
+  }
+}, "ensureDirSync");
+
+export { ensureDirSync as default };

package/dist/packem_shared/ensureDirSync-CXdMkg0Y.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+const getFileInfoType = require('./get-file-info-type-BpRzQHvd.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const ensureDirSync = /* @__PURE__ */ __name((directory) => {
+  assertValidFileOrDirectoryPath(directory);
+  try {
+    const fileInfo = node_fs.lstatSync(directory);
+    if (!fileInfo.isDirectory()) {
+      throw new Error(`Ensure path exists, expected 'dir', got '${getFileInfoType.getFileInfoType(fileInfo)}'`);
+    }
+    return;
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  try {
+    node_fs.mkdirSync(directory, { recursive: true });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+    const fileInfo = node_fs.lstatSync(directory);
+    if (!fileInfo.isDirectory()) {
+      throw new Error(`Ensure path exists, expected 'dir', got '${getFileInfoType.getFileInfoType(fileInfo)}'`);
+    }
+  }
+}, "ensureDirSync");
+
+module.exports = ensureDirSync;

package/dist/packem_shared/ensureFile-Br8tFUJ7.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+const promises = require('node:fs/promises');
+const path = require('@visulima/path');
+const utils = require('@visulima/path/utils');
+const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+const getFileInfoType = require('./get-file-info-type-BpRzQHvd.cjs');
+const ensureDir = require('./ensureDir-iUK2ga5M.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const ensureFile = /* @__PURE__ */ __name(async (filePath) => {
+  assertValidFileOrDirectoryPath(filePath);
+  try {
+    const stat = await promises.lstat(filePath);
+    if (!stat.isFile()) {
+      throw new Error(`Ensure path exists, expected 'file', got '${getFileInfoType.getFileInfoType(stat)}'`);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      await ensureDir(path.dirname(utils.toPath(filePath)));
+      await promises.writeFile(filePath, new Uint8Array());
+      return;
+    }
+    throw error;
+  }
+}, "ensureFile");
+
+module.exports = ensureFile;

package/dist/packem_shared/ensureFile-C2bWlBEa.mjs

@@ -0,0 +1,27 @@
+import { lstat, writeFile } from 'node:fs/promises';
+import { dirname } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+import { g as getFileInfoType } from './get-file-info-type-CeiZ6n6g.mjs';
+import ensureDir from './ensureDir-XiBlkOLR.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const ensureFile = /* @__PURE__ */ __name(async (filePath) => {
+  assertValidFileOrDirectoryPath(filePath);
+  try {
+    const stat = await lstat(filePath);
+    if (!stat.isFile()) {
+      throw new Error(`Ensure path exists, expected 'file', got '${getFileInfoType(stat)}'`);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      await ensureDir(dirname(toPath(filePath)));
+      await writeFile(filePath, new Uint8Array());
+      return;
+    }
+    throw error;
+  }
+}, "ensureFile");
+
+export { ensureFile as default };

package/dist/packem_shared/ensureFileSync-CZzSkNGC.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const path = require('@visulima/path');
+const utils = require('@visulima/path/utils');
+const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+const getFileInfoType = require('./get-file-info-type-BpRzQHvd.cjs');
+const ensureDirSync = require('./ensureDirSync-CXdMkg0Y.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const ensureFileSync = /* @__PURE__ */ __name((filePath) => {
+  assertValidFileOrDirectoryPath(filePath);
+  try {
+    const stat = node_fs.lstatSync(filePath);
+    if (!stat.isFile()) {
+      throw new Error(`Ensure path exists, expected 'file', got '${getFileInfoType.getFileInfoType(stat)}'`);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      ensureDirSync(path.dirname(utils.toPath(filePath)));
+      node_fs.writeFileSync(filePath, new Uint8Array());
+      return;
+    }
+    throw error;
+  }
+}, "ensureFileSync");
+
+module.exports = ensureFileSync;

package/dist/packem_shared/ensureFileSync-DkFfhOEs.mjs

@@ -0,0 +1,27 @@
+import { lstatSync, writeFileSync } from 'node:fs';
+import { dirname } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+import { g as getFileInfoType } from './get-file-info-type-CeiZ6n6g.mjs';
+import ensureDirSync from './ensureDirSync-2IFUHFK2.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const ensureFileSync = /* @__PURE__ */ __name((filePath) => {
+  assertValidFileOrDirectoryPath(filePath);
+  try {
+    const stat = lstatSync(filePath);
+    if (!stat.isFile()) {
+      throw new Error(`Ensure path exists, expected 'file', got '${getFileInfoType(stat)}'`);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      ensureDirSync(dirname(toPath(filePath)));
+      writeFileSync(filePath, new Uint8Array());
+      return;
+    }
+    throw error;
+  }
+}, "ensureFileSync");
+
+export { ensureFileSync as default };

package/dist/packem_shared/ensureLink-CFiabAD3.mjs

@@ -0,0 +1,34 @@
+import { lstat, link } from 'node:fs/promises';
+import { toNamespacedPath, dirname } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+import { i as isStatsIdentical } from './is-stats-identical-ByTYZ2Aw.mjs';
+import ensureDir from './ensureDir-XiBlkOLR.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const ensureLink = /* @__PURE__ */ __name(async (source, destination) => {
+  assertValidFileOrDirectoryPath(source);
+  assertValidFileOrDirectoryPath(destination);
+  source = toNamespacedPath(toPath(source));
+  destination = toNamespacedPath(toPath(destination));
+  let destinationStat;
+  try {
+    destinationStat = await lstat(destination);
+  } catch {
+  }
+  let sourceStat;
+  try {
+    sourceStat = await lstat(source);
+  } catch (error) {
+    error.message = error.message.replace("lstat", "ensureLink");
+    throw error;
+  }
+  if (destinationStat && isStatsIdentical(sourceStat, destinationStat)) {
+    return;
+  }
+  await ensureDir(dirname(destination));
+  await link(source, destination);
+}, "ensureLink");
+
+export { ensureLink as default };

package/dist/packem_shared/ensureLink-Dqw5GBDq.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+const promises = require('node:fs/promises');
+const path = require('@visulima/path');
+const utils = require('@visulima/path/utils');
+const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+const isStatsIdentical = require('./is-stats-identical-BfdEfO6i.cjs');
+const ensureDir = require('./ensureDir-iUK2ga5M.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const ensureLink = /* @__PURE__ */ __name(async (source, destination) => {
+  assertValidFileOrDirectoryPath(source);
+  assertValidFileOrDirectoryPath(destination);
+  source = path.toNamespacedPath(utils.toPath(source));
+  destination = path.toNamespacedPath(utils.toPath(destination));
+  let destinationStat;
+  try {
+    destinationStat = await promises.lstat(destination);
+  } catch {
+  }
+  let sourceStat;
+  try {
+    sourceStat = await promises.lstat(source);
+  } catch (error) {
+    error.message = error.message.replace("lstat", "ensureLink");
+    throw error;
+  }
+  if (destinationStat && isStatsIdentical.isStatsIdentical(sourceStat, destinationStat)) {
+    return;
+  }
+  await ensureDir(path.dirname(destination));
+  await promises.link(source, destination);
+}, "ensureLink");
+
+module.exports = ensureLink;

package/dist/packem_shared/ensureLinkSync-BVw3h6sK.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const path = require('@visulima/path');
+const utils = require('@visulima/path/utils');
+const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+const isStatsIdentical = require('./is-stats-identical-BfdEfO6i.cjs');
+const ensureDirSync = require('./ensureDirSync-CXdMkg0Y.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const ensureLinkSync = /* @__PURE__ */ __name((source, destination) => {
+  assertValidFileOrDirectoryPath(source);
+  assertValidFileOrDirectoryPath(destination);
+  source = path.toNamespacedPath(utils.toPath(source));
+  destination = path.toNamespacedPath(utils.toPath(destination));
+  let destinationStat;
+  try {
+    destinationStat = node_fs.lstatSync(destination);
+  } catch {
+  }
+  let sourceStat;
+  try {
+    sourceStat = node_fs.lstatSync(source);
+  } catch (error) {
+    error.message = error.message.replace("lstat", "ensureLink");
+    throw error;
+  }
+  if (destinationStat && isStatsIdentical.isStatsIdentical(sourceStat, destinationStat)) {
+    return;
+  }
+  ensureDirSync(path.dirname(destination));
+  node_fs.linkSync(source, destination);
+}, "ensureLinkSync");
+
+module.exports = ensureLinkSync;

package/dist/packem_shared/ensureLinkSync-Dk-YeRg6.mjs

@@ -0,0 +1,34 @@
+import { lstatSync, linkSync } from 'node:fs';
+import { toNamespacedPath, dirname } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+import { i as isStatsIdentical } from './is-stats-identical-ByTYZ2Aw.mjs';
+import ensureDirSync from './ensureDirSync-2IFUHFK2.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const ensureLinkSync = /* @__PURE__ */ __name((source, destination) => {
+  assertValidFileOrDirectoryPath(source);
+  assertValidFileOrDirectoryPath(destination);
+  source = toNamespacedPath(toPath(source));
+  destination = toNamespacedPath(toPath(destination));
+  let destinationStat;
+  try {
+    destinationStat = lstatSync(destination);
+  } catch {
+  }
+  let sourceStat;
+  try {
+    sourceStat = lstatSync(source);
+  } catch (error) {
+    error.message = error.message.replace("lstat", "ensureLink");
+    throw error;
+  }
+  if (destinationStat && isStatsIdentical(sourceStat, destinationStat)) {
+    return;
+  }
+  ensureDirSync(dirname(destination));
+  linkSync(source, destination);
+}, "ensureLinkSync");
+
+export { ensureLinkSync as default };