zuzu-js 0.1.0

package/modules/std/marshal.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const cbor = require( './marshal/cbor' );
+const {
+	dumpGraph,
+	loadGraph,
+	safeToDumpGraph,
+	setRuntimePolicy,
+} = require( './marshal/graph' );
+
+class MarshallingException extends Error {
+	constructor( message = 'std/marshal.dump failed' ) {
+		super( String( message ) );
+		this.name = 'MarshallingException';
+	}
+
+	to_String() {
+		return `${this.name}: ${this.message}`;
+	}
+}
+
+class UnmarshallingException extends Error {
+	constructor( message = 'std/marshal.load failed' ) {
+		super( String( message ) );
+		this.name = 'UnmarshallingException';
+	}
+
+	to_String() {
+		return `${this.name}: ${this.message}`;
+	}
+}
+
+function dump( value ) {
+	assertArity( 'dump', arguments.length, 1 );
+	try {
+		return dumpGraph( value );
+	}
+	catch ( err ) {
+		throw new MarshallingException(
+			`std/marshal.dump failed: ${err.message || err}`
+		);
+	}
+}
+
+function load( blob ) {
+	assertArity( 'load', arguments.length, 1 );
+	try {
+		return loadGraph( blob );
+	}
+	catch ( err ) {
+		if ( String( err && err.message || err ).startsWith( 'TypeException:' ) ) {
+			throw err;
+		}
+		throw new UnmarshallingException(
+			`std/marshal.load failed: ${err.message || err}`
+		);
+	}
+}
+
+function safe_to_dump( value ) {
+	assertArity( 'safe_to_dump', arguments.length, 1 );
+	return safeToDumpGraph( value );
+}
+
+function assertArity( name, got, expected ) {
+	if ( got !== expected ) {
+		throw new Error(
+			`TypeException: ${name} expects ${expected} argument, got ${got}`
+		);
+	}
+}
+
+module.exports = {
+	dump,
+	load,
+	safe_to_dump,
+	MarshallingException,
+	UnmarshallingException,
+	__zuzu_set_runtime_policy: setRuntimePolicy,
+};
+
+Object.defineProperty( module.exports, '__cbor', {
+	value: cbor,
+	enumerable: false,
+	configurable: false,
+	writable: false,
+} );

package/modules/std/math/bignum.js

