@kprint/kprint 0.0.0-stage → 0.60.6

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 David Sherret
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,35 @@
-# Temporary Holding Version
+# @kprint/kprint
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[kprint](https://dprint.kjanat.dev) is a pluggable and configurable code
+formatter written in Rust, forked from dprint. It has formatters built in (ex.
+exec) and runs dprint's plugins.
+
+## Install
+
+```sh
+npm install --global @kprint/kprint
+```
+
+This installs the `kprint` command, also as `dprint` for tools
+that call that. npm only downloads the binary for your platform, from its
+`@kprint/kprint-<platform>` package.
+
+## Use
+
+```sh
+kprint init   # create a configuration file
+kprint fmt    # format the files
+kprint check  # check they're formatted
+```
+
+Or in a project, as a dev dependency:
+
+```sh
+npm install --save-dev @kprint/kprint
+npx kprint fmt
+```
+
+[@kjanat/fmt](https://www.npmjs.com/package/@kjanat/fmt) runs `kprint fmt` as `fmt`.
+
+See [dprint.kjanat.dev](https://dprint.kjanat.dev) for the configuration and the
+plugins, and [the repository](https://github.com/kjanat/dprint) for its source.

package/bin.cjs

@@ -0,0 +1,365 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  1 ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// deployment/npm/bin.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+
+// deployment/npm/install_api.ts
+var import_node_child_process = require("node:child_process");
+var import_node_crypto = require("node:crypto");
+var fs = __toESM(require("node:fs"));
+var import_node_module = require("node:module");
+var os = __toESM(require("node:os"));
+var path = __toESM(require("node:path"));
+var import_node_zlib = require("node:zlib");
+
+// deployment/npm/names.ts
+var scope = "@kprint";
+var mainPackage = `${scope}/kprint`;
+var platformPrefix = "kprint";
+function platformPackage(platform3) {
+  return `${scope}/${platformDir(platform3)}`;
+}
+function platformDir(platform3) {
+  return `${platformPrefix}-${platform3}`;
+}
+
+// deployment/npm/install_api.ts
+var cachedIsMusl;
+function runInstall() {
+  const dprintFileName = os.platform() === "win32" ? "kprint.exe" : "kprint";
+  const targetExecutablePath = path.join(__dirname, dprintFileName);
+  if (fs.existsSync(targetExecutablePath)) return targetExecutablePath;
+  const target = getTarget();
+  const sourceExecutablePath = resolveSourceExecutablePath(target, dprintFileName);
+  if (sourceExecutablePath == null) {
+    downloadExecutable(target, dprintFileName, targetExecutablePath);
+    if (os.platform() !== "win32") chmodX(targetExecutablePath);
+    return targetExecutablePath;
+  }
+  try {
+    if (process.env.DPRINT_SIMULATED_READONLY_FILE_SYSTEM === "1") {
+      console.warn("Simulating readonly file system for testing.");
+      throw new Error("Throwing for testing purposes.");
+    }
+    hardLinkOrCopy(sourceExecutablePath, targetExecutablePath);
+    if (os.platform() !== "win32") chmodX(targetExecutablePath);
+    return targetExecutablePath;
+  } catch (err) {
+    if (process.env.DPRINT_DEBUG === "1") {
+      console.warn(`Failed to copy executable from ${sourceExecutablePath} to ${targetExecutablePath}. Using resolved package path instead.`, err);
+    }
+    return sourceExecutablePath;
+  }
+}
+function packageName(target) {
+  return platformPackage(target);
+}
+function resolveSourceExecutablePath(target, dprintFileName) {
+  let sourcePackagePath;
+  try {
+    sourcePackagePath = path.dirname((0, import_node_module.createRequire)(__filename).resolve(`${packageName(target)}/package.json`));
+  } catch {
+    return void 0;
+  }
+  const sourceExecutablePath = path.join(sourcePackagePath, dprintFileName);
+  return fs.existsSync(sourceExecutablePath) ? sourceExecutablePath : void 0;
+}
+function readPackageField(fileName, field) {
+  const parsed = JSON.parse(fs.readFileSync(path.join(__dirname, fileName), "utf8"));
+  if (typeof parsed !== "object" || parsed === null) throw new Error(`${fileName} is not an object`);
+  return Object.fromEntries(Object.entries(parsed))[field];
+}
+function downloadExecutable(target, dprintFileName, destinationPath) {
+  const version = readPackageField("package.json", "version");
+  if (typeof version !== "string") throw new Error("package.json has no version");
+  const registry = (process.env.npm_config_registry || "https://registry.npmjs.org").replace(/\/+$/, "");
+  const tarballUrl = `${registry}/${packageName(target)}/-/${platformDir(target)}-${version}.tgz`;
+  console.error(`[kprint] Optional dependency ${packageName(target)} was not installed. Downloading from ${tarballUrl}`);
+  const tarballBuffer = downloadBufferSync(tarballUrl);
+  const executableBuffer = extractFileFromTarGzip(tarballBuffer, `package/${dprintFileName}`);
+  verifyExecutableHash(target, executableBuffer);
+  atomicWriteFile(destinationPath, executableBuffer);
+}
+function verifyExecutableHash(target, buffer) {
+  let expected;
+  try {
+    expected = readPackageField("hashes.json", target);
+  } catch (err) {
+    throw new Error(`Could not load hashes.json to verify the downloaded binary: ${err instanceof Error ? err.message : err}`);
+  }
+  if (typeof expected !== "string") {
+    throw new Error(`No known hash for ${packageName(target)} to verify the download against.`);
+  }
+  const actual = (0, import_node_crypto.createHash)("sha256").update(buffer).digest("hex");
+  if (actual !== expected) {
+    throw new Error(`Integrity check failed for the downloaded ${packageName(target)} binary.
+  Expected sha256: ${expected}
+  Actual sha256:   ${actual}`);
+  }
+}
+function downloadBufferSync(url) {
+  const fromCurl = downloadBufferWithCurl(url);
+  return fromCurl != null ? fromCurl : downloadBufferWithNode(url);
+}
+function downloadBufferWithCurl(url) {
+  const args = [
+    "-fsSL"
+  ];
+  const proxy = process.env.npm_config_https_proxy || process.env.npm_config_proxy || process.env.HTTPS_PROXY || process.env.https_proxy;
+  if (proxy) {
+    args.push("--proxy", proxy);
+  }
+  const noProxy = process.env.npm_config_noproxy || process.env.NO_PROXY || process.env.no_proxy;
+  if (noProxy) {
+    args.push("--noproxy", noProxy);
+  }
+  args.push("-o", "-", url);
+  try {
+    return (0, import_node_child_process.execFileSync)("curl", args, {
+      maxBuffer: 512 * 1024 * 1024
+    });
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return void 0;
+    }
+    throw err;
+  }
+}
+function downloadBufferWithNode(url) {
+  const script = `const https = require("node:https");
+function f(u) {
+  https.get(u, r => {
+    const s = r.statusCode;
+    if ((s === 301 || s === 302 || s === 303 || s === 307 || s === 308) && r.headers.location) {
+      f(new URL(r.headers.location, u).toString());
+      return;
+    }
+    if (s !== 200) {
+      console.error(\`[kprint] Unexpected status code \${s} downloading \${u}\`);
+      process.exit(1);
+    }
+    r.pipe(process.stdout);
+  }).on("error", e => {
+    console.error(String(e?.message || e));
+    process.exit(1);
+  });
+}
+f(process.argv[1]);
+`;
+  return (0, import_node_child_process.execFileSync)(process.execPath, [
+    "-e",
+    script,
+    url
+  ], {
+    maxBuffer: 512 * 1024 * 1024
+  });
+}
+function extractFileFromTarGzip(buffer, subpath) {
+  let tar;
+  try {
+    tar = (0, import_node_zlib.gunzipSync)(buffer);
+  } catch (err) {
+    throw new Error(`Invalid gzip data in downloaded tarball: ${err instanceof Error ? err.message : err}`);
+  }
+  let offset = 0;
+  while (offset < tar.length) {
+    const name = readTarString(tar, offset, 100);
+    const size = parseInt(readTarString(tar, offset + 124, 12).trim(), 8);
+    offset += 512;
+    if (!Number.isNaN(size)) {
+      if (name === subpath) return tar.subarray(offset, offset + size);
+      offset += size + 511 & ~511;
+    }
+  }
+  throw new Error(`Could not find ${JSON.stringify(subpath)} in downloaded tarball`);
+}
+function readTarString(buffer, offset, length) {
+  return buffer.toString("utf8", offset, offset + length).replace(/\0.*$/, "");
+}
+function atomicWriteFile(destinationPath, buffer) {
+  const rand = (0, import_node_crypto.randomBytes)(4).toString("hex");
+  const tempFilePath = `${destinationPath}.${rand}`;
+  fs.writeFileSync(tempFilePath, buffer);
+  try {
+    fs.renameSync(tempFilePath, destinationPath);
+  } catch (err) {
+    try {
+      fs.unlinkSync(tempFilePath);
+    } catch {
+    }
+    throw err;
+  }
+}
+function chmodX(filePath) {
+  const fd = fs.openSync(filePath, "r");
+  try {
+    const perms = fs.fstatSync(fd).mode;
+    fs.fchmodSync(fd, perms | 73);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+function getTarget() {
+  const platform3 = os.platform();
+  if (platform3 === "linux") {
+    return `${platform3}-${getArch()}-${getLinuxFamily()}`;
+  } else {
+    return `${platform3}-${getArch()}`;
+  }
+}
+function getArch() {
+  const arch2 = os.arch();
+  if (arch2 !== "arm64" && arch2 !== "x64" && arch2 !== "riscv64" && arch2 !== "loong64" && arch2 !== "ppc64") {
+    throw new Error(`Unsupported architecture ${os.arch()}. Only x64, arm64, riscv64, loong64 and ppc64 binaries are available.`);
+  }
+  return arch2;
+}
+function getLinuxFamily() {
+  return getIsMusl() ? "musl" : "glibc";
+  function getIsMusl() {
+    if (cachedIsMusl == null) {
+      cachedIsMusl = innerGet();
+    }
+    return cachedIsMusl;
+    function innerGet() {
+      try {
+        if (os.platform() !== "linux") {
+          return false;
+        }
+        let musl = isMuslFromFilesystem();
+        if (musl == null) {
+          musl = isMuslFromReport();
+        }
+        if (musl == null) {
+          musl = isMuslFromChildProcess();
+        }
+        return musl;
+      } catch (err) {
+        console.warn("Error checking if musl.", err);
+        return false;
+      }
+    }
+    function isMuslFromFilesystem() {
+      try {
+        return fs.readFileSync("/usr/bin/ldd", "utf-8").includes("musl");
+      } catch {
+        return null;
+      }
+    }
+    function isMuslFromReport() {
+      const processReport = process.report;
+      if (typeof processReport !== "object" || processReport === null || !("getReport" in processReport) || typeof processReport.getReport !== "function") {
+        return null;
+      }
+      const originalExcludeNetwork = Reflect.get(processReport, "excludeNetwork");
+      let rawReport;
+      try {
+        Reflect.set(processReport, "excludeNetwork", true);
+        rawReport = processReport.getReport();
+      } finally {
+        Reflect.set(processReport, "excludeNetwork", originalExcludeNetwork);
+      }
+      const report = typeof rawReport === "string" ? JSON.parse(rawReport) : rawReport;
+      if (typeof report !== "object" || report === null) {
+        return null;
+      }
+      const fields = Object.fromEntries(Object.entries(report));
+      const header = fields.header;
+      if (typeof header === "object" && header !== null && "glibcVersionRuntime" in header && header.glibcVersionRuntime) {
+        return false;
+      }
+      const sharedObjects = fields.sharedObjects;
+      if (Array.isArray(sharedObjects)) {
+        return sharedObjects.some((entry) => typeof entry === "string" && isFileMusl(entry));
+      }
+      return false;
+    }
+    function isMuslFromChildProcess() {
+      try {
+        return (0, import_node_child_process.execSync)("ldd --version", {
+          encoding: "utf8"
+        }).includes("musl");
+      } catch {
+        return false;
+      }
+    }
+    function isFileMusl(f) {
+      return f.includes("libc.musl-") || f.includes("ld-musl-");
+    }
+  }
+}
+function hardLinkOrCopy(sourcePath, destinationPath) {
+  try {
+    fs.linkSync(sourcePath, destinationPath);
+  } catch {
+    atomicCopyFile(sourcePath, destinationPath);
+  }
+}
+function atomicCopyFile(sourcePath, destinationPath) {
+  const rand = (0, import_node_crypto.randomBytes)(4).toString("hex");
+  const tempFilePath = `${destinationPath}.${rand}`;
+  fs.copyFileSync(sourcePath, tempFilePath);
+  try {
+    fs.renameSync(tempFilePath, destinationPath);
+  } catch (err) {
+    try {
+      fs.unlinkSync(tempFilePath);
+    } catch {
+    }
+    throw err;
+  }
+}
+
+// deployment/npm/bin.ts
+var exePath = (0, import_node_path.join)(__dirname, (0, import_node_os.platform)() === "win32" ? "kprint.exe" : "kprint");
+if (!(0, import_node_fs.existsSync)(exePath)) {
+  try {
+    runDprintExe(runInstall());
+  } catch (err) {
+    if (err instanceof Error) {
+      console.error(err.message);
+    } else {
+      console.error(err);
+    }
+    process.exit(1);
+  }
+} else {
+  runDprintExe(exePath);
+}
+function runDprintExe(exePath2) {
+  const result = (0, import_node_child_process2.spawnSync)(exePath2, process.argv.slice(2), {
+    stdio: "inherit"
+  });
+  if (result.error) {
+    if (!(0, import_node_fs.existsSync)(exePath2)) {
+      throw new Error("Could not find exe at path '" + exePath2 + "'. Maybe try installing kprint again.");
+    }
+    throw result.error;
+  }
+  process.exit(result.status ?? 1);
+}

package/hashes.json

@@ -0,0 +1,18 @@
+{
+  "freebsd-x64": "b4f113c0ed36f2bc225f3008020a3f2d4e1708bb109b1ae8fa577a721c32c7df",
+  "win32-x64": "d8f725136aa4ea0e4c0cea3568df06935731296eb49356f2570386b93e584990",
+  "win32-arm64": "4f76f977865bfa877a99737c3ffa73e052a9e25f5bf25c00c453fb40cf6b0f7c",
+  "darwin-x64": "793e7e41dd562c8467486207773f260ab53e75130058b4d962e7f96272a7cc29",
+  "darwin-arm64": "91cce0bc4403844c8f22919bb1cff6217b9b70061f953b506f7b7592372533ba",
+  "linux-x64-glibc": "9b40a3b5d1b88e61f4cd344af0db27e73ed191b4c6877557957cbfa8fb16e5a3",
+  "linux-x64-musl": "9862dbe85354068e3e1875d9feab963ba36a6ce53d995000472273598c23645d",
+  "linux-arm64-glibc": "29ca735535518e1c2a2bfa25fa8f796c99a9a5eb729a86332e5f569902a6760e",
+  "linux-arm64-musl": "11bd8e75168110f6a2a4018a36fd7cd2cb0c103de2b11d5cd93175ee9da4f5a6",
+  "linux-riscv64-glibc": "4979d3d68fb7fb339f3a950987bfb90a47fd48210c484c269617f7340f621921",
+  "linux-loong64-glibc": "a691bf35b5ca1b514a0addefa6b3c1d7ba1d46e16a5c71bdf2092e15336c8d32",
+  "linux-loong64-musl": "bde33362abc59ba321ad132f37dfcf3b9afa2509f7de089a97609f6c67effbc2",
+  "linux-ppc64-glibc": "5fa333f5994e3bf017c99be84a318837697d21d5d4a1f149ef3706bbf2fd9536",
+  "linux-ppc64-musl": "7859bbb430136a319c60ad820250cd063c667e5e16bb2ba82ff538da406bc27c",
+  "android-arm64": "7182eb339e928aed3bf3ecac0b7e096bff2c7411514b4d414dc4d361a65f7fae",
+  "android-x64": "05d2d8ed5b4f1572fce26b1441c31e0b6e56c2b63f3e5a3560e549a326b4c894"
+}

package/install.cjs

@@ -0,0 +1,400 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  1 ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// deployment/npm/install_api.ts
+var import_node_child_process = require("node:child_process");
+var import_node_crypto = require("node:crypto");
+var fs = __toESM(require("node:fs"));
+var import_node_module = require("node:module");
+var os = __toESM(require("node:os"));
+var path = __toESM(require("node:path"));
+var import_node_zlib = require("node:zlib");
+
+// deployment/npm/names.ts
+var scope = "@kprint";
+var mainPackage = `${scope}/kprint`;
+var platformPrefix = "kprint";
+function platformPackage(platform2) {
+  return `${scope}/${platformDir(platform2)}`;
+}
+function platformDir(platform2) {
+  return `${platformPrefix}-${platform2}`;
+}
+
+// deployment/npm/install_api.ts
+var BIN_COMMANDS = [
+  "kprint",
+  "dprint"
+];
+var cachedIsMusl;
+function runInstall() {
+  const dprintFileName = os.platform() === "win32" ? "kprint.exe" : "kprint";
+  const targetExecutablePath = path.join(__dirname, dprintFileName);
+  if (fs.existsSync(targetExecutablePath)) return targetExecutablePath;
+  const target = getTarget();
+  const sourceExecutablePath = resolveSourceExecutablePath(target, dprintFileName);
+  if (sourceExecutablePath == null) {
+    downloadExecutable(target, dprintFileName, targetExecutablePath);
+    if (os.platform() !== "win32") chmodX(targetExecutablePath);
+    return targetExecutablePath;
+  }
+  try {
+    if (process.env.DPRINT_SIMULATED_READONLY_FILE_SYSTEM === "1") {
+      console.warn("Simulating readonly file system for testing.");
+      throw new Error("Throwing for testing purposes.");
+    }
+    hardLinkOrCopy(sourceExecutablePath, targetExecutablePath);
+    if (os.platform() !== "win32") chmodX(targetExecutablePath);
+    return targetExecutablePath;
+  } catch (err) {
+    if (process.env.DPRINT_DEBUG === "1") {
+      console.warn(`Failed to copy executable from ${sourceExecutablePath} to ${targetExecutablePath}. Using resolved package path instead.`, err);
+    }
+    return sourceExecutablePath;
+  }
+}
+function packageName(target) {
+  return platformPackage(target);
+}
+function resolveSourceExecutablePath(target, dprintFileName) {
+  let sourcePackagePath;
+  try {
+    sourcePackagePath = path.dirname((0, import_node_module.createRequire)(__filename).resolve(`${packageName(target)}/package.json`));
+  } catch {
+    return void 0;
+  }
+  const sourceExecutablePath = path.join(sourcePackagePath, dprintFileName);
+  return fs.existsSync(sourceExecutablePath) ? sourceExecutablePath : void 0;
+}
+function readPackageField(fileName, field) {
+  const parsed = JSON.parse(fs.readFileSync(path.join(__dirname, fileName), "utf8"));
+  if (typeof parsed !== "object" || parsed === null) throw new Error(`${fileName} is not an object`);
+  return Object.fromEntries(Object.entries(parsed))[field];
+}
+function downloadExecutable(target, dprintFileName, destinationPath) {
+  const version = readPackageField("package.json", "version");
+  if (typeof version !== "string") throw new Error("package.json has no version");
+  const registry = (process.env.npm_config_registry || "https://registry.npmjs.org").replace(/\/+$/, "");
+  const tarballUrl = `${registry}/${packageName(target)}/-/${platformDir(target)}-${version}.tgz`;
+  console.error(`[kprint] Optional dependency ${packageName(target)} was not installed. Downloading from ${tarballUrl}`);
+  const tarballBuffer = downloadBufferSync(tarballUrl);
+  const executableBuffer = extractFileFromTarGzip(tarballBuffer, `package/${dprintFileName}`);
+  verifyExecutableHash(target, executableBuffer);
+  atomicWriteFile(destinationPath, executableBuffer);
+}
+function verifyExecutableHash(target, buffer) {
+  let expected;
+  try {
+    expected = readPackageField("hashes.json", target);
+  } catch (err) {
+    throw new Error(`Could not load hashes.json to verify the downloaded binary: ${err instanceof Error ? err.message : err}`);
+  }
+  if (typeof expected !== "string") {
+    throw new Error(`No known hash for ${packageName(target)} to verify the download against.`);
+  }
+  const actual = (0, import_node_crypto.createHash)("sha256").update(buffer).digest("hex");
+  if (actual !== expected) {
+    throw new Error(`Integrity check failed for the downloaded ${packageName(target)} binary.
+  Expected sha256: ${expected}
+  Actual sha256:   ${actual}`);
+  }
+}
+function downloadBufferSync(url) {
+  const fromCurl = downloadBufferWithCurl(url);
+  return fromCurl != null ? fromCurl : downloadBufferWithNode(url);
+}
+function downloadBufferWithCurl(url) {
+  const args = [
+    "-fsSL"
+  ];
+  const proxy = process.env.npm_config_https_proxy || process.env.npm_config_proxy || process.env.HTTPS_PROXY || process.env.https_proxy;
+  if (proxy) {
+    args.push("--proxy", proxy);
+  }
+  const noProxy = process.env.npm_config_noproxy || process.env.NO_PROXY || process.env.no_proxy;
+  if (noProxy) {
+    args.push("--noproxy", noProxy);
+  }
+  args.push("-o", "-", url);
+  try {
+    return (0, import_node_child_process.execFileSync)("curl", args, {
+      maxBuffer: 512 * 1024 * 1024
+    });
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return void 0;
+    }
+    throw err;
+  }
+}
+function downloadBufferWithNode(url) {
+  const script = `const https = require("node:https");
+function f(u) {
+  https.get(u, r => {
+    const s = r.statusCode;
+    if ((s === 301 || s === 302 || s === 303 || s === 307 || s === 308) && r.headers.location) {
+      f(new URL(r.headers.location, u).toString());
+      return;
+    }
+    if (s !== 200) {
+      console.error(\`[kprint] Unexpected status code \${s} downloading \${u}\`);
+      process.exit(1);
+    }
+    r.pipe(process.stdout);
+  }).on("error", e => {
+    console.error(String(e?.message || e));
+    process.exit(1);
+  });
+}
+f(process.argv[1]);
+`;
+  return (0, import_node_child_process.execFileSync)(process.execPath, [
+    "-e",
+    script,
+    url
+  ], {
+    maxBuffer: 512 * 1024 * 1024
+  });
+}
+function extractFileFromTarGzip(buffer, subpath) {
+  let tar;
+  try {
+    tar = (0, import_node_zlib.gunzipSync)(buffer);
+  } catch (err) {
+    throw new Error(`Invalid gzip data in downloaded tarball: ${err instanceof Error ? err.message : err}`);
+  }
+  let offset = 0;
+  while (offset < tar.length) {
+    const name = readTarString(tar, offset, 100);
+    const size = parseInt(readTarString(tar, offset + 124, 12).trim(), 8);
+    offset += 512;
+    if (!Number.isNaN(size)) {
+      if (name === subpath) return tar.subarray(offset, offset + size);
+      offset += size + 511 & ~511;
+    }
+  }
+  throw new Error(`Could not find ${JSON.stringify(subpath)} in downloaded tarball`);
+}
+function readTarString(buffer, offset, length) {
+  return buffer.toString("utf8", offset, offset + length).replace(/\0.*$/, "");
+}
+function atomicWriteFile(destinationPath, buffer) {
+  const rand = (0, import_node_crypto.randomBytes)(4).toString("hex");
+  const tempFilePath = `${destinationPath}.${rand}`;
+  fs.writeFileSync(tempFilePath, buffer);
+  try {
+    fs.renameSync(tempFilePath, destinationPath);
+  } catch (err) {
+    try {
+      fs.unlinkSync(tempFilePath);
+    } catch {
+    }
+    throw err;
+  }
+}
+function chmodX(filePath) {
+  const fd = fs.openSync(filePath, "r");
+  try {
+    const perms = fs.fstatSync(fd).mode;
+    fs.fchmodSync(fd, perms | 73);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+function getTarget() {
+  const platform2 = os.platform();
+  if (platform2 === "linux") {
+    return `${platform2}-${getArch()}-${getLinuxFamily()}`;
+  } else {
+    return `${platform2}-${getArch()}`;
+  }
+}
+function getArch() {
+  const arch2 = os.arch();
+  if (arch2 !== "arm64" && arch2 !== "x64" && arch2 !== "riscv64" && arch2 !== "loong64" && arch2 !== "ppc64") {
+    throw new Error(`Unsupported architecture ${os.arch()}. Only x64, arm64, riscv64, loong64 and ppc64 binaries are available.`);
+  }
+  return arch2;
+}
+function getLinuxFamily() {
+  return getIsMusl() ? "musl" : "glibc";
+  function getIsMusl() {
+    if (cachedIsMusl == null) {
+      cachedIsMusl = innerGet();
+    }
+    return cachedIsMusl;
+    function innerGet() {
+      try {
+        if (os.platform() !== "linux") {
+          return false;
+        }
+        let musl = isMuslFromFilesystem();
+        if (musl == null) {
+          musl = isMuslFromReport();
+        }
+        if (musl == null) {
+          musl = isMuslFromChildProcess();
+        }
+        return musl;
+      } catch (err) {
+        console.warn("Error checking if musl.", err);
+        return false;
+      }
+    }
+    function isMuslFromFilesystem() {
+      try {
+        return fs.readFileSync("/usr/bin/ldd", "utf-8").includes("musl");
+      } catch {
+        return null;
+      }
+    }
+    function isMuslFromReport() {
+      const processReport = process.report;
+      if (typeof processReport !== "object" || processReport === null || !("getReport" in processReport) || typeof processReport.getReport !== "function") {
+        return null;
+      }
+      const originalExcludeNetwork = Reflect.get(processReport, "excludeNetwork");
+      let rawReport;
+      try {
+        Reflect.set(processReport, "excludeNetwork", true);
+        rawReport = processReport.getReport();
+      } finally {
+        Reflect.set(processReport, "excludeNetwork", originalExcludeNetwork);
+      }
+      const report = typeof rawReport === "string" ? JSON.parse(rawReport) : rawReport;
+      if (typeof report !== "object" || report === null) {
+        return null;
+      }
+      const fields = Object.fromEntries(Object.entries(report));
+      const header = fields.header;
+      if (typeof header === "object" && header !== null && "glibcVersionRuntime" in header && header.glibcVersionRuntime) {
+        return false;
+      }
+      const sharedObjects = fields.sharedObjects;
+      if (Array.isArray(sharedObjects)) {
+        return sharedObjects.some((entry) => typeof entry === "string" && isFileMusl(entry));
+      }
+      return false;
+    }
+    function isMuslFromChildProcess() {
+      try {
+        return (0, import_node_child_process.execSync)("ldd --version", {
+          encoding: "utf8"
+        }).includes("musl");
+      } catch {
+        return false;
+      }
+    }
+    function isFileMusl(f) {
+      return f.includes("libc.musl-") || f.includes("ld-musl-");
+    }
+  }
+}
+function replaceBinEntry(exePath2) {
+  const binDir = findBinDir();
+  if (binDir === void 0) return;
+  const relative2 = path.relative(binDir, exePath2);
+  for (const command of BIN_COMMANDS) {
+    if (!isOurBinEntry(binDir, command)) continue;
+    if (os.platform() === "win32") {
+      fs.writeFileSync(path.join(binDir, `${command}.cmd`), `@"%~dp0${relative2}" %*\r
+`);
+      fs.writeFileSync(path.join(binDir, `${command}.ps1`), `& (Join-Path $PSScriptRoot "${relative2.replace(/\\/g, "/")}") $args\r
+exit $LASTEXITCODE\r
+`);
+    } else {
+      const link = path.join(binDir, command);
+      fs.unlinkSync(link);
+      fs.symlinkSync(relative2, link);
+    }
+  }
+}
+function findBinDir() {
+  if (process.env.npm_config_global === "true") {
+    const prefix = process.env.npm_config_prefix;
+    if (prefix) {
+      const binDir = os.platform() === "win32" ? prefix : path.join(prefix, "bin");
+      if (isBinDirForThisPackage(binDir)) return binDir;
+    }
+  }
+  let dir = __dirname;
+  for (let i = 0; i < 64; i++) {
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    if (path.basename(parent) === "node_modules") {
+      const binDir = path.join(parent, ".bin");
+      if (isBinDirForThisPackage(binDir)) {
+        return binDir;
+      }
+    }
+    dir = parent;
+  }
+  return void 0;
+}
+function isBinDirForThisPackage(binDir) {
+  return isOurBinEntry(binDir, "kprint");
+}
+function isOurBinEntry(binDir, command) {
+  try {
+    if (os.platform() === "win32") {
+      const content = fs.readFileSync(path.join(binDir, `${command}.cmd`), "utf8");
+      return content.includes("bin.cjs");
+    } else {
+      const linkTarget = fs.readlinkSync(path.join(binDir, command));
+      const resolved = path.resolve(binDir, linkTarget);
+      return resolved.endsWith("bin.cjs");
+    }
+  } catch {
+    return false;
+  }
+}
+function hardLinkOrCopy(sourcePath, destinationPath) {
+  try {
+    fs.linkSync(sourcePath, destinationPath);
+  } catch {
+    atomicCopyFile(sourcePath, destinationPath);
+  }
+}
+function atomicCopyFile(sourcePath, destinationPath) {
+  const rand = (0, import_node_crypto.randomBytes)(4).toString("hex");
+  const tempFilePath = `${destinationPath}.${rand}`;
+  fs.copyFileSync(sourcePath, tempFilePath);
+  try {
+    fs.renameSync(tempFilePath, destinationPath);
+  } catch (err) {
+    try {
+      fs.unlinkSync(tempFilePath);
+    } catch {
+    }
+    throw err;
+  }
+}
+
+// deployment/npm/install.ts
+var exePath = runInstall();
+try {
+  replaceBinEntry(exePath);
+} catch {
+}

package/package.json

@@ -1,6 +1,48 @@
 {
   "name": "@kprint/kprint",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.60.6",
+  "description": "kprint: a pluggable and configurable code formatter written in Rust, forked from dprint.",
+  "bin": {
+    "kprint": "bin.cjs",
+    "dprint": "bin.cjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kjanat/dprint.git"
+  },
+  "keywords": [
+    "dprint",
+    "formatter",
+    "format",
+    "code",
+    "cli"
+  ],
+  "author": "Kaj Kowalski",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/kjanat/dprint/issues"
+  },
+  "homepage": "https://dprint.kjanat.dev",
+  "preferUnplugged": true,
+  "scripts": {
+    "postinstall": "node ./install.cjs"
+  },
+  "optionalDependencies": {
+    "@kprint/kprint-freebsd-x64": "0.60.6",
+    "@kprint/kprint-win32-x64": "0.60.6",
+    "@kprint/kprint-win32-arm64": "0.60.6",
+    "@kprint/kprint-darwin-x64": "0.60.6",
+    "@kprint/kprint-darwin-arm64": "0.60.6",
+    "@kprint/kprint-linux-x64-glibc": "0.60.6",
+    "@kprint/kprint-linux-x64-musl": "0.60.6",
+    "@kprint/kprint-linux-arm64-glibc": "0.60.6",
+    "@kprint/kprint-linux-arm64-musl": "0.60.6",
+    "@kprint/kprint-linux-riscv64-glibc": "0.60.6",
+    "@kprint/kprint-linux-loong64-glibc": "0.60.6",
+    "@kprint/kprint-linux-loong64-musl": "0.60.6",
+    "@kprint/kprint-linux-ppc64-glibc": "0.60.6",
+    "@kprint/kprint-linux-ppc64-musl": "0.60.6",
+    "@kprint/kprint-android-arm64": "0.60.6",
+    "@kprint/kprint-android-x64": "0.60.6"
+  }
+}