jww-parser 1.0.0

package/README.md

@@ -0,0 +1,138 @@
+# jww-parser
+
+JWW (Jw_cad) file parser and DXF converter for JavaScript/TypeScript.
+
+This package uses WebAssembly to parse JWW binary files (created by [Jw_cad](https://www.jwcad.net/), a popular Japanese CAD software) and convert them to DXF format.
+
+## Installation
+
+```bash
+npm install jww-parser
+```
+
+## Usage
+
+### Node.js
+
+```typescript
+import { createParser } from 'jww-parser';
+import { readFileSync } from 'fs';
+
+async function main() {
+  // Create and initialize the parser
+  const parser = await createParser();
+
+  // Read a JWW file
+  const jwwData = readFileSync('drawing.jww');
+  const data = new Uint8Array(jwwData);
+
+  // Parse JWW to get document structure
+  const doc = parser.parse(data);
+  console.log('Entities:', doc.Entities.length);
+  console.log('Layers:', doc.LayerGroups.length);
+
+  // Convert to DXF string
+  const dxfString = parser.toDxfString(data);
+  writeFileSync('output.dxf', dxfString);
+}
+
+main();
+```
+
+### Browser
+
+```html
+<!-- Include wasm_exec.js from Go -->
+<script src="wasm_exec.js"></script>
+<script type="module">
+  import { createParser } from 'jww-parser';
+
+  async function convertFile(file) {
+    const parser = await createParser('path/to/jww-parser.wasm');
+
+    const buffer = await file.arrayBuffer();
+    const data = new Uint8Array(buffer);
+
+    // Get DXF content
+    const dxfString = parser.toDxfString(data);
+
+    // Download as file
+    const blob = new Blob([dxfString], { type: 'application/dxf' });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = file.name.replace('.jww', '.dxf');
+    a.click();
+  }
+</script>
+```
+
+## API
+
+### `createParser(wasmPath?: string): Promise<JwwParser>`
+
+Create and initialize a JWW parser instance.
+
+- `wasmPath` - Optional path to the `jww-parser.wasm` file
+
+### `JwwParser`
+
+#### `init(): Promise<void>`
+
+Initialize the WASM module. Called automatically by `createParser()`.
+
+#### `parse(data: Uint8Array): JwwDocument`
+
+Parse a JWW file and return the document structure.
+
+#### `toDxf(data: Uint8Array): DxfDocument`
+
+Parse a JWW file and convert to DXF document structure (JSON).
+
+#### `toDxfString(data: Uint8Array): string`
+
+Parse a JWW file and convert to DXF file content string.
+
+## Types
+
+### JwwDocument
+
+```typescript
+interface JwwDocument {
+  Version: number;
+  Memo: string;
+  PaperSize: number;
+  LayerGroups: LayerGroup[];
+  Entities: JwwEntity[];
+  Blocks: JwwBlock[];
+}
+```
+
+### JwwEntity
+
+Supported entity types:
+- `JwwLine` - Line segments
+- `JwwArc` - Arcs and circles
+- `JwwPoint` - Points
+- `JwwText` - Text annotations
+- `JwwSolid` - Solid fills
+- `JwwBlockRef` - Block references
+
+### DxfDocument
+
+```typescript
+interface DxfDocument {
+  Layers: DxfLayer[];
+  Entities: DxfEntity[];
+  Blocks: DxfBlock[];
+}
+```
+
+## Requirements
+
+- Node.js >= 18.0.0 (for Node.js usage)
+- Modern browser with WebAssembly support (for browser usage)
+
+## License
+
+AGPL-3.0

package/dist/index.d.mts

@@ -0,0 +1,168 @@
+/**
+ * JWW (Jw_cad) file parser and DXF converter
+ *
+ * This module provides functionality to parse JWW binary files
+ * and convert them to DXF format using WebAssembly.
+ */
+interface JwwDocument {
+    Version: number;
+    Memo: string;
+    PaperSize: number;
+    LayerGroups: LayerGroup[];
+    Entities: JwwEntity[];
+    Blocks: JwwBlock[];
+}
+interface LayerGroup {
+    Name: string;
+    Layers: Layer[];
+}
+interface Layer {
+    Name: string;
+    Visible: boolean;
+    Locked: boolean;
+}
+interface JwwEntityBase {
+    Type: string;
+    Group: number;
+    PenStyle: number;
+    PenColor: number;
+    PenWidth: number;
+    Layer: number;
+    LayerGroup: number;
+}
+interface JwwLine extends JwwEntityBase {
+    Type: "Line";
+    X1: number;
+    Y1: number;
+    X2: number;
+    Y2: number;
+}
+interface JwwArc extends JwwEntityBase {
+    Type: "Arc";
+    CenterX: number;
+    CenterY: number;
+    Radius: number;
+    StartAngle: number;
+    EndAngle: number;
+    Flatness: number;
+}
+interface JwwPoint extends JwwEntityBase {
+    Type: "Point";
+    X: number;
+    Y: number;
+    Code: number;
+}
+interface JwwText extends JwwEntityBase {
+    Type: "Text";
+    X: number;
+    Y: number;
+    Text: string;
+    FontName: string;
+    Height: number;
+    Width: number;
+    Angle: number;
+}
+interface JwwSolid extends JwwEntityBase {
+    Type: "Solid";
+    Points: [number, number][];
+}
+interface JwwBlockRef extends JwwEntityBase {
+    Type: "Block";
+    X: number;
+    Y: number;
+    ScaleX: number;
+    ScaleY: number;
+    Angle: number;
+    BlockNumber: number;
+}
+type JwwEntity = JwwLine | JwwArc | JwwPoint | JwwText | JwwSolid | JwwBlockRef;
+interface JwwBlock {
+    Name: string;
+    Entities: JwwEntity[];
+}
+interface DxfDocument {
+    Layers: DxfLayer[];
+    Entities: DxfEntity[];
+    Blocks: DxfBlock[];
+}
+interface DxfLayer {
+    Name: string;
+    Color: number;
+    Frozen: boolean;
+    Locked: boolean;
+}
+interface DxfEntity {
+    Type: string;
+    Layer: string;
+    Color?: number;
+    [key: string]: unknown;
+}
+interface DxfBlock {
+    Name: string;
+    Entities: DxfEntity[];
+}
+interface WasmResult {
+    ok: boolean;
+    data?: string;
+    error?: string;
+}
+declare global {
+    var Go: new () => GoInstance;
+    var jwwParse: (data: Uint8Array) => WasmResult;
+    var jwwToDxf: (data: Uint8Array) => WasmResult;
+    var jwwToDxfString: (data: Uint8Array) => WasmResult;
+}
+interface GoInstance {
+    importObject: WebAssembly.Imports;
+    run(instance: WebAssembly.Instance): Promise<void>;
+}
+declare class JwwParser {
+    private initialized;
+    private initPromise;
+    private wasmPath;
+    /**
+     * Create a new JWW parser instance
+     * @param wasmPath - Path to the jww-parser.wasm file
+     */
+    constructor(wasmPath?: string);
+    private getDefaultWasmPath;
+    /**
+     * Initialize the WASM module
+     * Must be called before using parse methods
+     */
+    init(): Promise<void>;
+    private loadWasm;
+    private loadWasmExec;
+    private waitForWasmFunctions;
+    private ensureInitialized;
+    /**
+     * Parse a JWW file and return the document structure
+     * @param data - JWW file content as Uint8Array
+     * @returns Parsed JWW document
+     */
+    parse(data: Uint8Array): JwwDocument;
+    /**
+     * Parse a JWW file and convert to DXF document structure
+     * @param data - JWW file content as Uint8Array
+     * @returns DXF document object
+     */
+    toDxf(data: Uint8Array): DxfDocument;
+    /**
+     * Parse a JWW file and convert to DXF file content string
+     * @param data - JWW file content as Uint8Array
+     * @returns DXF file content as string
+     */
+    toDxfString(data: Uint8Array): string;
+}
+/**
+ * Create and initialize a JWW parser instance
+ * @param wasmPath - Optional path to the jww-parser.wasm file
+ * @returns Initialized JwwParser instance
+ */
+declare function createParser(wasmPath?: string): Promise<JwwParser>;
+declare const _default: {
+    JwwParser: typeof JwwParser;
+    createParser: typeof createParser;
+};
+
+export { type DxfBlock, type DxfDocument, type DxfEntity, type DxfLayer, type JwwArc, type JwwBlock, type JwwBlockRef, type JwwDocument, type JwwEntity, type JwwEntityBase, type JwwLine, JwwParser, type JwwPoint, type JwwSolid, type JwwText, type Layer, type LayerGroup, createParser, _default as default };

package/dist/index.d.ts

@@ -0,0 +1,168 @@
+/**
+ * JWW (Jw_cad) file parser and DXF converter
+ *
+ * This module provides functionality to parse JWW binary files
+ * and convert them to DXF format using WebAssembly.
+ */
+interface JwwDocument {
+    Version: number;
+    Memo: string;
+    PaperSize: number;
+    LayerGroups: LayerGroup[];
+    Entities: JwwEntity[];
+    Blocks: JwwBlock[];
+}
+interface LayerGroup {
+    Name: string;
+    Layers: Layer[];
+}
+interface Layer {
+    Name: string;
+    Visible: boolean;
+    Locked: boolean;
+}
+interface JwwEntityBase {
+    Type: string;
+    Group: number;
+    PenStyle: number;
+    PenColor: number;
+    PenWidth: number;
+    Layer: number;
+    LayerGroup: number;
+}
+interface JwwLine extends JwwEntityBase {
+    Type: "Line";
+    X1: number;
+    Y1: number;
+    X2: number;
+    Y2: number;
+}
+interface JwwArc extends JwwEntityBase {
+    Type: "Arc";
+    CenterX: number;
+    CenterY: number;
+    Radius: number;
+    StartAngle: number;
+    EndAngle: number;
+    Flatness: number;
+}
+interface JwwPoint extends JwwEntityBase {
+    Type: "Point";
+    X: number;
+    Y: number;
+    Code: number;
+}
+interface JwwText extends JwwEntityBase {
+    Type: "Text";
+    X: number;
+    Y: number;
+    Text: string;
+    FontName: string;
+    Height: number;
+    Width: number;
+    Angle: number;
+}
+interface JwwSolid extends JwwEntityBase {
+    Type: "Solid";
+    Points: [number, number][];
+}
+interface JwwBlockRef extends JwwEntityBase {
+    Type: "Block";
+    X: number;
+    Y: number;
+    ScaleX: number;
+    ScaleY: number;
+    Angle: number;
+    BlockNumber: number;
+}
+type JwwEntity = JwwLine | JwwArc | JwwPoint | JwwText | JwwSolid | JwwBlockRef;
+interface JwwBlock {
+    Name: string;
+    Entities: JwwEntity[];
+}
+interface DxfDocument {
+    Layers: DxfLayer[];
+    Entities: DxfEntity[];
+    Blocks: DxfBlock[];
+}
+interface DxfLayer {
+    Name: string;
+    Color: number;
+    Frozen: boolean;
+    Locked: boolean;
+}
+interface DxfEntity {
+    Type: string;
+    Layer: string;
+    Color?: number;
+    [key: string]: unknown;
+}
+interface DxfBlock {
+    Name: string;
+    Entities: DxfEntity[];
+}
+interface WasmResult {
+    ok: boolean;
+    data?: string;
+    error?: string;
+}
+declare global {
+    var Go: new () => GoInstance;
+    var jwwParse: (data: Uint8Array) => WasmResult;
+    var jwwToDxf: (data: Uint8Array) => WasmResult;
+    var jwwToDxfString: (data: Uint8Array) => WasmResult;
+}
+interface GoInstance {
+    importObject: WebAssembly.Imports;
+    run(instance: WebAssembly.Instance): Promise<void>;
+}
+declare class JwwParser {
+    private initialized;
+    private initPromise;
+    private wasmPath;
+    /**
+     * Create a new JWW parser instance
+     * @param wasmPath - Path to the jww-parser.wasm file
+     */
+    constructor(wasmPath?: string);
+    private getDefaultWasmPath;
+    /**
+     * Initialize the WASM module
+     * Must be called before using parse methods
+     */
+    init(): Promise<void>;
+    private loadWasm;
+    private loadWasmExec;
+    private waitForWasmFunctions;
+    private ensureInitialized;
+    /**
+     * Parse a JWW file and return the document structure
+     * @param data - JWW file content as Uint8Array
+     * @returns Parsed JWW document
+     */
+    parse(data: Uint8Array): JwwDocument;
+    /**
+     * Parse a JWW file and convert to DXF document structure
+     * @param data - JWW file content as Uint8Array
+     * @returns DXF document object
+     */
+    toDxf(data: Uint8Array): DxfDocument;
+    /**
+     * Parse a JWW file and convert to DXF file content string
+     * @param data - JWW file content as Uint8Array
+     * @returns DXF file content as string
+     */
+    toDxfString(data: Uint8Array): string;
+}
+/**
+ * Create and initialize a JWW parser instance
+ * @param wasmPath - Optional path to the jww-parser.wasm file
+ * @returns Initialized JwwParser instance
+ */
+declare function createParser(wasmPath?: string): Promise<JwwParser>;
+declare const _default: {
+    JwwParser: typeof JwwParser;
+    createParser: typeof createParser;
+};
+
+export { type DxfBlock, type DxfDocument, type DxfEntity, type DxfLayer, type JwwArc, type JwwBlock, type JwwBlockRef, type JwwDocument, type JwwEntity, type JwwEntityBase, type JwwLine, JwwParser, type JwwPoint, type JwwSolid, type JwwText, type Layer, type LayerGroup, createParser, _default as default };

package/dist/index.js

@@ -0,0 +1,167 @@
+"use strict";
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  JwwParser: () => JwwParser,
+  createParser: () => createParser,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_meta = {};
+var JwwParser = class {
+  /**
+   * Create a new JWW parser instance
+   * @param wasmPath - Path to the jww-parser.wasm file
+   */
+  constructor(wasmPath) {
+    this.initialized = false;
+    this.initPromise = null;
+    this.wasmPath = wasmPath || this.getDefaultWasmPath();
+  }
+  getDefaultWasmPath() {
+    if (typeof process !== "undefined" && process.versions?.node) {
+      return new URL("../wasm/jww-parser.wasm", import_meta.url).pathname;
+    }
+    return "jww-parser.wasm";
+  }
+  /**
+   * Initialize the WASM module
+   * Must be called before using parse methods
+   */
+  async init() {
+    if (this.initialized) return;
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = this.loadWasm();
+    await this.initPromise;
+    this.initialized = true;
+  }
+  async loadWasm() {
+    if (typeof Go === "undefined") {
+      await this.loadWasmExec();
+    }
+    const go = new Go();
+    let wasmInstance;
+    if (typeof process !== "undefined" && process.versions?.node) {
+      const fs = await import("fs");
+      const path = await import("path");
+      const wasmBuffer = fs.readFileSync(this.wasmPath);
+      const wasmModule = await WebAssembly.compile(wasmBuffer);
+      wasmInstance = await WebAssembly.instantiate(wasmModule, go.importObject);
+    } else {
+      const result = await WebAssembly.instantiateStreaming(
+        fetch(this.wasmPath),
+        go.importObject
+      ).catch(async () => {
+        const response = await fetch(this.wasmPath);
+        const bytes = await response.arrayBuffer();
+        return WebAssembly.instantiate(bytes, go.importObject);
+      });
+      wasmInstance = result.instance;
+    }
+    go.run(wasmInstance);
+    await this.waitForWasmFunctions();
+  }
+  async loadWasmExec() {
+    if (typeof process !== "undefined" && process.versions?.node) {
+      const wasmExecPath = new URL("../wasm/wasm_exec.js", import_meta.url).pathname;
+      await import(wasmExecPath);
+    } else {
+      throw new Error(
+        "Go runtime not loaded. Please include wasm_exec.js in your HTML."
+      );
+    }
+  }
+  async waitForWasmFunctions(timeout = 5e3, interval = 50) {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      if (typeof globalThis.jwwParse === "function" && typeof globalThis.jwwToDxf === "function" && typeof globalThis.jwwToDxfString === "function") {
+        return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new Error("WASM functions not available after timeout");
+  }
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new Error("Parser not initialized. Call init() first.");
+    }
+  }
+  /**
+   * Parse a JWW file and return the document structure
+   * @param data - JWW file content as Uint8Array
+   * @returns Parsed JWW document
+   */
+  parse(data) {
+    this.ensureInitialized();
+    const result = globalThis.jwwParse(data);
+    if (!result.ok) {
+      throw new Error(result.error || "Parse failed");
+    }
+    return JSON.parse(result.data);
+  }
+  /**
+   * Parse a JWW file and convert to DXF document structure
+   * @param data - JWW file content as Uint8Array
+   * @returns DXF document object
+   */
+  toDxf(data) {
+    this.ensureInitialized();
+    const result = globalThis.jwwToDxf(data);
+    if (!result.ok) {
+      throw new Error(result.error || "Conversion failed");
+    }
+    return JSON.parse(result.data);
+  }
+  /**
+   * Parse a JWW file and convert to DXF file content string
+   * @param data - JWW file content as Uint8Array
+   * @returns DXF file content as string
+   */
+  toDxfString(data) {
+    this.ensureInitialized();
+    const result = globalThis.jwwToDxfString(data);
+    if (!result.ok) {
+      throw new Error(result.error || "Conversion failed");
+    }
+    return result.data;
+  }
+};
+async function createParser(wasmPath) {
+  const parser = new JwwParser(wasmPath);
+  await parser.init();
+  return parser;
+}
+var index_default = { JwwParser, createParser };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JwwParser,
+  createParser
+});