@@ -0,0 +1,91 @@
+'use strict';
+
+class BigNum {
+	constructor( value, text = null, isInt = null ) {
+		this._value = Number( value ?? 0 );
+		this._text = text == null ? String( this._value ) : String( text );
+		this._isInt = isInt == null ? Number.isInteger( this._value ) : Boolean( isInt );
+	}
+
+	static _coerce( value ) {
+		if ( value instanceof BigNum ) {
+			return value;
+		}
+		if ( typeof value === 'string' ) {
+			return BigNum.from_dec( value );
+		}
+		return new BigNum( Number( value ?? 0 ) );
+	}
+
+	static from_dec( value ) {
+		const text = String( value ?? '0' ).trim();
+		return new BigNum( Number( text || '0' ), text || '0', !/[.eE]/.test( text ) );
+	}
+
+	static from_hex( value ) {
+		const text = String( value ?? '0' ).trim().toLowerCase().replace( /^0x/u, '' ) || '0';
+		const parsed = Number.parseInt( text, 16 );
+		return new BigNum( parsed, String( parsed ), true );
+	}
+
+	get is_int() {
+		return this._isInt;
+	}
+
+	bcmp( other ) {
+		const rhs = BigNum._coerce( other )._value;
+		return this._value < rhs ? -1 : ( this._value > rhs ? 1 : 0 );
+	}
+
+	beq( other ) { return this.bcmp( other ) === 0; }
+	bne( other ) { return this.bcmp( other ) !== 0; }
+	blt( other ) { return this.bcmp( other ) < 0; }
+	ble( other ) { return this.bcmp( other ) <= 0; }
+	bgt( other ) { return this.bcmp( other ) > 0; }
+	bge( other ) { return this.bcmp( other ) >= 0; }
+
+	get babs() { return new BigNum( Math.abs( this._value ), String( Math.abs( this._value ) ), this._isInt ); }
+	get bneg() { return new BigNum( -this._value, String( -this._value ), this._isInt ); }
+	get binv() { return new BigNum( 1 / this._value ); }
+	get bsin() { return new BigNum( Math.sin( this._value ), String( Math.sin( this._value ) ), false ); }
+	get bcos() { return new BigNum( Math.cos( this._value ) ); }
+	get btan() { return new BigNum( Math.tan( this._value ), String( Math.tan( this._value ) ), false ); }
+	get bsqrt() { return new BigNum( Math.sqrt( this._value ) ); }
+	get bround() { return new BigNum( Math.round( this._value ) ); }
+	get bfloor() { return new BigNum( Math.floor( this._value ) ); }
+	get bceil() { return new BigNum( Math.ceil( this._value ) ); }
+
+	badd( other ) { return new BigNum( this._value + BigNum._coerce( other )._value, String( this._value + BigNum._coerce( other )._value ), false ); }
+	bsub( other ) { return new BigNum( this._value - BigNum._coerce( other )._value, String( this._value - BigNum._coerce( other )._value ), false ); }
+	bmul( other ) { return new BigNum( this._value * BigNum._coerce( other )._value, String( this._value * BigNum._coerce( other )._value ), false ); }
+	bdiv( other ) { return new BigNum( this._value / BigNum._coerce( other )._value ); }
+	bmod( other ) { return new BigNum( this._value % BigNum._coerce( other )._value ); }
+	bpow( other ) { return new BigNum( this._value ** BigNum._coerce( other )._value ); }
+
+	get to_hex() {
+		return `0x${Math.trunc( this._value ).toString( 16 )}`;
+	}
+
+	get to_dec() {
+		return this._isInt ? Math.trunc( this._value ) : this._textify();
+	}
+
+	get to_String() {
+		return this.to_dec;
+	}
+
+	get to_Number() {
+		return this._value;
+	}
+
+	_textify() {
+		if ( this._text != null && /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/u.test( this._text ) ) {
+			return this._text.replace( /\.0+$/u, '' ).replace( /(\.\d*?)0+$/u, '$1' ).replace( /\.$/u, '' );
+		}
+		return String( this._value );
+	}
+}
+
+module.exports = {
+	BigNum,
+};

