node-ipconfig 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 node-ipconfig contributors
+
+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,135 @@
-# Temporary Holding Version
+# node-ipconfig
 
-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.
+Promise-based JavaScript access to Windows network configuration through the native `ipconfig.exe`. It has no runtime dependencies and never invokes a shell. Parsed configuration is returned as a JavaScript object by default (ready to use as JSON); you can also serialize it as JSON text, XML, YAML, CSV, or NDJSON.
+
+## Requirements and compatibility
+
+- Node.js 18 or newer.
+- Command execution is supported on Windows only. The pure `parseIpconfig(text)` parser runs on Windows, macOS, and Linux.
+- Both ESM and CommonJS package entry points are provided. Public command methods return Promises.
+
+```sh
+npm install node-ipconfig
+```
+
+The command wrapper requires Windows. The parser and output formatters can run on any supported Node.js platform.
+
+## Quick start
+
+### ESM
+
+```js
+import ipconfig from 'node-ipconfig';
+
+const config = await ipconfig.getConfig({ all: true });
+console.log(config.hostname);
+for (const adapter of config.adapters) {
+  console.log(adapter.name, adapter.ipv4, adapter.ipv6);
+}
+```
+
+Select a serialized format when an integration needs a document rather than a JavaScript object:
+
+```js
+const xml = await ipconfig.getConfig({ all: true, format: 'xml' });
+const yaml = await ipconfig.getConfig({ all: true, format: 'yaml' });
+const csv = await ipconfig.getConfig({ all: true, format: 'csv' });
+```
+
+### CommonJS
+
+```js
+const ipconfig = require('node-ipconfig');
+
+async function main() {
+  const adapters = await ipconfig.getAdapters({ all: true });
+  console.log(await ipconfig.getIPv4());
+}
+main().catch(console.error);
+```
+
+## API
+
+Configuration methods accept `QueryOptions`: `all` (boolean, defaults to false), `timeout` (positive milliseconds, defaults to 15000), `signal` (`AbortSignal`), `encoding` (Node.js encoding name, defaults to UTF-8), and `rawResult` (boolean). `getConfig` additionally accepts `format`. Unknown keys and invalid values throw `TypeError`.
+
+- `getConfig(options?)` runs `ipconfig` or `/all` and returns a `Config` object by default (`format: 'json'`). Supported formats are `json`, `xml`, `yaml`, `csv`, and `ndjson`. JSON returns the object; the other formats return a string. CSV has one row per adapter, with nested arrays and objects encoded as JSON cells. NDJSON emits one adapter record per line, including the hostname when available.
+- `getRawOutput(options?)` returns stdout as a string. With `{ rawResult: true }`, it returns `{ stdout, stderr, exitCode }`.
+- `getAdapters(options?)` returns `Adapter[]`.
+- `getAdapter(nameOrIndex, options?)` returns one adapter; string matching is case-insensitive and the numeric index is zero-based. Missing adapters reject with `IpconfigError` code `ENOADAPTER`.
+- `getIPv4()` / `getIPv6()` return flat arrays of address strings from detailed configuration.
+- `getDefaultGateway()` / `getDnsServers()` return arrays of `{ adapter, address }` records.
+- `getMacAddresses()` returns `{ adapter, address }` records for adapters with a physical address.
+- `getHostname()` returns the host name reported by Node.js `os.hostname()`.
+- `parseIpconfig(text)` synchronously parses captured text without running a process.
+- `createIpconfig(options?)` creates an isolated API instance; its `platform` and `exec` options support testing with a mocked process runner.
+- `execute(command, options?)` permits only the command names listed below. It returns stdout, or the execution result when `rawResult: true`.
+
+### Output formats
+
+```js
+const config = await ipconfig.getConfig(); // Config object (default JSON data)
+const jsonText = JSON.stringify(config, null, 2);
+const xml = await ipconfig.getConfig({ format: 'xml' });
+const yaml = await ipconfig.getConfig({ format: 'yaml' });
+const csv = await ipconfig.getConfig({ format: 'csv' });
+const lines = await ipconfig.getConfig({ format: 'ndjson' });
+```
+
+The formatter preserves the parsed configuration fields. XML values are escaped. YAML is emitted as a YAML document. CSV uses a header row and one row per adapter; complex values are JSON-encoded in their cells. NDJSON emits one JSON adapter record per line. The original native text is available separately through `getRawOutput()`.
+
+### Data schema
+
+`Config` is `{ hostname?: string, adapters: Adapter[] }`. Adapter fields include `name`, `type`, `addresses: IpAddress[]`, `ipv4: string[]`, `ipv6: string[]`, `dnsServers: string[]`, `defaultGateways: string[]`, and `connectionSpecificDnsSuffix` (string or `null`). When available, adapters also include `description`, `macAddress`, `subnetMask`, `ipv4PrefixLength`, `dhcpEnabled`, `autoconfigurationEnabled`, `dhcpServer`, `leaseObtained`, `leaseExpires`, and `mediaState`. Unknown labeled fields are preserved in `fields`. Older scalar fields such as `ipv4Address` and `ipv6Address` remain available for compatibility; when multiple addresses exist, those scalars contain the last parsed address. `IpAddress` contains `address`, `family` (4 or 6), and optional `scope` or `prefixLength`.
+
+## Commands and side effects
+
+`execute` accepts `config`, `all`, `release`, `release6`, `renew`, `renew6`, `flushdns`, `displaydns`, `registerdns`, `showclassid`, `setclassid`, `showclassid6`, or `setclassid6`. Command options are limited to `timeout`, `signal`, `encoding`, `rawResult`, plus `adapter` where needed and `classId` for `setclassid` variants. Adapter names and class IDs are passed as distinct process arguments and reject control characters and slash-prefixed option injection.
+
+Convenience methods include `flushDns(options?)`, `displayDns(options?)`, `registerDns(options?)`, `release(options?)`, and `renew(options?)`. `release` and `renew` accept optional `{ adapter, ipv6 }`; IPv6 selects `/release6` or `/renew6`. `showClassId({ adapter })`, `setClassId({ adapter, classId? })`, and their `...6` counterparts wrap class ID operations.
+
+Configuration reads, `/displaydns`, and `/showclassid` are read-only. `/flushdns` clears the DNS resolver cache. `/registerdns`, DHCP release/renew, and class ID setting can change network state. Those commands are only run when the corresponding method or `execute` call is explicitly invoked; discovery never runs them. DHCP operations can briefly interrupt connectivity. Windows permissions may vary; run an appropriately authorized terminal when Windows denies an operation.
+
+| JavaScript method | Native command | Effect |
+| --- | --- | --- |
+| `getConfig()` / `getRawOutput()` | `ipconfig` | Read current configuration |
+| `{ all: true }` | `ipconfig /all` | Read detailed adapter configuration |
+| `flushDns()` | `ipconfig /flushdns` | Clear DNS resolver cache |
+| `displayDns()` / `getDnsCache()` | `ipconfig /displaydns` | Read cached DNS records |
+| `registerDns()` | `ipconfig /registerdns` | Refresh DHCP leases and register DNS names |
+| `release({ adapter?, ipv6? })` | `/release` or `/release6` | Release DHCP configuration; may interrupt connectivity |
+| `renew({ adapter?, ipv6? })` | `/renew` or `/renew6` | Renew DHCP configuration; may interrupt connectivity |
+| `showClassId({ adapter })` / `showClassId6(...)` | `/showclassid` or `/showclassid6` | Read DHCP class ID |
+| `setClassId({ adapter, classId? })` / `setClassId6(...)` | `/setclassid` or `/setclassid6` | Change DHCP class ID |
+
+You may also call `execute` with an allowlisted command name (`config`, `all`, `release`, `release6`, `renew`, `renew6`, `flushdns`, `displaydns`, `registerdns`, `showclassid`, `setclassid`, `showclassid6`, `setclassid6`). Commands that change system state are never run during discovery.
+
+## Raw output, encoding, and localization
+
+`getRawOutput()` preserves the decoded command text, while `rawResult: true` also returns stderr and exit code. The default decoder is UTF-8; set `encoding` to a Node-supported encoding when the machine's OEM code page requires it. This avoids extra code-page dependencies, but callers must know the output encoding for their system. The parser recognizes common English, German, and Spanish labels, common adapter header forms, and preserves unknown labeled values. Windows localization and version changes mean parsing is best effort; use raw output when exact text matters.
+
+## Errors and security
+
+Unsupported operating systems reject with `IpconfigError` code `ENOTSUP`. Process startup, permission, timeout, cancellation, and command errors reject with `IpconfigError`, including available command, stdout, stderr, exit code, and cause details. A command can emit useful output alongside a non-zero exit status; that text is returned, and `{ rawResult: true }` exposes the exit code. No API accepts arbitrary command strings or starts a shell. All executable arguments come from a fixed allowlist and validated values.
+
+## Examples
+
+Runnable ESM example: [`examples/basic.js`](examples/basic.js).
+
+For full API details, configuration fields, output format behavior, command effects, options, and errors, see the [API guide](docs/API.md).
+
+```js
+const gateways = await ipconfig.getDefaultGateway();
+const dns = await ipconfig.getDnsServers();
+const wifi = await ipconfig.getAdapter('Wi-Fi');
+const raw = await ipconfig.getRawOutput({ all: true });
+
+// Explicit operations: these can change machine state.
+await ipconfig.flushDns();
+await ipconfig.renew({ adapter: wifi.name });
+```
+
+## Development
+
+`npm test` runs the platform-independent mocked suite. `npm run lint` performs JavaScript syntax checks, and `npm run typecheck` checks the published declarations with TypeScript. CI runs the suite on Windows, Linux, and macOS for supported Node.js releases.
+
+MIT licensed; see [LICENSE](LICENSE).