package/dist/index.mjs

@@ -0,0 +1,130 @@
+// src/index.ts
+var JwwParser = class {
+  /**
+   * Create a new JWW parser instance
+   * @param wasmPath - Path to the jww-parser.wasm file
+   */
+  constructor(wasmPath) {
+    this.initialized = false;
+    this.initPromise = null;
+    this.wasmPath = wasmPath || this.getDefaultWasmPath();
+  }
+  getDefaultWasmPath() {
+    if (typeof process !== "undefined" && process.versions?.node) {
+      return new URL("../wasm/jww-parser.wasm", import.meta.url).pathname;
+    }
+    return "jww-parser.wasm";
+  }
+  /**
+   * Initialize the WASM module
+   * Must be called before using parse methods
+   */
+  async init() {
+    if (this.initialized) return;
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = this.loadWasm();
+    await this.initPromise;
+    this.initialized = true;
+  }
+  async loadWasm() {
+    if (typeof Go === "undefined") {
+      await this.loadWasmExec();
+    }
+    const go = new Go();
+    let wasmInstance;
+    if (typeof process !== "undefined" && process.versions?.node) {
+      const fs = await import("fs");
+      const path = await import("path");
+      const wasmBuffer = fs.readFileSync(this.wasmPath);
+      const wasmModule = await WebAssembly.compile(wasmBuffer);
+      wasmInstance = await WebAssembly.instantiate(wasmModule, go.importObject);
+    } else {
+      const result = await WebAssembly.instantiateStreaming(
+        fetch(this.wasmPath),
+        go.importObject
+      ).catch(async () => {
+        const response = await fetch(this.wasmPath);
+        const bytes = await response.arrayBuffer();
+        return WebAssembly.instantiate(bytes, go.importObject);
+      });
+      wasmInstance = result.instance;
+    }
+    go.run(wasmInstance);
+    await this.waitForWasmFunctions();
+  }
+  async loadWasmExec() {
+    if (typeof process !== "undefined" && process.versions?.node) {
+      const wasmExecPath = new URL("../wasm/wasm_exec.js", import.meta.url).pathname;
+      await import(wasmExecPath);
+    } else {
+      throw new Error(
+        "Go runtime not loaded. Please include wasm_exec.js in your HTML."
+      );
+    }
+  }
+  async waitForWasmFunctions(timeout = 5e3, interval = 50) {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      if (typeof globalThis.jwwParse === "function" && typeof globalThis.jwwToDxf === "function" && typeof globalThis.jwwToDxfString === "function") {
+        return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new Error("WASM functions not available after timeout");
+  }
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new Error("Parser not initialized. Call init() first.");
+    }
+  }
+  /**
+   * Parse a JWW file and return the document structure
+   * @param data - JWW file content as Uint8Array
+   * @returns Parsed JWW document
+   */
+  parse(data) {
+    this.ensureInitialized();
+    const result = globalThis.jwwParse(data);
+    if (!result.ok) {
+      throw new Error(result.error || "Parse failed");
+    }
+    return JSON.parse(result.data);
+  }
+  /**
+   * Parse a JWW file and convert to DXF document structure
+   * @param data - JWW file content as Uint8Array
+   * @returns DXF document object
+   */
+  toDxf(data) {
+    this.ensureInitialized();
+    const result = globalThis.jwwToDxf(data);
+    if (!result.ok) {
+      throw new Error(result.error || "Conversion failed");
+    }
+    return JSON.parse(result.data);
+  }
+  /**
+   * Parse a JWW file and convert to DXF file content string
+   * @param data - JWW file content as Uint8Array
+   * @returns DXF file content as string
+   */
+  toDxfString(data) {
+    this.ensureInitialized();
+    const result = globalThis.jwwToDxfString(data);
+    if (!result.ok) {
+      throw new Error(result.error || "Conversion failed");
+    }
+    return result.data;
+  }
+};
+async function createParser(wasmPath) {
+  const parser = new JwwParser(wasmPath);
+  await parser.init();
+  return parser;
+}
+var index_default = { JwwParser, createParser };
+export {
+  JwwParser,
+  createParser,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "jww-parser",
+  "version": "1.0.0",
+  "description": "JWW (Jw_cad) file parser and DXF converter for JavaScript/TypeScript",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "wasm"
+  ],
+  "keywords": [
+    "jww",
+    "jw-cad",
+    "jwcad",
+    "dxf",
+    "cad",
+    "converter",
+    "parser",
+    "webassembly",
+    "wasm"
+  ],
+  "author": "f12o",
+  "license": "AGPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/f4ah6o/jww-dxf.git"
+  },
+  "bugs": {
+    "url": "https://github.com/f4ah6o/jww-dxf/issues"
+  },
+  "homepage": "https://github.com/f4ah6o/jww-dxf#readme",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "npm run build:wasm && npm run build:js",
+    "build:wasm": "mkdir -p wasm && cd .. && make build-wasm && cp dist/jww-parser.wasm npm/wasm/",
+    "build:js": "tsup src/index.ts --format cjs,esm --dts"
+  }
+}