package/modules/std/math.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const PI = Math.PI;
+
+function normalizeNumberArgs( values ) {
+	if ( values.length === 1 && Array.isArray( values[0] ) ) {
+		return values[0];
+	}
+	return values;
+}
+
+const ZMath = {
+	pi: PI,
+	sin( value ) { return Math.sin( Number( value ?? 0 ) ); },
+	cos( value ) { return Math.cos( Number( value ?? 0 ) ); },
+	tan( value ) { return Math.tan( Number( value ?? 0 ) ); },
+	asin( value ) { return Math.asin( Number( value ?? 0 ) ); },
+	acos( value ) { return Math.acos( Number( value ?? 0 ) ); },
+	atan( value ) { return Math.atan( Number( value ?? 0 ) ); },
+	atan2( y, x ) { return Math.atan2( Number( y ?? 0 ), Number( x ?? 0 ) ); },
+	pow( base, exp ) { return Math.pow( Number( base ?? 0 ), Number( exp ?? 0 ) ); },
+	exp( value ) { return Math.exp( Number( value ?? 0 ) ); },
+	log( value ) { return Math.log( Number( value ?? 0 ) ); },
+	log10( value ) { return Math.log10( Number( value ?? 0 ) ); },
+	min( ...values ) { return Math.min( ...normalizeNumberArgs( values ).map( Number ) ); },
+	max( ...values ) { return Math.max( ...normalizeNumberArgs( values ).map( Number ) ); },
+	sum( ...values ) { return normalizeNumberArgs( values ).map( Number ).reduce( ( acc, v ) => acc + v, 0 ); },
+	clamp( value, low, high ) {
+		return Math.min( Number( high ?? 0 ), Math.max( Number( low ?? 0 ), Number( value ?? 0 ) ) );
+	},
+	hypot( ...values ) { return Math.hypot( ...values.map( Number ) ); },
+	deg2rad( degrees ) { return Number( degrees ?? 0 ) * ( PI / 180 ); },
+	rad2deg( radians ) { return Number( radians ?? 0 ) * ( 180 / PI ); },
+	rand() { return Math.random(); },
+	hex2dec( value ) { return convertBase( value, 16, 10 ); },
+	hex2oct( value ) { return convertBase( value, 16, 8 ); },
+	hex2bin( value ) { return convertBase( value, 16, 2 ); },
+	dec2hex( value ) { return convertBase( value, 10, 16 ); },
+	dec2oct( value ) { return convertBase( value, 10, 8 ); },
+	dec2bin( value ) { return convertBase( value, 10, 2 ); },
+	oct2hex( value ) { return convertBase( value, 8, 16 ); },
+	oct2dec( value ) { return convertBase( value, 8, 10 ); },
+	oct2bin( value ) { return convertBase( value, 8, 2 ); },
+	bin2hex( value ) { return convertBase( value, 2, 16 ); },
+	bin2dec( value ) { return convertBase( value, 2, 10 ); },
+	bin2oct( value ) { return convertBase( value, 2, 8 ); },
+};
+
+function normalizeDigits( value, base ) {
+	let text = String( value ?? '' ).trim().toLowerCase();
+	if ( base === 16 ) {
+		text = text.replace( /^0x/u, '' );
+	}
+	else if ( base === 8 ) {
+		text = text.replace( /^0o/u, '' );
+	}
+	else if ( base === 2 ) {
+		text = text.replace( /^0b/u, '' );
+	}
+	return text;
+}
+
+function convertBase( value, fromBase, toBase ) {
+	const text = normalizeDigits( value, fromBase );
+	if ( text === '' ) {
+		return '0';
+	}
+	const num = Number.parseInt( text, fromBase );
+	if ( Number.isNaN( num ) ) {
+		return '0';
+	}
+	return num.toString( toBase );
+}
+
+module.exports = {
+	Math: ZMath,
+	pi: PI,
+	π: PI,
+};

package/modules/std/net/dns.js