package/docs/API.md

@@ -0,0 +1,134 @@
+# API guide
+
+`node-ipconfig` wraps Windows `ipconfig.exe`. Its command methods return Promises and require Windows; `parseIpconfig()` and the format examples can be used on any supported Node.js platform. The package has no runtime dependencies.
+
+## Install
+
+```sh
+npm install node-ipconfig
+```
+
+Requires Node.js 18 or newer.
+
+## Get started
+
+### ECMAScript modules
+
+```js
+import ipconfig from 'node-ipconfig';
+
+const config = await ipconfig.getConfig({ all: true });
+console.log(config.hostname);
+for (const adapter of config.adapters) {
+  console.log(adapter.name, adapter.ipv4, adapter.ipv6);
+}
+```
+
+### CommonJS
+
+```js
+const ipconfig = require('node-ipconfig');
+
+async function main() {
+  const adapters = await ipconfig.getAdapters({ all: true });
+  console.log(adapters);
+}
+main().catch(console.error);
+```
+
+## Configuration and formats
+
+`getConfig(options?)` executes `ipconfig` and parses its output. Set `all: true` to execute `ipconfig /all`. By default it returns a JavaScript `Config` object (JSON-compatible data):
+
+```js
+const config = await ipconfig.getConfig();
+const detailed = await ipconfig.getConfig({ all: true });
+```
+
+Set `format` to serialize the parsed configuration. JSON is the default and remains an object; the other formats return strings.
+
+```js
+const jsonData = await ipconfig.getConfig({ format: 'json' });
+const xml = await ipconfig.getConfig({ all: true, format: 'xml' });
+const yaml = await ipconfig.getConfig({ all: true, format: 'yaml' });
+const csv = await ipconfig.getConfig({ all: true, format: 'csv' });
+const ndjson = await ipconfig.getConfig({ all: true, format: 'ndjson' });
+```
+
+CSV has one row per adapter; nested values are JSON-encoded in cells. NDJSON has one adapter record per line. XML values are escaped. YAML is emitted as a YAML document. Supported format names are `json`, `xml`, `yaml`, `csv`, and `ndjson`; unsupported names throw `TypeError`.
+
+`getRawOutput(options?)` returns the original decoded text. Set `rawResult: true` to receive `{ stdout, stderr, exitCode }` instead.
+
+## Discovery methods
+
+| Method | Result |
+| --- | --- |
+| `getConfig(options?)` | Parsed configuration, or serialized output when a non-JSON format is selected |
+| `getAdapters(options?)` | Adapter array |
+| `getAdapter(nameOrIndex, options?)` | One adapter by case-insensitive name or zero-based index |
+| `getIPv4()` / `getIPv6()` | Flat arrays of IP address strings |
+| `getDefaultGateway()` | `{ adapter, address }` records |
+| `getDnsServers()` | `{ adapter, address }` records |
+| `getMacAddresses()` | `{ adapter, address }` records |
+| `getHostname()` | Host name from Node.js `os.hostname()` |
+| `getRawOutput(options?)` | Native command output as text or execution result |
+| `parseIpconfig(text)` | Synchronous parser for captured output; no command execution |
+
+Detailed fields include adapter type and description, MAC address, IPv4 and IPv6 addresses, subnet mask and prefix length, gateways, DNS servers, DHCP and autoconfiguration state, DHCP server, lease timestamps, media state, and preserved unknown labeled fields. Parsing recognizes common English, German, and Spanish labels; it is best-effort across Windows versions and locales.
+
+## Options
+
+Configuration queries accept:
+
+- `all`: boolean, defaults to `false`.
+- `format`: `json`, `xml`, `yaml`, `csv`, or `ndjson`; only supported by `getConfig` and defaults to `json`.
+- `timeout`: positive milliseconds, defaults to 15000.
+- `signal`: `AbortSignal` to cancel execution.
+- `encoding`: Node.js text encoding, defaults to `utf8`.
+- `rawResult`: return `{ stdout, stderr, exitCode }` for raw command methods.
+
+Unknown options and invalid values throw `TypeError`.
+
+## Explicit commands
+
+Operations that change network state are only executed when called explicitly. `execute(command, options?)` accepts the allowlisted names below; it never accepts arbitrary command text.
+
+| Method | `execute` name / native switch | Notes |
+| --- | --- | --- |
+| `execute('config')` | `ipconfig` | Read current configuration |
+| `execute('all')` | `/all` | Detailed configuration |
+| `flushDns()` | `/flushdns` | Clears the DNS resolver cache |
+| `displayDns()` / `getDnsCache()` | `/displaydns` | Displays cached DNS records |
+| `registerDns()` | `/registerdns` | Initiates manual DNS registration |
+| `release(options?)` | `/release` or `/release6` | Releases DHCP configuration; may interrupt connectivity |
+| `renew(options?)` | `/renew` or `/renew6` | Renews DHCP configuration; may interrupt connectivity |
+| `showClassId({ adapter })` | `/showclassid` | Displays a DHCP class ID |
+| `setClassId({ adapter, classId? })` | `/setclassid` | Sets or clears a DHCP class ID |
+| `showClassId6({ adapter })` | `/showclassid6` | IPv6 class ID operation |
+| `setClassId6({ adapter, classId? })` | `/setclassid6` | Sets or clears an IPv6 class ID |
+
+`release()` and `renew()` accept `{ adapter, ipv6 }`; set `ipv6: true` to choose the IPv6 command. `adapter` and `classId` values are passed as separate process arguments, not through a shell. Read-only discovery never runs a state-changing command.
+
+Run release, renew, DNS registration, and class ID changes only when their effects are appropriate. DHCP release/renew can disrupt connectivity. Windows may require an appropriately authorized terminal for some operations.
+
+## Errors and platform support
+
+Command methods reject with `IpconfigError`. Its `code` identifies unsupported platforms (`ENOTSUP`), missing executables (`ENOENT`), permissions (`EACCES`), timeouts (`ETIMEDOUT`), cancellation (`ABORT_ERR`), or command failures. Available command, stdout, stderr, exit code, and cause are attached to the error. Unsupported option names, command names, or argument values throw `TypeError`.
+
+## Testing with a custom runner
+
+`createIpconfig()` makes the command runner injectable for tests:
+
+```js
+import { createIpconfig } from 'node-ipconfig';
+
+const api = createIpconfig({
+  platform: 'win32',
+  exec(file, args, options, callback) {
+    callback(null, 'Windows IP Configuration', '');
+  }
+});
+const config = await api.getConfig();
+```
+
+The parser can also be tested directly with fixture text, without mocking or requiring Windows.

