@arcticnotes/node-wsh 0.0.7

package/LICENSE

@@ -0,0 +1,18 @@
+Copyright 2025 ArcticNotes.com
+
+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

@@ -0,0 +1,40 @@
+
+# Node-WSH Bridge
+
+This is a Node.js libary that runs Windows Scripting Host (WSH) as a child process and exposes the resources from the
+WSH world to the Node.js world through serialized communication over the standard input and output channels. Obviously,
+it only works on Windows.
+
+## Usage
+
+To install:
+
+```console
+$ npm install @arcticnotes/node-wsh
+```
+
+In JavaScript code:
+
+```javascript
+import {WindowsScriptingHost} from '@arcticnotes/node-wsh';
+
+const wsh = await WindowsScriptingHost.connect();
+const WScript = wsh.WScript;
+console.log(WScript.Version);
+await wsh.disconnect();
+```
+
+## Dependencies
+
+*  Node.js release 20.x or higher is required.
+*  Windows Scripting Host is required. Version compatibility is unclear. Please report issues.
+   *  Version 5.812 is known to work.
+*  Dependency libraries included by `package.json`:
+   *  `@arcticnotes/syncline`. See https://github.com/arcticnotes/syncline.
+
+## License
+
+This library is shared under the [MIT License](https://opensource.org/license/mit). See the `LICENSE` file for details.
+
+This library includes `json2.js`, an implementation of JSON, donated by Douglas Crockford (the designer of JSON) to the
+public domain. The license aforementioned does not apply to this file.

package/lib/index.js

@@ -0,0 +1 @@
+export { WindowsScriptingHost} from './node/node-wsh.js';

package/lib/node/node-wsh.js

@@ -0,0 +1,235 @@
+import PATH from 'node:path';
+import { Syncline} from "@arcticnotes/syncline";
+
+const COMMAND = 'cscript.exe';
+const ARGS = [ '//E:jscript', '//NoLogo'];
+const SCRIPT_FILE = PATH.join( PATH.dirname( import.meta.dirname), 'wsh', 'host.js');
+const PROXY = Symbol();
+const TRACE_REF = 1;
+
+export class WindowsScriptingHost {
+
+	static async connect( options = {}) {
+		const command = options.command || COMMAND;
+		const args = options.args || ARGS;
+		const scriptFile = options.scriptFile || SCRIPT_FILE;
+		const trace = options.trace || 0;
+		return new WindowsScriptingHost( await Syncline.spawn( command, [ ...args, scriptFile], { trace}), options);
+	}
+
+	#syncline;
+	#proxies;
+	#WScript;
+	#GetObject;
+	#Enumerator;
+
+	constructor( syncline, options) {
+		this.#syncline = syncline;
+		this.#syncline.on( 'stderr', line => console.log( 'wsh:', line));
+		this.#syncline.on( 'stdout', line => console.log( 'wsh:', line));
+		this.#proxies = new Proxies( syncline, options);
+		this.#WScript = this.#proxies.getOrCreateObject( 0);
+		this.#GetObject = this.#proxies.getOrCreateFunction( 1);
+		this.#Enumerator = this.#proxies.getOrCreateFunction( 2);
+	}
+
+	get WScript() {
+		return this.#WScript;
+	}
+
+	get GetObject() {
+		return this.#GetObject;
+	}
+
+	get Enumerator() {
+		return this.#Enumerator;
+	}
+
+	async disconnect() {
+		await this.#syncline.close();
+	}
+}
+
+class Proxies {
+
+	#syncline;
+	#trace;
+	#finalizer = new FinalizationRegistry( this.#finalized.bind( this));
+	#ref2proxy = new Map();
+	#proxy2ref = new Map();
+
+	#objectHandler = {
+
+		proxies: this,
+	
+		get( target, prop) {
+			if( prop === Symbol.toPrimitive)
+				return () => `ref#${ this.proxies.#proxy2ref.get( target[ PROXY])}`;
+			const encodedTarget = this.proxies.#encode( target[ PROXY]);
+			const encodedProp = this.proxies.#encode( prop);
+			const output = JSON.parse( this.proxies.#syncline.exchange( JSON.stringify( [ 'get', encodedTarget, encodedProp])));
+			switch( output[ 0]) {
+				case 'value': return this.proxies.#decode( output[ 1]);
+				case 'error': throw new Error( output[ 1]);
+				default: throw new Error( `unknown status: ${ output[ 0]}`);
+			}
+		},
+	};
+
+	#functionHandler = {
+
+		proxies: this,
+
+		get( target, prop) {
+			if( prop === Symbol.toPrimitive)
+				return () => `ref#${ this.proxies.#proxy2ref.get( target[ PROXY])}`;
+			return undefined;
+		},
+
+		apply( target, thisArg, argumentList) {
+			const encodedTarget = this.proxies.#encode( target[ PROXY]);
+			const encodedThisArg = this.proxies.#encode( thisArg);
+			const encodedArgumentList = this.proxies.#encode( argumentList);
+			const output = JSON.parse( this.proxies.#syncline.exchange( JSON.stringify( [ 'apply', encodedTarget, encodedThisArg, encodedArgumentList])));
+			switch( output[ 0]) {
+				case 'value': return this.proxies.#decode( output[ 1]);
+				case 'error': throw new Error( output[ 1]);
+				default: throw new Error( `unknown status: ${ output[ 0]}`);
+			}
+		},
+
+		construct( target, argumentList) {
+			const encodedTarget = this.proxies.#encode( target[ PROXY]);
+			const encodedArgumentList = this.proxies.#encode( argumentList);
+			const output = JSON.parse( this.proxies.#syncline.exchange( JSON.stringify( [ 'construct', encodedTarget, encodedArgumentList])));
+			switch( output[ 0]) {
+				case 'value': return this.proxies.#decode( output[ 1]);
+				case 'error': throw new Error( output[ 1]);
+				default: throw new Error( `unknown status: ${ output[ 0]}`);
+			}
+		},
+	};
+
+	constructor( syncline, options) {
+		this.#syncline = syncline;
+		this.#trace = options.trace;
+	}
+
+	getOrCreateObject( ref) {
+		return this.#getOrCreate( ref, this.#objectHandler);
+	}
+
+	getOrCreateFunction( ref) {
+		return this.#getOrCreate( ref, this.#functionHandler);
+	}
+
+	#getOrCreate( ref, handler) {
+		const existingProxy = this.#ref2proxy.get( ref);
+		if( existingProxy)
+			return existingProxy;
+
+		const target = handler === this.#objectHandler? new RemoteObject(): function() {};
+		const newProxy = new Proxy( target, handler);
+		target[ PROXY] = newProxy;
+		this.#ref2proxy.set( ref, newProxy);
+		this.#proxy2ref.set( newProxy, ref);
+		this.#finalizer.register( newProxy, ref);
+		return newProxy;
+	}
+
+	#finalized( ref) {
+		const output = this.#syncline.exchange( JSON.stringify( [ 'unref', ref]));
+		if( this.#trace >= TRACE_REF)
+			switch( output[ 0]) {
+				case 'error':
+					console.log( `failed to unref: ${ ref}`);
+					break;
+				case 'done':
+					console.log( `unreferenced: ${ ref}`);
+					break;
+				default:
+					console.log( `unknown response: ${ output[ 0]}`);
+			}
+	}
+
+	#encode( decoded) {
+		switch( typeof decoded) {
+			case 'boolean':
+			case 'number':
+			case 'string':
+				return decoded;
+			case 'undefined':
+				return { type: 'undefined'};
+			case 'object':
+				if( decoded === null)
+					return decoded;
+				if( decoded instanceof Array) {
+					const encoded = [];
+					for( const item of decoded)
+						encoded.push( this.#encode( item));
+					return encoded;
+				}
+				if( decoded instanceof RemoteObject) {
+					const objref = this.#proxy2ref.get( decoded);
+					if( objref === undefined)
+						throw new Error( `remote object reference not found: ${ decoded}`);
+					return { type: 'objref', value: objref};
+				}
+				const encoded = { type: 'object', value: {}};
+				for( const [ name, value] of Object.entries( decoded))
+					encoded.value[ name] = this.#encode( value);
+				return encoded;
+			case 'function':
+				const funref = this.#proxy2ref.get( decoded);
+				if( funref === undefined)
+					throw new Error( `functions from node are disallowed: ${ decoded}`);
+				return { type: 'funref', value: funref};
+			case 'bigint':
+			case 'symbol':
+			default:
+				throw new Error( `unsupported value: ${ decoded}`);
+		}
+	}
+
+	#decode( encoded) {
+		switch( typeof encoded) {
+			case 'boolean':
+			case 'number':
+			case 'string':
+				return encoded;
+			case 'object':
+				if( encoded === null)
+					return encoded;
+				if( encoded instanceof Array) {
+					const decoded = [];
+					for( const item of encoded)
+						decoded.push( this.#decode( item));
+					return decoded;
+				}
+				switch( encoded.type) {
+					case 'undefined':
+						return undefined;
+					case 'object':
+						const decoded = {};
+						for( const [ name, value] of Object.entries( encoded.value))
+							decoded[ name] = this.#decode( value);
+						return decoded;
+					case 'objref':
+						return this.getOrCreateObject( encoded.value);
+					case 'funref':
+						return this.getOrCreateFunction( encoded.value);
+					default:
+						throw new Error( `illegal value: ${ encoded}`);
+				}
+			case 'undefined':
+			case 'function':
+			case 'bigint':
+			case 'symbol':
+			default:
+				throw new Error( `illegal value: ${ encoded}`);
+		}
+	}
+}
+
+class RemoteObject {
+}

package/lib/wsh/host.js

@@ -0,0 +1,215 @@
+// This file is in JScript, not in JavaScript. It is executed in Windows Scripting Host (WSH).
+
+var FSO = new ActiveXObject( 'Scripting.FileSystemObject');
+var OBJECT_TOSTRING = Object.toString();
+var REFERENCES = { // must match node-wsh.js
+	'0': { type: 'obj', value: WScript},
+	'1': { type: 'fun', value: GetObject},
+	'2': { type: 'fun', value: Enumerator}
+};
+var nextRefId = 3;
+
+eval( FSO.OpenTextFile( FSO.BuildPath( FSO.GetParentFolderName( WScript.ScriptFullName), 'json2.js')).ReadAll());
+
+function decode( encoded) {
+	var decoded;
+	var item;
+	var i;
+	switch( typeof encoded) {
+		case 'boolean':
+		case 'number':
+		case 'string':
+			return encoded;
+		case 'object':
+			if( encoded === null)
+				return encoded;
+			if( encoded instanceof Array) {
+				decoded = [];
+				for( i = 0; i < encoded.length; i++)
+					decoded.push( decode( encoded[ i]));
+				return decoded;
+			}
+			switch( encoded.type) {
+				case 'undefined':
+					return undefined;
+				case 'object':
+					decoded = {};
+					for( i in encoded.value)
+						decoded[ i] = decode( encoded.value[ i]);
+					return decoded;
+				case 'objref':
+					item = REFERENCES[ encoded.value];
+					if( item === undefined)
+						throw new Error( 'reference not found: ' + encoded.value);
+					if( item.type !== 'obj')
+						throw new Error( 'reference type mismatch: ' + encoded.value);
+					return item.value;
+				case 'funref':
+					item = REFERENCES[ encoded.value];
+					if( item === undefined)
+						throw new Error( 'reference not found: ' + encoded.value);
+					if( item.type === 'potential-method')
+						throw new Error( 'potentially a method, cannot be evaluated standalone: ' + encoded.value);
+					if( item.type !== 'fun')
+						throw new Error( 'reference type mismatch: ' + encoded.value);
+					return item.value;
+				default:
+					throw new Error( 'unknown object type: ' + encoded.type);
+			}
+		case 'undefined':
+		case 'symbol':
+		case 'bigint':
+		case 'function':
+		default:
+			throw new Error( 'illegal data type: ' + typeof encoded);
+	}
+}
+
+function encode( decoded) {
+	var encoded;
+	var i;
+	switch( typeof decoded) {
+		case 'boolean':
+		case 'number':
+		case 'string':
+			return decoded;
+		case 'undefined':
+			return { type: 'undefined'};
+		case 'object':
+			if( decoded === null)
+				return decoded;
+			if( decoded instanceof Array) {
+				encoded = [];
+				for( i = 0; i < decoded.length; i++)
+					encoded.push( encode( decoded[ i]));
+				return encoded;
+			}
+			if( decoded.constructor && decoded.constructor.toString() === OBJECT_TOSTRING) {
+				encoded = { type: 'object', value: {}};
+				for( i in decoded)
+					encoded.value[ i] = encode( decoded[ i]);
+				return encoded;
+			}
+			for( i in REFERENCES)
+				if( REFERENCES[ i].value === decoded)
+					return { type: 'objref', value: i};
+			i = '' + nextRefId++;
+			REFERENCES[ i] = { type: 'obj', value: decoded};
+			return { type: 'objref', value: i};
+		case 'function':
+			for( i in REFERENCES)
+				if( REFERENCES[ i].value === decoded)
+					return { type: 'funref', value: i};
+			i = '' + nextRefId++;
+			REFERENCES[ i] = { type: 'fun', value: decoded};
+			return { type: 'funref', value: i};
+		case 'symbol':
+		case 'bigint':
+		default:
+			throw new Error( 'unsupported data type: ' + typeof decoded);
+	}
+}
+
+function encodePotentialMethod( target, prop) {
+	var i;
+	var item;
+	for( i in REFERENCES) {
+		item = REFERENCES[ i];
+		if( item.type === 'potential-method' && item.target === target, item.prop === prop)
+			return { type: 'funref', value: i};
+	}
+	i = '' + nextRefId++;
+	REFERENCES[ i] = { type: 'potential-method', target: target, prop: prop};
+	return { type: 'funref', value: i};
+}
+
+function decodePotentialMethod( encoded) {
+	var item;
+	if( typeof encoded === 'object' && encoded.type === 'funref') {
+		item = REFERENCES[ encoded.value];
+		if( item.type === 'potential-method')
+			return { 'potential-method': true, target: item.target, prop: item.prop};
+	}
+	return { 'potential-method': false, value: decode( encoded)}
+}
+
+( function() {
+	var input;
+	var output;
+	var target;
+	var prop;
+	var thisArg;
+	var args;
+	while( !WScript.StdIn.AtEndOfLine)
+		try {
+			input = JSON.parse( WScript.StdIn.ReadLine());
+			switch( input[ 0]) {
+				case 'unref': // [ 'unref', ref] => [ 'done']
+					if( REFERENCES[ input[ 1]] === undefined)
+						throw new Error( 'unknown ref: ' + input[ 1]);
+					delete REFERENCES[ input[ i]];
+					output = [ 'done'];
+					break;
+				case 'get': // [ 'get', target, prop] => [ 'value', value] | [ 'potential-method']
+					target = decode( input[ 1]);
+					prop = decode( input[ 2]);
+					try {
+						output = [ 'value', encode( target[ prop])];
+					} catch( error) {
+						// could be a method
+						if( typeof target[ prop] !== 'unknown')
+							throw error;
+						output = [ 'value', encodePotentialMethod( target, prop)];
+					}
+					break;
+				case 'apply': // [ 'apply', target, thisArg, argumentList] => [ 'value', value]
+					target = decodePotentialMethod( input[ 1]);
+					thisArg = decode( input[ 2]);
+					args = decode( input[ 3]);
+					if( target[ 'potential-method']) {
+						if( thisArg === undefined)
+							throw new Error( 'potentially a method, can only be used as such');
+						if( thisArg !== target.target)
+							throw new Error( 'potentially a method, can only be used as such');
+						switch( args.length) {
+							case 0: output = [ 'value', encode( target.target[ target.prop]())]; break;
+							case 1: output = [ 'value', encode( target.target[ target.prop]( args[ 0]))]; break;
+							case 2: output = [ 'value', encode( target.target[ target.prop]( args[ 0], args[ 1]))]; break;
+							case 3: output = [ 'value', encode( target.target[ target.prop]( args[ 0], args[ 1], args[ 2]))]; break;
+							case 4: output = [ 'value', encode( target.target[ target.prop]( args[ 0], args[ 1], args[ 2], args[ 3]))]; break;
+							case 5: output = [ 'value', encode( target.target[ target.prop]( args[ 0], args[ 1], args[ 2], args[ 3], args[ 4]))]; break;
+							case 6: output = [ 'value', encode( target.target[ target.prop]( args[ 0], args[ 1], args[ 2], args[ 3], args[ 4], args[ 5]))]; break;
+							case 7: output = [ 'value', encode( target.target[ target.prop]( args[ 0], args[ 1], args[ 2], args[ 3], args[ 4], args[ 5], args[ 6]))]; break;
+							case 8: output = [ 'value', encode( target.target[ target.prop]( args[ 0], args[ 1], args[ 2], args[ 3], args[ 4], args[ 5], args[ 6], args[ 7]))]; break;
+							case 9: output = [ 'value', encode( target.target[ target.prop]( args[ 0], args[ 1], args[ 2], args[ 3], args[ 4], args[ 5], args[ 6], args[ 7], args[ 8]))]; break;
+							default: throw new Error( 'too many arguments');
+						}
+					} else
+						output = [ 'value', encode( target.value.apply( thisArg, args))];
+					break;
+				case 'construct': // [ 'construct', target, argumentList] => [ 'value', value]
+					target = decode( input[ 1]);
+					args = decode( input[ 2]);
+					switch( args.length) {
+						case 0: output = [ 'value', encode( new target())]; break;
+						case 1: output = [ 'value', encode( new target( args[ 0]))]; break;
+						case 2: output = [ 'value', encode( new target( args[ 0], args[ 1]))]; break;
+						case 3: output = [ 'value', encode( new target( args[ 0], args[ 1], args[ 2]))]; break;
+						case 4: output = [ 'value', encode( new target( args[ 0], args[ 1], args[ 2], args[ 3]))]; break;
+						case 5: output = [ 'value', encode( new target( args[ 0], args[ 1], args[ 2], args[ 3], args[ 4]))]; break;
+						case 6: output = [ 'value', encode( new target( args[ 0], args[ 1], args[ 2], args[ 3], args[ 4], args[ 5]))]; break;
+						case 7: output = [ 'value', encode( new target( args[ 0], args[ 1], args[ 2], args[ 3], args[ 4], args[ 5], args[ 6]))]; break;
+						case 8: output = [ 'value', encode( new target( args[ 0], args[ 1], args[ 2], args[ 3], args[ 4], args[ 5], args[ 6], args[ 7]))]; break;
+						case 9: output = [ 'value', encode( new target( args[ 0], args[ 1], args[ 2], args[ 3], args[ 4], args[ 5], args[ 6], args[ 7], args[ 8]))]; break;
+						default: throw new Error( 'too many arguments');
+					}
+					break;
+				default:
+					throw new Error( 'unknown command: ' + input[ 0]);
+			}
+		} catch( error) {
+			output = [ 'error', '' + error.message];
+		} finally {
+			WScript.StdOut.WriteLine( JSON.stringify( output));
+		}
+})();

package/lib/wsh/json2.js

@@ -0,0 +1,534 @@
+// This file is downloaded from
+// https://github.com/douglascrockford/JSON-js/blob/master/json2.js
+//==============================================================================
+
+//  json2.js
+//  2023-05-10
+//  Public Domain.
+//  NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
+
+//  USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO
+//  NOT CONTROL.
+
+//  This file creates a global JSON object containing two methods: stringify
+//  and parse. This file provides the ES5 JSON capability to ES3 systems.
+//  If a project might run on IE8 or earlier, then this file should be included.
+//  This file does nothing on ES5 systems.
+
+//      JSON.stringify(value, replacer, space)
+//          value       any JavaScript value, usually an object or array.
+//          replacer    an optional parameter that determines how object
+//                      values are stringified for objects. It can be a
+//                      function or an array of strings.
+//          space       an optional parameter that specifies the indentation
+//                      of nested structures. If it is omitted, the text will
+//                      be packed without extra whitespace. If it is a number,
+//                      it will specify the number of spaces to indent at each
+//                      level. If it is a string (such as "\t" or " "),
+//                      it contains the characters used to indent at each level.
+//          This method produces a JSON text from a JavaScript value.
+//          When an object value is found, if the object contains a toJSON
+//          method, its toJSON method will be called and the result will be
+//          stringified. A toJSON method does not serialize: it returns the
+//          value represented by the name/value pair that should be serialized,
+//          or undefined if nothing should be serialized. The toJSON method
+//          will be passed the key associated with the value, and this will be
+//          bound to the value.
+
+//          For example, this would serialize Dates as ISO strings.
+
+//              Date.prototype.toJSON = function (key) {
+//                  function f(n) {
+//                      // Format integers to have at least two digits.
+//                      return (n < 10)
+//                          ? "0" + n
+//                          : n;
+//                  }
+//                  return this.getUTCFullYear()   + "-" +
+//                       f(this.getUTCMonth() + 1) + "-" +
+//                       f(this.getUTCDate())      + "T" +
+//                       f(this.getUTCHours())     + ":" +
+//                       f(this.getUTCMinutes())   + ":" +
+//                       f(this.getUTCSeconds())   + "Z";
+//              };
+
+//          You can provide an optional replacer method. It will be passed the
+//          key and value of each member, with this bound to the containing
+//          object. The value that is returned from your method will be
+//          serialized. If your method returns undefined, then the member will
+//          be excluded from the serialization.
+
+//          If the replacer parameter is an array of strings, then it will be
+//          used to select the members to be serialized. It filters the results
+//          such that only members with keys listed in the replacer array are
+//          stringified.
+
+//          Values that do not have JSON representations, such as undefined or
+//          functions, will not be serialized. Such values in objects will be
+//          dropped; in arrays they will be replaced with null. You can use
+//          a replacer function to replace those with JSON values.
+
+//          JSON.stringify(undefined) returns undefined.
+
+//          The optional space parameter produces a stringification of the
+//          value that is filled with line breaks and indentation to make it
+//          easier to read.
+
+//          If the space parameter is a non-empty string, then that string will
+//          be used for indentation. If the space parameter is a number, then
+//          the indentation will be that many spaces.
+
+//          Example:
+
+//          text = JSON.stringify(["e", {pluribus: "unum"}]);
+//          // text is '["e",{"pluribus":"unum"}]'
+
+//          text = JSON.stringify(["e", {pluribus: "unum"}], null, "\t");
+//          // text is '[\n\t"e",\n\t{\n\t\t"pluribus": "unum"\n\t}\n]'
+
+//          text = JSON.stringify([new Date()], function (key, value) {
+//              return this[key] instanceof Date
+//                  ? "Date(" + this[key] + ")"
+//                  : value;
+//          });
+//          // text is '["Date(---current time---)"]'
+
+//      JSON.parse(text, reviver)
+//          This method parses a JSON text to produce an object or array.
+//          It can throw a SyntaxError exception.
+
+//          The optional reviver parameter is a function that can filter and
+//          transform the results. It receives each of the keys and values,
+//          and its return value is used instead of the original value.
+//          If it returns what it received, then the structure is not modified.
+//          If it returns undefined then the member is deleted.
+
+//          Example:
+
+//          // Parse the text. Values that look like ISO date strings will
+//          // be converted to Date objects.
+
+//          myData = JSON.parse(text, function (key, value) {
+//              var a;
+//              if (typeof value === "string") {
+//                  a =
+//   /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
+//                  if (a) {
+//                      return new Date(Date.UTC(
+//                         +a[1], +a[2] - 1, +a[3], +a[4], +a[5], +a[6]
+//                      ));
+//                  }
+//                  return value;
+//              }
+//          });
+
+//          myData = JSON.parse(
+//              "[\"Date(09/09/2001)\"]",
+//              function (key, value) {
+//                  var d;
+//                  if (
+//                      typeof value === "string"
+//                      && value.slice(0, 5) === "Date("
+//                      && value.slice(-1) === ")"
+//                  ) {
+//                      d = new Date(value.slice(5, -1));
+//                      if (d) {
+//                          return d;
+//                      }
+//                  }
+//                  return value;
+//              }
+//          );
+
+//  This is a reference implementation. You are free to copy, modify, or
+//  redistribute.
+
+/*jslint
+    eval, for, this
+*/
+
+/*property
+    JSON, apply, call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours,
+    getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join,
+    lastIndex, length, parse, prototype, push, replace, slice, stringify,
+    test, toJSON, toString, valueOf
+*/
+
+
+// Create a JSON object only if one does not already exist. We create the
+// methods in a closure to avoid creating global variables.
+
+if (typeof JSON !== "object") {
+    JSON = {};
+}
+
+(function () {
+    "use strict";
+
+    var rx_one = /^[\],:{}\s]*$/;
+    var rx_two = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g;
+    var rx_three = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g;
+    var rx_four = /(?:^|:|,)(?:\s*\[)+/g;
+    var rx_escapable = /[\\"\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
+    var rx_dangerous = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
+
+    function f(n) {
+        // Format integers to have at least two digits.
+        return (n < 10)
+            ? "0" + n
+            : n;
+    }
+
+    function this_value() {
+        return this.valueOf();
+    }
+
+    if (typeof Date.prototype.toJSON !== "function") {
+
+        Date.prototype.toJSON = function () {
+
+            return isFinite(this.valueOf())
+                ? (
+                    this.getUTCFullYear()
+                    + "-"
+                    + f(this.getUTCMonth() + 1)
+                    + "-"
+                    + f(this.getUTCDate())
+                    + "T"
+                    + f(this.getUTCHours())
+                    + ":"
+                    + f(this.getUTCMinutes())
+                    + ":"
+                    + f(this.getUTCSeconds())
+                    + "Z"
+                )
+                : null;
+        };
+
+        Boolean.prototype.toJSON = this_value;
+        Number.prototype.toJSON = this_value;
+        String.prototype.toJSON = this_value;
+    }
+
+    var gap;
+    var indent;
+    var meta;
+    var rep;
+
+
+    function quote(string) {
+
+// If the string contains no control characters, no quote characters, and no
+// backslash characters, then we can safely slap some quotes around it.
+// Otherwise we must also replace the offending characters with safe escape
+// sequences.
+
+        rx_escapable.lastIndex = 0;
+        return rx_escapable.test(string)
+            ? "\"" + string.replace(rx_escapable, function (a) {
+                var c = meta[a];
+                return typeof c === "string"
+                    ? c
+                    : "\\u" + ("0000" + a.charCodeAt(0).toString(16)).slice(-4);
+            }) + "\""
+            : "\"" + string + "\"";
+    }
+
+
+    function str(key, holder) {
+
+// Produce a string from holder[key].
+
+        var i;          // The loop counter.
+        var k;          // The member key.
+        var v;          // The member value.
+        var length;
+        var mind = gap;
+        var partial;
+        var value = holder[key];
+
+// If the value has a toJSON method, call it to obtain a replacement value.
+
+        if (
+            value
+            && typeof value === "object"
+            && typeof value.toJSON === "function"
+        ) {
+            value = value.toJSON(key);
+        }
+
+// If we were called with a replacer function, then call the replacer to
+// obtain a replacement value.
+
+        if (typeof rep === "function") {
+            value = rep.call(holder, key, value);
+        }
+
+// What happens next depends on the value's type.
+
+        switch (typeof value) {
+        case "string":
+            return quote(value);
+
+        case "number":
+
+// JSON numbers must be finite. Encode non-finite numbers as null.
+
+            return (isFinite(value))
+                ? String(value)
+                : "null";
+
+        case "boolean":
+        case "null":
+
+// If the value is a boolean or null, convert it to a string. Note:
+// typeof null does not produce "null". The case is included here in
+// the remote chance that this gets fixed someday.
+
+            return String(value);
+
+// If the type is "object", we might be dealing with an object or an array or
+// null.
+
+        case "object":
+
+// Due to a specification blunder in ECMAScript, typeof null is "object",
+// so watch out for that case.
+
+            if (!value) {
+                return "null";
+            }
+
+// Make an array to hold the partial results of stringifying this object value.
+
+            gap += indent;
+            partial = [];
+
+// Is the value an array?
+
+            if (Object.prototype.toString.apply(value) === "[object Array]") {
+
+// The value is an array. Stringify every element. Use null as a placeholder
+// for non-JSON values.
+
+                length = value.length;
+                for (i = 0; i < length; i += 1) {
+                    partial[i] = str(i, value) || "null";
+                }
+
+// Join all of the elements together, separated with commas, and wrap them in
+// brackets.
+
+                v = partial.length === 0
+                    ? "[]"
+                    : gap
+                        ? (
+                            "[\n"
+                            + gap
+                            + partial.join(",\n" + gap)
+                            + "\n"
+                            + mind
+                            + "]"
+                        )
+                        : "[" + partial.join(",") + "]";
+                gap = mind;
+                return v;
+            }
+
+// If the replacer is an array, use it to select the members to be stringified.
+
+            if (rep && typeof rep === "object") {
+                length = rep.length;
+                for (i = 0; i < length; i += 1) {
+                    if (typeof rep[i] === "string") {
+                        k = rep[i];
+                        v = str(k, value);
+                        if (v) {
+                            partial.push(quote(k) + (
+                                (gap)
+                                    ? ": "
+                                    : ":"
+                            ) + v);
+                        }
+                    }
+                }
+            } else {
+
+// Otherwise, iterate through all of the keys in the object.
+
+                for (k in value) {
+                    if (Object.prototype.hasOwnProperty.call(value, k)) {
+                        v = str(k, value);
+                        if (v) {
+                            partial.push(quote(k) + (
+                                (gap)
+                                    ? ": "
+                                    : ":"
+                            ) + v);
+                        }
+                    }
+                }
+            }
+
+// Join all of the member texts together, separated with commas,
+// and wrap them in braces.
+
+            v = partial.length === 0
+                ? "{}"
+                : gap
+                    ? "{\n" + gap + partial.join(",\n" + gap) + "\n" + mind + "}"
+                    : "{" + partial.join(",") + "}";
+            gap = mind;
+            return v;
+        }
+    }
+
+// If the JSON object does not yet have a stringify method, give it one.
+
+    if (typeof JSON.stringify !== "function") {
+        meta = {    // table of character substitutions
+            "\b": "\\b",
+            "\t": "\\t",
+            "\n": "\\n",
+            "\f": "\\f",
+            "\r": "\\r",
+            "\"": "\\\"",
+            "\\": "\\\\"
+        };
+        JSON.stringify = function (value, replacer, space) {
+
+// The stringify method takes a value and an optional replacer, and an optional
+// space parameter, and returns a JSON text. The replacer can be a function
+// that can replace values, or an array of strings that will select the keys.
+// A default replacer method can be provided. Use of the space parameter can
+// produce text that is more easily readable.
+
+            var i;
+            gap = "";
+            indent = "";
+
+// If the space parameter is a number, make an indent string containing that
+// many spaces.
+
+            if (typeof space === "number") {
+                for (i = 0; i < space; i += 1) {
+                    indent += " ";
+                }
+
+// If the space parameter is a string, it will be used as the indent string.
+
+            } else if (typeof space === "string") {
+                indent = space;
+            }
+
+// If there is a replacer, it must be a function or an array.
+// Otherwise, throw an error.
+
+            rep = replacer;
+            if (replacer && typeof replacer !== "function" && (
+                typeof replacer !== "object"
+                || typeof replacer.length !== "number"
+            )) {
+                throw new Error("JSON.stringify");
+            }
+
+// Make a fake root object containing our value under the key of "".
+// Return the result of stringifying the value.
+
+            return str("", {"": value});
+        };
+    }
+
+
+// If the JSON object does not yet have a parse method, give it one.
+
+    if (typeof JSON.parse !== "function") {
+        JSON.parse = function (text, reviver) {
+
+// The parse method takes a text and an optional reviver function, and returns
+// a JavaScript value if the text is a valid JSON text.
+
+            var j;
+
+            function walk(holder, key) {
+
+// The walk method is used to recursively walk the resulting structure so
+// that modifications can be made.
+
+                var k;
+                var v;
+                var value = holder[key];
+                if (value && typeof value === "object") {
+                    for (k in value) {
+                        if (Object.prototype.hasOwnProperty.call(value, k)) {
+                            v = walk(value, k);
+                            if (v !== undefined) {
+                                value[k] = v;
+                            } else {
+                                delete value[k];
+                            }
+                        }
+                    }
+                }
+                return reviver.call(holder, key, value);
+            }
+
+
+// Parsing happens in four stages. In the first stage, we replace certain
+// Unicode characters with escape sequences. JavaScript handles many characters
+// incorrectly, either silently deleting them, or treating them as line endings.
+
+            text = String(text);
+            rx_dangerous.lastIndex = 0;
+            if (rx_dangerous.test(text)) {
+                text = text.replace(rx_dangerous, function (a) {
+                    return (
+                        "\\u"
+                        + ("0000" + a.charCodeAt(0).toString(16)).slice(-4)
+                    );
+                });
+            }
+
+// In the second stage, we run the text against regular expressions that look
+// for non-JSON patterns. We are especially concerned with "()" and "new"
+// because they can cause invocation, and "=" because it can cause mutation.
+// But just to be safe, we want to reject all unexpected forms.
+
+// We split the second stage into 4 regexp operations in order to work around
+// crippling inefficiencies in IE's and Safari's regexp engines. First we
+// replace the JSON backslash pairs with "@" (a non-JSON character). Second, we
+// replace all simple value tokens with "]" characters. Third, we delete all
+// open brackets that follow a colon or comma or that begin the text. Finally,
+// we look to see that the remaining characters are only whitespace or "]" or
+// "," or ":" or "{" or "}". If that is so, then the text is safe for eval.
+
+            if (
+                rx_one.test(
+                    text
+                        .replace(rx_two, "@")
+                        .replace(rx_three, "]")
+                        .replace(rx_four, "")
+                )
+            ) {
+
+// In the third stage we use the eval function to compile the text into a
+// JavaScript structure. The "{" operator is subject to a syntactic ambiguity
+// in JavaScript: it can begin a block or an object literal. We wrap the text
+// in parens to eliminate the ambiguity.
+
+                j = eval("(" + text + ")");
+
+// In the optional fourth stage, we recursively walk the new structure, passing
+// each name/value pair to a reviver function for possible transformation.
+
+                return (typeof reviver === "function")
+                    ? walk({"": j}, "")
+                    : j;
+            }
+
+// If the text is not JSON parseable, then a SyntaxError is thrown.
+
+            throw new SyntaxError("JSON.parse");
+        };
+    }
+}());

package/package.json

@@ -0,0 +1,26 @@
+{
+	"name": "@arcticnotes/node-wsh",
+	"version": "0.0.7",
+	"description": "A Node.js package that runs Windows Scripting Host (WSH) as a child process and exposes the resources from the WSH world to the Node.js world",
+	"author": "Paul <paul@arcticnotes.com>",
+	"license": "MIT",
+	"keywords": [
+		"wsh",
+		"windows-scripting-host"
+	],
+	"homepage": "https://github.com/arcticnotes/node-wsh#readme",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/arcticnotes/node-wsh.git"
+	},
+	"bugs": {
+		"url": "https://github.com/arcticnotes/node-wsh/issues"
+	},
+	"type": "module",
+	"exports": {
+		".": "./lib/index.js"
+	},
+	"dependencies": {
+		"@arcticnotes/syncline": "0.0.3"
+	}
+}

package/test/test.js

@@ -0,0 +1,20 @@
+import ASSERT from 'node:assert/strict';
+import TEST from 'node:test';
+import { WindowsScriptingHost} from '@arcticnotes/node-wsh';
+
+TEST( 'smoke-test', async() => {
+	const wsh = await WindowsScriptingHost.connect();
+	try {
+		const { WScript, GetObject, Enumerator} = wsh;
+		console.log( WScript.Version);
+		ASSERT.equal( typeof WScript.Version, 'string');
+		const procs = GetObject( "winmgmts:\\\\.\\root\\cimv2").ExecQuery( 'SELECT ProcessId, Name FROM Win32_Process');
+		for( const enumerator = new Enumerator( procs); !enumerator.atEnd(); enumerator.moveNext()) {
+			console.log( `${ enumerator.item().ProcessId}: ${ enumerator.item().Name}`);
+			ASSERT.equal( typeof enumerator.item().ProcessId, 'number');
+			ASSERT.equal( typeof enumerator.item().Name, 'string');
+		}
+	} finally {
+		await wsh.disconnect();
+	}
+});