@@ -0,0 +1,306 @@
+'use strict';
+
+const { spawnSync } = require( 'node:child_process' );
+const dns = require( 'node:dns' );
+const { Task, traceBlockingOperation } = require( '../task' );
+
+let runtimePolicy = {};
+
+const SUPPORTED = new Set( [
+	'A',
+	'AAAA',
+	'CNAME',
+	'MX',
+	'NS',
+	'PTR',
+	'SRV',
+	'TXT',
+] );
+
+function __zuzu_set_runtime_policy( policy = {} ) {
+	runtimePolicy = policy || {};
+}
+
+function _requireDns() {
+	if ( runtimePolicy.deny_net || runtimePolicy.host_name === 'browser' ) {
+		throw new Error( 'DNSException: std/net/dns is unsupported in this runtime' );
+	}
+}
+
+function _type( value = 'A' ) {
+	const type = String( value ?? 'A' ).toUpperCase();
+	if ( !SUPPORTED.has( type ) ) {
+		throw new Error( `DNSException: unsupported DNS record type '${type}'` );
+	}
+	return type;
+}
+
+function _family( value = 'any' ) {
+	const family = String( value ?? 'any' ).toLowerCase();
+	if ( ![ 'any', 'ipv4', 'ipv6' ].includes( family ) ) {
+		throw new Error( `DNSException: unsupported address family '${family}'` );
+	}
+	return family;
+}
+
+function _noData( err ) {
+	return err && [ 'ENODATA', 'ENOTFOUND', 'ENODOMAIN' ].includes( err.code );
+}
+
+function _expectArity( name, count, min, max ) {
+	if ( count >= min && count <= max ) {
+		return;
+	}
+	const range = min === max ? String( min ) : `${min} or ${max}`;
+	throw new Error( `DNSException: ${name} expects ${range} arguments` );
+}
+
+function _record( type, name, item ) {
+	const out = {
+		type,
+		name: String( name ?? '' ),
+		value: null,
+		ttl: null,
+	};
+	if ( type === 'A' || type === 'AAAA' ) {
+		out.address = typeof item === 'string' ? item : String( item.address ?? '' );
+		out.value = out.address;
+		if ( item && typeof item === 'object' && item.ttl != null ) {
+			out.ttl = Number( item.ttl );
+		}
+	}
+	else if ( type === 'CNAME' || type === 'NS' || type === 'PTR' ) {
+		out.target = String( item ?? '' );
+		out.value = out.target;
+	}
+	else if ( type === 'MX' ) {
+		out.exchange = String( item.exchange ?? '' );
+		out.preference = Number( item.priority ?? item.preference ?? 0 );
+		out.value = out.exchange;
+	}
+	else if ( type === 'TXT' ) {
+		const strings = Array.isArray( item ) ? item.map( String ) : [ String( item ?? '' ) ];
+		out.strings = strings;
+		out.text = strings.join( '' );
+		out.value = out.text;
+	}
+	else if ( type === 'SRV' ) {
+		out.target = String( item.name ?? item.target ?? '' );
+		out.port = Number( item.port ?? 0 );
+		out.priority = Number( item.priority ?? 0 );
+		out.weight = Number( item.weight ?? 0 );
+		out.value = out.target;
+	}
+	return out;
+}
+
+async function _lookupAsync( name, recordType = 'A' ) {
+	_requireDns();
+	const type = _type( recordType );
+	const query = String( name ?? '' );
+	try {
+		let records;
+		if ( type === 'A' ) {
+			records = await dns.promises.resolve4( query, { ttl: true } );
+		}
+		else if ( type === 'AAAA' ) {
+			records = await dns.promises.resolve6( query, { ttl: true } );
+		}
+		else {
+			records = await dns.promises.resolve( query, type );
+		}
+		return records.map( (item) => _record( type, query, item ) );
+	}
+	catch ( err ) {
+		if ( _noData( err ) ) {
+			return [];
+		}
+		throw new Error( `DNSException: ${err.message || err.code || err}` );
+	}
+}
+
+async function _addressesAsync( name, family = 'any' ) {
+	_requireDns();
+	const selected = _family( family );
+	const query = String( name ?? '' );
+	const familyNumber = selected === 'ipv4' ? 4 : selected === 'ipv6' ? 6 : 0;
+	try {
+		const records = await dns.promises.lookup( query, {
+			all: true,
+			family: familyNumber,
+		} );
+		return records.map( (item) => item.address );
+	}
+	catch ( err ) {
+		if ( _noData( err ) ) {
+			return [];
+		}
+		throw new Error( `DNSException: ${err.message || err.code || err}` );
+	}
+}
+
+async function _reverseAsync( address ) {
+	_requireDns();
+	try {
+		return await dns.promises.reverse( String( address ?? '' ) );
+	}
+	catch ( err ) {
+		if ( _noData( err ) ) {
+			return [];
+		}
+		throw new Error( `DNSException: ${err.message || err.code || err}` );
+	}
+}
+
+function _nodeChildOptions() {
+	const options = {
+		encoding: 'utf8',
+	};
+	if ( runtimePolicy.host_name === 'electron' ) {
+		options.env = {
+			...process.env,
+			ELECTRON_RUN_AS_NODE: '1',
+		};
+	}
+	return options;
+}
+
+function _emptyResponseError( child ) {
+	const detail = String( child.stderr || '' ).trim()
+		|| (
+			Number.isInteger( child.status )
+				? `exit ${child.status}`
+				: ''
+		)
+		|| (
+			child.signal
+				? `signal ${child.signal}`
+				: ''
+		)
+		|| 'empty resolver response';
+	return `empty resolver response (${detail})`;
+}
+
+function _syncRun( op, args ) {
+	_requireDns();
+	const source = `
+		const dns = require( 'node:dns' );
+		const payload = JSON.parse( process.argv[1] );
+		const noData = ( err ) => err && [ 'ENODATA', 'ENOTFOUND', 'ENODOMAIN' ].includes( err.code );
+		const record = ${_record.toString()};
+		(async () => {
+			try {
+				let result;
+				if ( payload.op === 'lookup' ) {
+					if ( payload.args[1] === 'A' ) {
+						result = ( await dns.promises.resolve4( payload.args[0], { ttl: true } ) )
+							.map( ( item ) => record( 'A', payload.args[0], item ) );
+					}
+					else if ( payload.args[1] === 'AAAA' ) {
+						result = ( await dns.promises.resolve6( payload.args[0], { ttl: true } ) )
+							.map( ( item ) => record( 'AAAA', payload.args[0], item ) );
+					}
+					else {
+						result = ( await dns.promises.resolve( payload.args[0], payload.args[1] ) )
+							.map( ( item ) => record( payload.args[1], payload.args[0], item ) );
+					}
+				}
+				else if ( payload.op === 'addresses' ) {
+					const family = payload.args[1] === 'ipv4' ? 4 : payload.args[1] === 'ipv6' ? 6 : 0;
+					result = ( await dns.promises.lookup( payload.args[0], { all: true, family } ) )
+						.map( ( item ) => item.address );
+				}
+				else if ( payload.op === 'reverse' ) {
+					result = await dns.promises.reverse( payload.args[0] );
+				}
+				process.stdout.write( JSON.stringify( { ok: true, result } ) );
+			}
+			catch ( err ) {
+				if ( noData( err ) ) {
+					process.stdout.write( JSON.stringify( { ok: true, result: [] } ) );
+					return;
+				}
+				process.stdout.write( JSON.stringify( {
+					ok: false,
+					error: err && ( err.message || err.code ) ? err.message || err.code : String( err ),
+				} ) );
+			}
+		})().catch( ( err ) => {
+			process.stdout.write( JSON.stringify( { ok: false, error: String( err ) } ) );
+		} );
+	`;
+	const payload = JSON.stringify( { op, args } );
+	const child = spawnSync( process.execPath, [ '-e', source, payload ], {
+		..._nodeChildOptions(),
+	});
+	if ( child.error ) {
+		throw new Error( `DNSException: ${child.error.message}` );
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(
+			child.stdout || JSON.stringify( {
+				ok: false,
+				error: _emptyResponseError( child ),
+			} )
+		);
+	}
+	catch ( err ) {
+		throw new Error(
+			`DNSException: invalid resolver response: ${err.message}`
+		);
+	}
+	if ( !parsed.ok ) {
+		throw new Error( `DNSException: ${parsed.error}` );
+	}
+	return parsed.result;
+}
+
+function lookup( name, recordType = 'A' ) {
+	_expectArity( 'lookup()', arguments.length, 1, 2 );
+	traceBlockingOperation( 'std/net/dns lookup' );
+	return _syncRun( 'lookup', [ String( name ?? '' ), _type( recordType ) ] );
+}
+
+function lookup_async( name, recordType = 'A' ) {
+	_expectArity( 'lookup_async()', arguments.length, 1, 2 );
+	return new Task( () => _lookupAsync( name, recordType ), {
+		name: 'dns.lookup_async',
+	} );
+}
+
+function addresses( name, family = 'any' ) {
+	_expectArity( 'addresses()', arguments.length, 1, 2 );
+	traceBlockingOperation( 'std/net/dns addresses' );
+	return _syncRun( 'addresses', [ String( name ?? '' ), _family( family ) ] );
+}
+
+function addresses_async( name, family = 'any' ) {
+	_expectArity( 'addresses_async()', arguments.length, 1, 2 );
+	return new Task( () => _addressesAsync( name, family ), {
+		name: 'dns.addresses_async',
+	} );
+}
+
+function reverse( address ) {
+	_expectArity( 'reverse()', arguments.length, 1, 1 );
+	traceBlockingOperation( 'std/net/dns reverse' );
+	return _syncRun( 'reverse', [ String( address ?? '' ) ] );
+}
+
+function reverse_async( address ) {
+	_expectArity( 'reverse_async()', arguments.length, 1, 1 );
+	return new Task( () => _reverseAsync( address ), {
+		name: 'dns.reverse_async',
+	} );
+}
+
+module.exports = {
+	__zuzu_set_runtime_policy,
+	lookup,
+	lookup_async,
+	addresses,
+	addresses_async,
+	reverse,
+	reverse_async,
+};