package/package.json

@@ -1,6 +1,38 @@
-{
-  "name": "node-ipconfig",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "node-ipconfig",
+  "version": "1.0.0",
+  "description": "A safe JavaScript API for Windows ipconfig output",
+  "license": "MIT",
+  "type": "module",
+  "main": "./src/index.cjs",
+  "module": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "import": { "types": "./src/index.d.ts", "default": "./src/index.js" },
+      "require": { "types": "./src/index.d.cts", "default": "./src/index.cjs" }
+    },
+    "./parser": {
+      "import": { "types": "./src/parser.d.ts", "default": "./src/parser.js" },
+      "require": {
+        "types": "./src/parser.d.cts",
+        "default": "./src/parser.cjs"
+      }
+    }
+  },
+  "files": ["src", "docs", "README.md", "LICENSE"],
+  "engines": { "node": ">=18" },
+  "scripts": {
+    "test": "node --test",
+    "test:coverage": "node --experimental-test-coverage --test",
+    "lint": "node --check src/index.js && node --check src/parser.js && node --check src/command.js && node --check test/ipconfig.test.js && node --check examples/basic.js",
+    "typecheck": "tsc --noEmit --strict --skipLibCheck --target ES2022 --module NodeNext --moduleResolution NodeNext src/index.d.ts src/index.d.cts src/parser.d.ts src/parser.d.cts"
+  },
+  "keywords": ["ipconfig", "windows", "network", "configuration", "dns"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aymen94/node-ipconfig.git"
+  },
+  "bugs": { "url": "https://github.com/aymen94/node-ipconfig/issues" },
+  "homepage": "https://github.com/aymen94/node-ipconfig#readme"
+}

package/src/command.js

@@ -0,0 +1,117 @@
+import { execFile } from "node:child_process";
+
+export class IpconfigError extends Error {
+  constructor(
+    message,
+    {
+      code = "EIPCONFIG",
+      cause,
+      command,
+      stdout = "",
+      stderr = "",
+      exitCode,
+    } = {},
+  ) {
+    super(message, { cause });
+    this.name = "IpconfigError";
+    this.code = code;
+    if (command) this.command = command;
+    this.stdout = stdout;
+    this.stderr = stderr;
+    if (exitCode !== undefined) this.exitCode = exitCode;
+  }
+}
+
+export function createRunner({
+  platform = process.platform,
+  exec = execFile,
+} = {}) {
+  return function run(args = [], options = {}) {
+    if (platform !== "win32")
+      return Promise.reject(
+        new IpconfigError("node-ipconfig is supported only on Windows.", {
+          code: "ENOTSUP",
+        }),
+      );
+    return new Promise((resolve, reject) => {
+      const command = ["ipconfig.exe", ...args];
+      const finish = (error, stdout = "", stderr = "") => {
+        const output =
+          typeof stdout === "string"
+            ? stdout
+            : stdout?.toString(options.encoding ?? "utf8");
+        const errorOutput =
+          typeof stderr === "string"
+            ? stderr
+            : stderr?.toString(options.encoding ?? "utf8");
+        const exitCode = Number.isInteger(error?.code)
+          ? error.code
+          : error
+            ? null
+            : 0;
+        // Some ipconfig commands emit useful localized diagnostics and a non-zero exit status.
+        if (
+          error &&
+          !output?.trim() &&
+          !(options.rawResult && Number.isInteger(error.code))
+        ) {
+          const code =
+            error.code === "EACCES" || error.code === "EPERM"
+              ? "EACCES"
+              : error.code === "ENOENT"
+                ? "ENOENT"
+                : error.code === "ETIMEDOUT" ||
+                    (error.killed && options.timeout)
+                  ? "ETIMEDOUT"
+                  : error.name === "AbortError"
+                    ? "ABORT_ERR"
+                    : (error.code ?? "EIPCONFIG");
+          const message =
+            code === "EACCES"
+              ? "Permission denied while running ipconfig; retry from an appropriately authorized terminal."
+              : code === "ENOENT"
+                ? "ipconfig.exe could not be found on PATH."
+                : code === "ETIMEDOUT"
+                  ? "ipconfig timed out; increase timeout or retry."
+                  : code === "ABORT_ERR"
+                    ? "ipconfig was aborted."
+                    : `ipconfig failed${error.message ? `: ${error.message}` : ""}`;
+          reject(
+            new IpconfigError(message, {
+              code,
+              cause: error,
+              command,
+              stdout: output ?? "",
+              stderr: errorOutput ?? "",
+              exitCode: exitCode ?? undefined,
+            }),
+          );
+          return;
+        }
+        if (options.rawResult)
+          resolve({
+            stdout: output ?? "",
+            stderr: errorOutput ?? "",
+            exitCode: exitCode ?? 0,
+          });
+        else resolve((output ?? "") || (errorOutput ?? ""));
+      };
+      try {
+        exec(
+          "ipconfig.exe",
+          args,
+          {
+            windowsHide: true,
+            encoding: options.encoding ?? "utf8",
+            timeout: options.timeout ?? 15000,
+            maxBuffer: 4 * 1024 * 1024,
+            ...(options.signal ? { signal: options.signal } : {}),
+          },
+          finish,
+        );
+      } catch (error) {
+        finish(error);
+      }
+    });
+  };
+}

package/src/format.js

@@ -0,0 +1,119 @@
+const FORMATS = new Set(["json", "xml", "yaml", "csv", "ndjson"]);
+
+function escapeXml(value) {
+  return String(value).replace(
+    /[<>&"']/g,
+    (character) =>
+      ({
+        "<": "&lt;",
+        ">": "&gt;",
+        "&": "&amp;",
+        '"': "&quot;",
+        "'": "&apos;",
+      })[character],
+  );
+}
+
+function xmlNode(name, value) {
+  if (Array.isArray(value))
+    return `<${name}>${value.map((item) => xmlNode("item", item)).join("")}</${name}>`;
+  if (value && typeof value === "object")
+    return `<${name}>${Object.entries(value)
+      .map(([key, item]) =>
+        xmlNode(key.replace(/[^A-Za-z0-9_.-]/g, "_") || "field", item),
+      )
+      .join("")}</${name}>`;
+  return `<${name}>${escapeXml(value ?? "")}</${name}>`;
+}
+
+function yamlScalar(value) {
+  if (value === null) return "null";
+  if (typeof value === "string") return JSON.stringify(value);
+  return String(value);
+}
+
+function yamlLines(value, indent = 0) {
+  const pad = " ".repeat(indent);
+  if (Array.isArray(value))
+    return value.length
+      ? value.flatMap((item) => {
+          if (item && typeof item === "object") {
+            const lines = yamlLines(item, indent + 2);
+            return [
+              `${pad}- ${lines[0]?.trimStart() ?? "{}"}`,
+              ...lines.slice(1),
+            ];
+          }
+          return [`${pad}- ${yamlScalar(item)}`];
+        })
+      : [`${pad}[]`];
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value);
+    return entries.length
+      ? entries.flatMap(([key, item]) => {
+          const safeKey = /^[A-Za-z_][\w.-]*$/.test(key)
+            ? key
+            : JSON.stringify(key);
+          if (item && typeof item === "object")
+            return [`${pad}${safeKey}:`, ...yamlLines(item, indent + 2)];
+          return [`${pad}${safeKey}: ${yamlScalar(item)}`];
+        })
+      : [`${pad}{}`];
+  }
+  return [`${pad}${yamlScalar(value)}`];
+}
+
+function csvCell(value) {
+  const text =
+    value == null
+      ? ""
+      : typeof value === "object"
+        ? JSON.stringify(value)
+        : String(value);
+  return /[",\r\n]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+
+/** Format a parsed configuration as JSON data or a serialized JSON, XML, YAML, CSV, or NDJSON document. */
+export function formatConfig(config, format = "json") {
+  if (!FORMATS.has(format))
+    throw new TypeError(
+      `Unsupported format: ${format}. Choose json, xml, yaml, csv, or ndjson.`,
+    );
+  if (format === "json") return config;
+  if (format === "xml")
+    return `<?xml version="1.0" encoding="UTF-8"?>\n${xmlNode("config", config)}`;
+  if (format === "yaml") return `${yamlLines(config).join("\n")}\n`;
+  if (format === "ndjson")
+    return `${config.adapters.map((adapter) => JSON.stringify({ ...(config.hostname ? { hostname: config.hostname } : {}), adapter })).join("\n")}${config.adapters.length ? "\n" : ""}`;
+  const columns = [
+    "name",
+    "type",
+    "description",
+    "macAddress",
+    "ipv4",
+    "ipv6",
+    "subnetMask",
+    "ipv4PrefixLength",
+    "defaultGateways",
+    "dnsServers",
+    "dhcpEnabled",
+    "autoconfigurationEnabled",
+    "dhcpServer",
+    "leaseObtained",
+    "leaseExpires",
+    "connectionSpecificDnsSuffix",
+    "mediaState",
+    "addresses",
+    "fields",
+  ];
+  return (
+    [
+      columns.join(","),
+      ...config.adapters.map((adapter) =>
+        columns.map((key) => csvCell(adapter[key])).join(","),
+      ),
+    ].join("\r\n") + "\r\n"
+  );
+}
+
+export const CONFIG_FORMATS = Object.freeze([...FORMATS]);

package/src/index.cjs

@@ -0,0 +1,64 @@
+"use strict";
+const load = () => import("./index.js");
+const api = {};
+for (const name of [
+  "execute",
+  "getRawOutput",
+  "getConfig",
+  "getAdapters",
+  "getAdapter",
+  "getIPv4",
+  "getIPv6",
+  "getDefaultGateway",
+  "getDnsServers",
+  "getMacAddresses",
+  "getHostname",
+  "release",
+  "renew",
+  "flushDns",
+  "getDnsCache",
+  "displayDns",
+  "registerDns",
+  "showClassId",
+  "setClassId",
+  "showClassId6",
+  "setClassId6",
+]) {
+  api[name] = (...args) =>
+    load().then(({ ipconfig }) => ipconfig[name](...args));
+}
+api.parseIpconfig = (...args) =>
+  load().then(({ parseIpconfig }) => parseIpconfig(...args));
+api.createIpconfig = (options) => {
+  const instance = {};
+  for (const name of [
+    "execute",
+    "getRawOutput",
+    "getConfig",
+    "getAdapters",
+    "getAdapter",
+    "getIPv4",
+    "getIPv6",
+    "getDefaultGateway",
+    "getDnsServers",
+    "getMacAddresses",
+    "getHostname",
+    "release",
+    "renew",
+    "flushDns",
+    "getDnsCache",
+    "displayDns",
+    "registerDns",
+    "showClassId",
+    "setClassId",
+    "showClassId6",
+    "setClassId6",
+  ]) {
+    instance[name] = (...args) =>
+      load().then(({ createIpconfig }) =>
+        createIpconfig(options)[name](...args),
+      );
+  }
+  return instance;
+};
+module.exports = api;

package/src/index.d.cts

@@ -0,0 +1,92 @@
+declare namespace nodeIpconfig {
+  interface QueryOptions {
+    all?: boolean;
+    timeout?: number;
+    signal?: AbortSignal;
+    encoding?: BufferEncoding;
+    rawResult?: boolean;
+  }
+  type ConfigFormat = "json" | "xml" | "yaml" | "csv" | "ndjson";
+  interface ConfigOptions extends QueryOptions {
+    format?: ConfigFormat;
+  }
+  interface ExecutionOptions {
+    timeout?: number;
+    signal?: AbortSignal;
+    encoding?: BufferEncoding;
+    rawResult?: boolean;
+  }
+  interface Adapter {
+    name: string;
+    type: string;
+    addresses: Array<{
+      address: string;
+      family: 4 | 6;
+      scope?: string;
+      prefixLength?: number;
+    }>;
+    ipv4: string[];
+    ipv6: string[];
+    dnsServers: string[];
+    defaultGateways: string[];
+    [field: string]: unknown;
+  }
+  interface Config {
+    hostname?: string;
+    adapters: Adapter[];
+  }
+  interface Result {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+  }
+  interface Api {
+    execute(
+      command: string,
+      options?: ExecutionOptions & { adapter?: string; classId?: string },
+    ): Promise<string | Result>;
+    getRawOutput(options?: QueryOptions): Promise<string | Result>;
+    getConfig<F extends ConfigFormat = "json">(
+      options?: ConfigOptions & { format?: F },
+    ): Promise<F extends "json" ? Config : string>;
+    getAdapters(options?: QueryOptions): Promise<Adapter[]>;
+    getAdapter(
+      nameOrIndex: string | number,
+      options?: QueryOptions,
+    ): Promise<Adapter>;
+    getIPv4(): Promise<string[]>;
+    getIPv6(): Promise<string[]>;
+    getDefaultGateway(): Promise<Array<{ adapter: string; address: string }>>;
+    getDnsServers(): Promise<Array<{ adapter: string; address: string }>>;
+    getMacAddresses(): Promise<Array<{ adapter: string; address: string }>>;
+    getHostname(): Promise<string>;
+    flushDns(options?: ExecutionOptions): Promise<string | Result>;
+    displayDns(options?: ExecutionOptions): Promise<string | Result>;
+    getDnsCache(options?: ExecutionOptions): Promise<string | Result>;
+    registerDns(options?: ExecutionOptions): Promise<string | Result>;
+    release(
+      options?: ExecutionOptions & { adapter?: string; ipv6?: boolean },
+    ): Promise<string | Result>;
+    renew(
+      options?: ExecutionOptions & { adapter?: string; ipv6?: boolean },
+    ): Promise<string | Result>;
+    showClassId(
+      options: ExecutionOptions & { adapter: string },
+    ): Promise<string | Result>;
+    setClassId(
+      options: ExecutionOptions & { adapter: string; classId?: string },
+    ): Promise<string | Result>;
+    showClassId6(
+      options: ExecutionOptions & { adapter: string },
+    ): Promise<string | Result>;
+    setClassId6(
+      options: ExecutionOptions & { adapter: string; classId?: string },
+    ): Promise<string | Result>;
+  }
+  interface Module extends Api {
+    parseIpconfig(output: string): Promise<Config>;
+    createIpconfig(options?: { platform?: string; exec?: Function }): Api;
+  }
+}
+declare const api: nodeIpconfig.Module;
+export = api;

package/src/index.d.ts

@@ -0,0 +1,132 @@
+export type AddressFamily = 4 | 6;
+export interface IpAddress {
+  address: string;
+  family: AddressFamily;
+  scope?: "link-local";
+  prefixLength?: number;
+}
+export interface Adapter {
+  name: string;
+  type: string;
+  description?: string;
+  macAddress?: string;
+  addresses: IpAddress[];
+  ipv4: string[];
+  ipv6: string[];
+  ipv4Address?: string;
+  ipv6Address?: string;
+  linkLocalIpv6Address?: string;
+  subnetMask?: string;
+  ipv4PrefixLength?: number;
+  defaultGateways: string[];
+  dnsServers: string[];
+  dhcpEnabled?: boolean | string;
+  autoconfigurationEnabled?: boolean | string;
+  dhcpServer?: string;
+  leaseObtained?: string;
+  leaseExpires?: string;
+  connectionSpecificDnsSuffix: string | null;
+  mediaState?: string;
+  fields?: Record<string, string>;
+  [field: string]: unknown;
+}
+export interface Config {
+  hostname?: string;
+  adapters: Adapter[];
+}
+export type ConfigFormat = "json" | "xml" | "yaml" | "csv" | "ndjson";
+export type FormattedConfig<F extends ConfigFormat> = F extends "json"
+  ? Config
+  : string;
+export interface ExecutionOptions {
+  timeout?: number;
+  signal?: AbortSignal;
+  encoding?: BufferEncoding;
+  rawResult?: boolean;
+}
+export interface QueryOptions extends ExecutionOptions {
+  all?: boolean;
+}
+export interface ConfigOptions extends QueryOptions {
+  format?: ConfigFormat;
+}
+export interface CommandOptions extends ExecutionOptions {
+  adapter?: string;
+  classId?: string;
+}
+export type IpconfigCommand =
+  | "config"
+  | "all"
+  | "release"
+  | "release6"
+  | "renew"
+  | "renew6"
+  | "flushdns"
+  | "displaydns"
+  | "registerdns"
+  | "showclassid"
+  | "setclassid"
+  | "showclassid6"
+  | "setclassid6";
+export interface ExecutionResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+export class IpconfigError extends Error {
+  code: string;
+  command?: string[];
+  stdout: string;
+  stderr: string;
+  exitCode?: number;
+}
+export function parseIpconfig(output: string): Config;
+export function createIpconfig(options?: {
+  platform?: NodeJS.Platform | string;
+  exec?: Function;
+}): IpconfigApi;
+export interface IpconfigApi {
+  execute(
+    command: IpconfigCommand,
+    options?: CommandOptions,
+  ): Promise<string | ExecutionResult>;
+  getRawOutput(options?: QueryOptions): Promise<string | ExecutionResult>;
+  getConfig<F extends ConfigFormat = "json">(
+    options?: ConfigOptions & { format?: F },
+  ): Promise<FormattedConfig<F>>;
+  getAdapters(options?: QueryOptions): Promise<Adapter[]>;
+  getAdapter(
+    nameOrIndex: string | number,
+    options?: QueryOptions,
+  ): Promise<Adapter>;
+  getIPv4(): Promise<string[]>;
+  getIPv6(): Promise<string[]>;
+  getDefaultGateway(): Promise<Array<{ adapter: string; address: string }>>;
+  getDnsServers(): Promise<Array<{ adapter: string; address: string }>>;
+  getMacAddresses(): Promise<Array<{ adapter: string; address: string }>>;
+  getHostname(): Promise<string>;
+  flushDns(options?: ExecutionOptions): Promise<string | ExecutionResult>;
+  displayDns(options?: ExecutionOptions): Promise<string | ExecutionResult>;
+  getDnsCache(options?: ExecutionOptions): Promise<string | ExecutionResult>;
+  registerDns(options?: ExecutionOptions): Promise<string | ExecutionResult>;
+  release(
+    options?: ExecutionOptions & { adapter?: string; ipv6?: boolean },
+  ): Promise<string | ExecutionResult>;
+  renew(
+    options?: ExecutionOptions & { adapter?: string; ipv6?: boolean },
+  ): Promise<string | ExecutionResult>;
+  showClassId(
+    options: ExecutionOptions & { adapter: string },
+  ): Promise<string | ExecutionResult>;
+  setClassId(
+    options: ExecutionOptions & { adapter: string; classId?: string },
+  ): Promise<string | ExecutionResult>;
+  showClassId6(
+    options: ExecutionOptions & { adapter: string },
+  ): Promise<string | ExecutionResult>;
+  setClassId6(
+    options: ExecutionOptions & { adapter: string; classId?: string },
+  ): Promise<string | ExecutionResult>;
+}
+export const ipconfig: IpconfigApi;
+export default ipconfig;

package/src/index.js

@@ -0,0 +1,244 @@
+import { hostname as systemHostname } from "node:os";
+import { createRunner, IpconfigError } from "./command.js";
+import { parseIpconfig } from "./parser.js";
+import { formatConfig } from "./format.js";
+
+const EXECUTION_OPTIONS = new Set([
+  "timeout",
+  "signal",
+  "encoding",
+  "rawResult",
+]);
+const QUERY_OPTIONS = new Set([...EXECUTION_OPTIONS, "all"]);
+const CONFIG_OPTIONS = new Set([...QUERY_OPTIONS, "format"]);
+const COMMANDS = Object.freeze({
+  config: [],
+  all: ["/all"],
+  release: ["/release"],
+  release6: ["/release6"],
+  renew: ["/renew"],
+  renew6: ["/renew6"],
+  flushdns: ["/flushdns"],
+  displaydns: ["/displaydns"],
+  registerdns: ["/registerdns"],
+  showclassid: ["/showclassid"],
+  setclassid: ["/setclassid"],
+  showclassid6: ["/showclassid6"],
+  setclassid6: ["/setclassid6"],
+});
+
+function validateOptions(options, allowed) {
+  if (options === undefined) options = {};
+  if (!options || typeof options !== "object" || Array.isArray(options))
+    throw new TypeError("options must be an object");
+  for (const key of Object.keys(options))
+    if (!allowed.has(key)) throw new TypeError(`Unsupported option: ${key}`);
+  if (
+    options.timeout !== undefined &&
+    (!Number.isInteger(options.timeout) || options.timeout <= 0)
+  )
+    throw new TypeError("timeout must be a positive integer");
+  if (
+    options.signal !== undefined &&
+    (typeof options.signal !== "object" ||
+      typeof options.signal.aborted !== "boolean")
+  )
+    throw new TypeError("signal must be an AbortSignal");
+  if (options.encoding !== undefined && typeof options.encoding !== "string")
+    throw new TypeError("encoding must be a supported Node.js encoding name");
+  if (options.rawResult !== undefined && typeof options.rawResult !== "boolean")
+    throw new TypeError("rawResult must be a boolean");
+  return options;
+}
+
+function queryOptions(options) {
+  validateOptions(options, QUERY_OPTIONS);
+  if (options.all !== undefined && typeof options.all !== "boolean")
+    throw new TypeError("all must be a boolean");
+  const { all, ...execution } = options;
+  return {
+    args: all ? ["/all"] : [],
+    execution: { ...execution, rawResult: false },
+  };
+}
+
+function adapterArgument(value, label = "adapter") {
+  if (
+    typeof value !== "string" ||
+    !value.trim() ||
+    value.length > 256 ||
+    /[\0\r\n]/.test(value) ||
+    value.trim().startsWith("/")
+  ) {
+    throw new TypeError(
+      `${label} must be a non-empty adapter name without control characters or option prefixes`,
+    );
+  }
+  return value.trim();
+}
+function classIdArgument(value) {
+  if (
+    typeof value !== "string" ||
+    value.length > 256 ||
+    /[\0\r\n]/.test(value) ||
+    value.startsWith("/")
+  ) {
+    throw new TypeError(
+      "classId must be a string without control characters or option prefixes",
+    );
+  }
+  return value;
+}
+function commandOptions(options, command) {
+  const adapterAllowed = [
+    "release",
+    "release6",
+    "renew",
+    "renew6",
+    "showclassid",
+    "setclassid",
+    "showclassid6",
+    "setclassid6",
+  ].includes(command);
+  const classIdAllowed = ["setclassid", "setclassid6"].includes(command);
+  validateOptions(
+    options,
+    new Set([
+      ...EXECUTION_OPTIONS,
+      ...(adapterAllowed ? ["adapter"] : []),
+      ...(classIdAllowed ? ["classId"] : []),
+    ]),
+  );
+  const args = [...COMMANDS[command]];
+  if (
+    ["release", "release6", "renew", "renew6"].includes(command) &&
+    options.adapter !== undefined
+  )
+    args.push(adapterArgument(options.adapter));
+  if (command === "showclassid" || command === "showclassid6")
+    args.push(adapterArgument(options.adapter));
+  if (command === "setclassid" || command === "setclassid6") {
+    args.push(adapterArgument(options.adapter));
+    if (options.classId !== undefined)
+      args.push(classIdArgument(options.classId));
+  }
+  const { adapter, classId, ...execution } = options;
+  return { args, execution };
+}
+
+function flatten(adapters, field) {
+  return adapters.flatMap((adapter) =>
+    (adapter[field] ?? []).map((address) => ({
+      adapter: adapter.name,
+      address,
+    })),
+  );
+}
+
+export function createIpconfig({ platform = process.platform, exec } = {}) {
+  const run = createRunner({ platform, ...(exec ? { exec } : {}) });
+  async function execute(command, options = {}) {
+    if (typeof command !== "string" || !Object.hasOwn(COMMANDS, command))
+      throw new TypeError(`Unsupported ipconfig command: ${String(command)}`);
+    const { args, execution } = commandOptions(options, command);
+    return run(args, execution);
+  }
+  async function getRawOutput(options = {}) {
+    const { args, execution } = queryOptions(options);
+    return run(args, { ...execution, rawResult: options.rawResult ?? false });
+  }
+  async function getConfig(options = {}) {
+    validateOptions(options, CONFIG_OPTIONS);
+    const { format = "json", ...query } = options;
+    if (!["json", "xml", "yaml", "csv", "ndjson"].includes(format))
+      throw new TypeError(
+        "format must be one of: json, xml, yaml, csv, ndjson",
+      );
+    const { args, execution } = queryOptions(query);
+    const output = await run(args, execution);
+    const config = parseIpconfig(output);
+    config.hostname ??= systemHostname();
+    return formatConfig(config, format);
+  }
+  async function getAdapters(options) {
+    validateOptions(options, QUERY_OPTIONS);
+    return (await getConfig(options)).adapters;
+  }
+  async function getAdapter(nameOrIndex, options) {
+    if (!(typeof nameOrIndex === "string" || Number.isInteger(nameOrIndex)))
+      throw new TypeError(
+        "adapter selector must be a name or zero-based integer index",
+      );
+    const adapters = await getAdapters(options);
+    const found =
+      typeof nameOrIndex === "number"
+        ? adapters[nameOrIndex]
+        : adapters.find(
+            ({ name }) =>
+              name.toLocaleLowerCase() ===
+              nameOrIndex.trim().toLocaleLowerCase(),
+          );
+    if (!found)
+      throw new IpconfigError(`Network adapter not found: ${nameOrIndex}`, {
+        code: "ENOADAPTER",
+      });
+    return found;
+  }
+  async function addresses(family) {
+    return (await getAdapters({ all: true })).flatMap(
+      (adapter) => adapter[family],
+    );
+  }
+  async function release(options = {}) {
+    validateOptions(
+      options,
+      new Set([...EXECUTION_OPTIONS, "adapter", "ipv6"]),
+    );
+    if (options.ipv6 !== undefined && typeof options.ipv6 !== "boolean")
+      throw new TypeError("ipv6 must be a boolean");
+    const { ipv6 = false, ...rest } = options;
+    return execute(ipv6 ? "release6" : "release", rest);
+  }
+  async function renew(options = {}) {
+    validateOptions(
+      options,
+      new Set([...EXECUTION_OPTIONS, "adapter", "ipv6"]),
+    );
+    if (options.ipv6 !== undefined && typeof options.ipv6 !== "boolean")
+      throw new TypeError("ipv6 must be a boolean");
+    const { ipv6 = false, ...rest } = options;
+    return execute(ipv6 ? "renew6" : "renew", rest);
+  }
+  return {
+    execute,
+    getRawOutput,
+    getConfig,
+    getAdapters,
+    getAdapter,
+    getIPv4: async () => addresses("ipv4"),
+    getIPv6: async () => addresses("ipv6"),
+    getDefaultGateway: async () =>
+      flatten(await getAdapters({ all: true }), "defaultGateways"),
+    getDnsServers: async () =>
+      flatten(await getAdapters({ all: true }), "dnsServers"),
+    getMacAddresses: async () =>
+      (await getAdapters({ all: true })).flatMap(({ name, macAddress }) =>
+        macAddress ? [{ adapter: name, address: macAddress }] : [],
+      ),
+    getHostname: async () => systemHostname(),
+    flushDns: (options = {}) => execute("flushdns", options),
+    displayDns: (options = {}) => execute("displaydns", options),
+    registerDns: (options = {}) => execute("registerdns", options),
+    release,
+    renew,
+    showClassId: (options = {}) => execute("showclassid", options),
+    setClassId: (options = {}) => execute("setclassid", options),
+    showClassId6: (options = {}) => execute("showclassid6", options),
+    setClassId6: (options = {}) => execute("setclassid6", options),
+    getDnsCache: (options = {}) => execute("displaydns", options),
+  };
+}
+
+export const ipconfig = createIpconfig();
+export { parseIpconfig, IpconfigError, createRunner };
+export default ipconfig;

package/src/parser.cjs

@@ -0,0 +1,3 @@
+"use strict";
+exports.parseIpconfig = (...args) =>
+  import("./parser.js").then(({ parseIpconfig }) => parseIpconfig(...args));

package/src/parser.d.cts

@@ -0,0 +1,6 @@
+declare const parser: {
+  parseIpconfig(
+    output: string,
+  ): Promise<{ hostname?: string; adapters: unknown[] }>;
+};
+export = parser;

package/src/parser.d.ts

@@ -0,0 +1,2 @@
+import type { Config } from "./index.js";
+export function parseIpconfig(output: string): Config;

package/src/parser.js

@@ -0,0 +1,182 @@
+const LABELS = [
+  ['hostname', /^(?:host name|hostname|computer name|hostname del equipo|nombre de host)$/i],
+  ['description', /^(?:description|beschreibung|descripción)$/i],
+  ['macAddress', /^(?:physical address|physikalische adresse|dirección física|mac address)$/i],
+  ['dhcpEnabled', /^(?:dhcp enabled|dhcp aktiviert|dhcp habilitado)$/i],
+  ['autoconfigurationEnabled', /^(?:autoconfiguration enabled|autokonfiguration aktiviert)$/i],
+  ['ipv4Address', /^(?:ipv4 address|ip address|ipv4-adresse|ip-adresse|dirección ipv4)(?: \((?:preferred|bevorzugt)\))?$/i],
+  ['ipv6Address', /^(?:ipv6 address|ipv6-adresse|dirección ipv6)(?: \((?:preferred|bevorzugt)\))?$/i],
+  ['subnetMask', /^(?:subnet mask|subnetzmaske|máscara de subred)$/i],
+  ['defaultGateway', /^(?:default gateway|standardgateway|puerta de enlace predeterminada)$/i],
+  ['dnsServers', /^(?:dns servers?|dns-server|servidores dns)$/i],
+  ['connectionSpecificDnsSuffix', /^(?:connection-specific dns suffix|verbindungsspezifisches dns-suffix|sufijo dns específico para la conexión)$/i],
+  ['linkLocalIpv6Address', /^(?:link-local ipv6 address|verbindungslokale ipv6-adresse|dirección ipv6 de vínculo local)$/i],
+  ['leaseObtained', /^(?:lease obtained|lease erhalten|concesión obtenida)$/i],
+  ['leaseExpires', /^(?:lease expires|lease läuft ab|la concesión expira)$/i],
+  ['dhcpServer', /^(?:dhcp server|dhcp-server|servidor dhcp)$/i],
+  ['winsServers', /^(?:wins servers?|wins-server)$/i],
+  ['mediaState', /^(?:media state|medienstatus|estado de los medios)$/i],
+  ['netbiosOverTcpip', /^(?:netbios over tcpip|netbios über tcpip aktiviert)$/i],
+  ['ipv4PrefixLength', /^(?:ipv4 prefix length|ipv4-präfixlänge)$/i]
+];
+
+const LIST_FIELDS = new Set(["dnsServers", "defaultGateway", "winsServers"]);
+const EMPTY_VALUES =
+  /^(?:n\/a|not applicable|none|keine|nicht zutreffend|ninguno|no disponible)$/i;
+const ADDRESS =
+  /^(?:\d{1,3}\.){3}\d{1,3}(?:\/\d{1,2})?$|^[0-9a-f]*:[0-9a-f:.%]+(?:\/\d{1,3})?$/i;
+
+function tidy(value) {
+  return value
+    .trim()
+    .replace(/^\.+$/, "")
+    .replace(/\s*\((?:preferred|bevorzugt|preferido)\)$/i, "")
+    .trim();
+}
+function bool(value) {
+  if (/^(?:yes|true|ja|sí|si|enabled|aktiviert)$/i.test(value)) return true;
+  if (/^(?:no|false|nein|disabled|deaktiviert)$/i.test(value)) return false;
+  return value;
+}
+function fieldLabel(line) {
+  return line.match(/^\s*(.+?)\s*:\s*(.*)$/);
+}
+function normalizeLabel(value) {
+  return value
+    .trim()
+    .replace(/\s*\.\s*/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+function makeAdapter(type, name) {
+  return {
+    name: name.trim().replace(/^\*+\s*/, ""),
+    type: type.trim(),
+    addresses: [],
+    ipv4: [],
+    ipv6: [],
+    dnsServers: [],
+    defaultGateways: [],
+  };
+}
+function addAddress(adapter, value, family, scope) {
+  const address = value.replace(/\/\d+$/, "");
+  const item = { address, family, ...(scope ? { scope } : {}) };
+  adapter.addresses.push(item);
+  (family === 4 ? adapter.ipv4 : adapter.ipv6).push(address);
+  adapter[family === 4 ? "ipv4Address" : "ipv6Address"] = address;
+  const prefix = value.match(/\/(\d+)$/)?.[1];
+  if (prefix !== undefined) item.prefixLength = Number(prefix);
+}
+
+/** Parse localized ipconfig text into normalized adapter objects. */
+export function parseIpconfig(output) {
+  if (typeof output !== "string")
+    throw new TypeError("ipconfig output must be a string");
+  const adapters = [];
+  let hostname;
+  let adapter;
+  let currentList;
+  for (const rawLine of output.replace(/^\uFEFF/, "").split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) {
+      currentList = undefined;
+      continue;
+    }
+    const header =
+      line.match(/^(.+?)\s+adapter\s+(.+):$/i) ??
+      line.match(/^(.+?)-Adapter\s+(.+):$/i) ??
+      line.match(/^(.+?) adaptador\s+(.+):$/i) ??
+      line.match(/^(.+?)-Adapter\s+(.+):$/i);
+    if (header) {
+      adapter = makeAdapter(header[1], header[2]);
+      adapters.push(adapter);
+      currentList = undefined;
+      continue;
+    }
+    if (
+      /(?:pseudo-interface|loopback interface)/i.test(line) &&
+      line.endsWith(":")
+    ) {
+      adapter = makeAdapter("Loopback", line.slice(0, -1));
+      adapters.push(adapter);
+      currentList = undefined;
+      continue;
+    }
+    const field = fieldLabel(rawLine);
+    if (!adapter) {
+      if (field) {
+        const label = normalizeLabel(field[1]);
+        const found = LABELS.find(
+          ([key, regex]) => key === "hostname" && regex.test(label),
+        );
+        if (found && field[2].trim()) hostname = tidy(field[2]);
+      }
+      continue;
+    }
+    const valueLine = line.match(ADDRESS);
+    if (currentList && valueLine) {
+      const target =
+        currentList === "defaultGateway"
+          ? adapter.defaultGateways
+          : adapter[currentList];
+      target.push(tidy(valueLine[0]));
+      continue;
+    }
+    if (!field) continue;
+    const label = normalizeLabel(field[1]);
+    const value = tidy(field[2]);
+    const match = LABELS.find(([, regex]) => regex.test(label));
+    if (!match) {
+      if (label && value)
+        ((adapter.fields ??= {}), (adapter.fields[label] = value));
+      currentList = undefined;
+      continue;
+    }
+    const key = match[0];
+    if (key === "hostname") {
+      if (value) hostname = value;
+      continue;
+    }
+    if (LIST_FIELDS.has(key)) {
+      currentList = key;
+      const target =
+        key === "defaultGateway"
+          ? adapter.defaultGateways
+          : key === "winsServers"
+            ? (adapter.winsServers ??= [])
+            : adapter.dnsServers;
+      if (value && value !== "::" && !EMPTY_VALUES.test(value))
+        target.push(value);
+      continue;
+    }
+    currentList = undefined;
+    if (!value || EMPTY_VALUES.test(value)) continue;
+    if (key === "ipv4Address") addAddress(adapter, value, 4);
+    else if (key === "ipv6Address") addAddress(adapter, value, 6);
+    else if (key === "linkLocalIpv6Address") {
+      adapter.linkLocalIpv6Address = value;
+      addAddress(adapter, value, 6, "link-local");
+    } else if (key === "dhcpEnabled" || key === "autoconfigurationEnabled")
+      adapter[key] = bool(value);
+    else if (key === "ipv4PrefixLength") {
+      adapter.ipv4PrefixLength = Number(value);
+    } else adapter[key] = value;
+  }
+  for (const item of adapters) {
+    if (item.subnetMask && item.ipv4PrefixLength === undefined)
+      item.ipv4PrefixLength = maskPrefix(item.subnetMask);
+    if (item.connectionSpecificDnsSuffix === undefined)
+      item.connectionSpecificDnsSuffix = null;
+  }
+  return { ...(hostname ? { hostname } : {}), adapters };
+}
+
+function maskPrefix(mask) {
+  const octets = mask.split(".").map(Number);
+  if (octets.length !== 4 || octets.some((part) => part < 0 || part > 255))
+    return undefined;
+  const bits = octets.map((part) => part.toString(2).padStart(8, "0")).join("");
+  if (!/^1*0*$/.test(bits)) return undefined;
+  return bits.indexOf("0") < 0 ? 32 : bits.indexOf("0");
+}