zuzu-js 0.2.0 → 0.4.0

package/modules/std/math/bignum.js

@@ -2,6 +2,12 @@
 
 class BigNum {
 	constructor( value, text = null, isInt = null ) {
+		if ( typeof value === 'bigint' ) {
+			this._value = value;
+			this._text = text == null ? String( value ) : String( text );
+			this._isInt = isInt == null ? true : Boolean( isInt );
+			return;
+		}
 		this._value = Number( value ?? 0 );
 		this._text = text == null ? String( this._value ) : String( text );
 		this._isInt = isInt == null ? Number.isInteger( this._value ) : Boolean( isInt );
@@ -19,22 +25,54 @@ class BigNum {
 
 	static from_dec( value ) {
 		const text = String( value ?? '0' ).trim();
-		return new BigNum( Number( text || '0' ), text || '0', !/[.eE]/.test( text ) );
+		const safeText = text || '0';
+		if ( BigNum._isIntegerText( safeText ) ) {
+			return new BigNum( BigInt( safeText ), safeText, true );
+		}
+		return new BigNum( Number( safeText ), safeText, !/[.eE]/.test( safeText ) );
 	}
 
 	static from_hex( value ) {
-		const text = String( value ?? '0' ).trim().toLowerCase().replace( /^0x/u, '' ) || '0';
-		const parsed = Number.parseInt( text, 16 );
+		const text = String( value ?? '0' ).trim().replace( /^0x/u, '' ).toLowerCase() || '0';
+		const negative = text.startsWith( '-' );
+		const digits = text.replace( /^[+-]/u, '' );
+		const parsed = BigInt( `0x${digits}` ) * ( negative ? -1n : 1n );
 		return new BigNum( parsed, String( parsed ), true );
 	}
 
-	get is_int() {
+	is_int() {
 		return this._isInt;
 	}
 
+	_toBigInt() {
+		if ( !this._isInt ) {
+			return null;
+		}
+		if ( typeof this._value === 'bigint' ) {
+			return this._value;
+		}
+		try {
+			return BigInt( this._text );
+		}
+		catch {
+			return null;
+		}
+	}
+
+	_toNumber() {
+		return typeof this._value === 'bigint' ? Number( this._value ) : this._value;
+	}
+
 	bcmp( other ) {
-		const rhs = BigNum._coerce( other )._value;
-		return this._value < rhs ? -1 : ( this._value > rhs ? 1 : 0 );
+		const rhs = BigNum._coerce( other );
+		const lhsBigInt = this._toBigInt();
+		const rhsBigInt = rhs._toBigInt();
+		if ( lhsBigInt !== null && rhsBigInt !== null ) {
+			return lhsBigInt < rhsBigInt ? -1 : ( lhsBigInt > rhsBigInt ? 1 : 0 );
+		}
+		return this._toNumber() < rhs._toNumber()
+			? -1
+			: ( this._toNumber() > rhs._toNumber() ? 1 : 0 );
 	}
 
 	beq( other ) { return this.bcmp( other ) === 0; }
@@ -44,45 +82,134 @@ class BigNum {
 	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 ) ); }
+	babs() {
+		const value = this._toBigInt();
+		if ( value !== null ) {
+			return new BigNum( value < 0n ? -value : value, String( value < 0n ? -value : value ), this._isInt );
+		}
+		return new BigNum( Math.abs( this._toNumber() ), String( Math.abs( this._toNumber() ) ), this._isInt );
+	}
+
+	bneg() {
+		const value = this._toBigInt();
+		if ( value !== null ) {
+			return new BigNum( -value, String( -value ), this._isInt );
+		}
+		return new BigNum( -this._toNumber(), String( -this._toNumber() ), this._isInt );
+	}
+
+	binv() { return new BigNum( 1 / this._toNumber() ); }
+	bsin() { return new BigNum( Math.sin( this._toNumber() ), String( Math.sin( this._toNumber() ) ), false ); }
+	bcos() { return new BigNum( Math.cos( this._toNumber() ) ); }
+	btan() { return new BigNum( Math.tan( this._toNumber() ), String( Math.tan( this._toNumber() ) ), false ); }
+	bsqrt() { return new BigNum( Math.sqrt( this._toNumber() ) ); }
+	bround() { return new BigNum( Math.round( this._toNumber() ) ); }
+	bfloor() { return new BigNum( Math.floor( this._toNumber() ) ); }
+	bceil() { return new BigNum( Math.ceil( this._toNumber() ) ); }
+
+	badd( other ) {
+		const rhs = BigNum._coerce( other );
+		const lhsInt = this._toBigInt();
+		const rhsInt = rhs._toBigInt();
+		if ( lhsInt !== null && rhsInt !== null ) {
+			return new BigNum( lhsInt + rhsInt, String( lhsInt + rhsInt ), false );
+		}
+		return new BigNum( this._toNumber() + rhs._toNumber(), String( this._toNumber() + rhs._toNumber() ), false );
+	}
+
+	bsub( other ) {
+		const rhs = BigNum._coerce( other );
+		const lhsInt = this._toBigInt();
+		const rhsInt = rhs._toBigInt();
+		if ( lhsInt !== null && rhsInt !== null ) {
+			return new BigNum( lhsInt - rhsInt, String( lhsInt - rhsInt ), false );
+		}
+		return new BigNum( this._toNumber() - rhs._toNumber(), String( this._toNumber() - rhs._toNumber() ), false );
+	}
+
+	bmul( other ) {
+		const rhs = BigNum._coerce( other );
+		const lhsInt = this._toBigInt();
+		const rhsInt = rhs._toBigInt();
+		if ( lhsInt !== null && rhsInt !== null ) {
+			return new BigNum( lhsInt * rhsInt, String( lhsInt * rhsInt ), false );
+		}
+		return new BigNum( this._toNumber() * rhs._toNumber(), String( this._toNumber() * rhs._toNumber() ), false );
+	}
 
-	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 ); }
+	bdiv( other ) {
+		const rhs = BigNum._coerce( other );
+		return new BigNum( this._toNumber() / rhs._toNumber() );
+	}
+
+	bmod( other ) {
+		const rhs = BigNum._coerce( other );
+		const lhsInt = this._toBigInt();
+		const rhsInt = rhs._toBigInt();
+		if ( lhsInt !== null && rhsInt !== null && rhsInt !== 0n ) {
+			return new BigNum( lhsInt % rhsInt, String( lhsInt % rhsInt ), true );
+		}
+		return new BigNum( this._toNumber() % rhs._toNumber() );
+	}
+	bpow( other ) {
+		const rhs = BigNum._coerce( other );
+		const lhsInt = this._toBigInt();
+		const rhsInt = rhs._toBigInt();
+		if ( lhsInt !== null && rhsInt !== null && rhsInt >= 0n ) {
+			let base = lhsInt;
+			let power = rhsInt;
+			let result = 1n;
+			while ( power > 0n ) {
+				if ( power & 1n ) {
+					result *= base;
+				}
+				power >>= 1n;
+				if ( power > 0n ) {
+					base *= base;
+				}
+			}
+			return new BigNum( result, String( result ), true );
+		}
+		return new BigNum( this._toNumber() ** rhs._toNumber() );
+	}
+
+	to_hex() {
+		const value = this._toBigInt();
+		if ( value === null ) {
+			return `0x${Math.trunc( this._toNumber() ).toString( 16 )}`;
+		}
+		if ( value === 0n ) {
+			return '0x0';
+		}
+		const absolute = value < 0n ? -value : value;
+		return value < 0n ? `-0x${ absolute.toString( 16 ) }` : `0x${ absolute.toString( 16 ) }`;
+	}
+
+	to_dec() {
+		return this._textify();
+	}
 
-	get to_hex() {
-		return `0x${Math.trunc( this._value ).toString( 16 )}`;
+	to_String() {
+		return this.to_dec();
 	}
 
-	get to_dec() {
-		return this._isInt ? Math.trunc( this._value ) : this._textify();
+	toString() {
+		return String( this.to_String() );
 	}
 
-	get to_String() {
-		return this.to_dec;
+	to_Number() {
+		return this._toNumber();
 	}
 
-	get to_Number() {
-		return this._value;
+	static _isIntegerText( text ) {
+		return /^[+-]?(?:\d+)$/u.test( text );
 	}
 
 	_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 );
+		return this._toBigInt() !== null ? this._toBigInt().toString() : String( this._value );
 	}
 }
 

package/modules/std/math.js

@@ -10,7 +10,7 @@ function normalizeNumberArgs( values ) {
 }
 
 const ZMath = {
-	pi: PI,
+	pi() { return 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 ) ); },

package/modules/std/net/url.js

@@ -68,37 +68,46 @@ function parse( value ) {
 	return out;
 }
 
-function _templateVar( values, name ) {
-	if ( values[name] == null ) {
-		return '';
-	}
-	return encodeURIComponent( _str( values[name] ) );
-}
+const { StdUriTemplate } = require( '@std-uritemplate/std-uritemplate' );
 
-function _templateQuery( values, namesText ) {
-	const names = String( namesText )
-		.split( /\s*,\s*/u )
-		.filter( Boolean );
-	const parts = [];
-	for ( const name of names ) {
-		if ( values[name] == null ) {
-			continue;
+function _templateValue( value ) {
+	if ( value == null ) {
+		return null;
+	}
+	if ( Array.isArray( value ) ) {
+		return value.map( (item) => _str( item ) );
+	}
+	if ( typeof value === 'boolean' ) {
+		return value ? 'true' : 'false';
+	}
+	if ( typeof value === 'object' && !( value.bytes instanceof Uint8Array ) ) {
+		// Associative values: keys sorted for deterministic expansion.
+		const out = {};
+		for ( const key of Object.keys( value ).sort() ) {
+			out[key] = _str( value[key] );
 		}
-		const key = encodeURIComponent( name );
-		const val = encodeURIComponent( _str( values[name] ) );
-		parts.push( `${key}=${val}` );
+		return out;
 	}
-	return parts.length > 0 ? `?${parts.join( '&' )}` : '';
+	return _str( value );
 }
 
 function fill_template( template, values ) {
 	const source = _str( template );
-	const data = values && typeof values === 'object' && !Array.isArray( values )
-		? values
-		: {};
-	return source
-		.replace( /\{\?([^}]+)\}/gu, ( _, names ) => _templateQuery( data, names ) )
-		.replace( /\{([a-zA-Z_][a-zA-Z0-9_]*)\}/gu, ( _, name ) => _templateVar( data, name ) );
+	const data = {};
+	if ( values && typeof values === 'object' && !Array.isArray( values ) ) {
+		for ( const key of Object.keys( values ) ) {
+			const converted = _templateValue( values[key] );
+			if ( converted != null ) {
+				data[key] = converted;
+			}
+		}
+	}
+	try {
+		return StdUriTemplate.expand( source, data );
+	}
+	catch ( err ) {
+		throw new Error( `Exception: invalid URL template: ${source}` );
+	}
 }
 
 module.exports = {

package/modules/std/string/encode.js

@@ -0,0 +1,188 @@
+'use strict';
+
+// std/string/encode: character-encoding conversions between String and
+// BinaryString. UTF-16 and UTF-32 encode to big-endian without a BOM (the
+// deterministic canonical form shared by all runtimes); decode honours a
+// leading BOM and otherwise assumes big-endian.
+
+const { BinaryString } = require( '../../../lib/runtime-helpers' );
+
+function typeName( value ) {
+	if ( value == null ) {
+		return 'Null';
+	}
+	if ( typeof value === 'string' || value instanceof String ) {
+		return 'String';
+	}
+	if ( value.bytes instanceof Uint8Array ) {
+		return 'BinaryString';
+	}
+	return value.constructor && value.constructor.name ? value.constructor.name : typeof value;
+}
+
+function canonicalEncoding( name ) {
+	const upper = String( name == null ? 'UTF-8' : name ).toUpperCase().replace( /\s+/g, '' );
+	if ( upper === 'UTF-8' || upper === 'UTF8' ) {
+		return 'utf8';
+	}
+	if ( upper === 'UTF-16' || upper === 'UTF16' || upper === 'UTF-16BE' ) {
+		return 'utf16';
+	}
+	if ( upper === 'UTF-32' || upper === 'UTF32' || upper === 'UTF-32BE' ) {
+		return 'utf32';
+	}
+	if (
+		upper === 'ISO-8859-1' || upper === 'ISO8859-1'
+		|| upper === 'LATIN-1' || upper === 'LATIN1' || upper === 'LATIN'
+	) {
+		return 'latin1';
+	}
+	return null;
+}
+
+function codePoints( text ) {
+	return Array.from( text, (ch) => ch.codePointAt( 0 ) );
+}
+
+function encode( value, encoding ) {
+	if ( typeName( value ) !== 'String' ) {
+		throw new Error( `TypeException: encode expects String, got ${typeName( value )}` );
+	}
+	const text = String( value );
+	const codec = canonicalEncoding( encoding );
+	if ( codec === 'utf8' ) {
+		return new BinaryString( new TextEncoder().encode( text ) );
+	}
+	if ( codec === 'utf16' ) {
+		const out = [];
+		for ( let i = 0; i < text.length; i++ ) {
+			const unit = text.charCodeAt( i );
+			out.push( ( unit >> 8 ) & 0xff, unit & 0xff );
+		}
+		return new BinaryString( out );
+	}
+	if ( codec === 'utf32' ) {
+		const out = [];
+		for ( const point of codePoints( text ) ) {
+			out.push(
+				( point >>> 24 ) & 0xff,
+				( point >>> 16 ) & 0xff,
+				( point >>> 8 ) & 0xff,
+				point & 0xff,
+			);
+		}
+		return new BinaryString( out );
+	}
+	if ( codec === 'latin1' ) {
+		const out = [];
+		for ( const point of codePoints( text ) ) {
+			if ( point > 0xff ) {
+				const hex = point.toString( 16 ).toUpperCase().padStart( 4, '0' );
+				throw new Error( `Exception: Character U+${hex} cannot be encoded as ISO-8859-1` );
+			}
+			out.push( point );
+		}
+		return new BinaryString( out );
+	}
+	throw new Error( `Exception: Unsupported encoding: ${encoding}` );
+}
+
+function decode( value, encoding ) {
+	if ( typeName( value ) !== 'BinaryString' ) {
+		throw new Error( `TypeException: decode expects BinaryString, got ${typeName( value )}` );
+	}
+	let bytes = value.bytes;
+	const codec = canonicalEncoding( encoding );
+	if ( codec === 'utf8' ) {
+		try {
+			return new TextDecoder( 'utf-8', { fatal: true } ).decode( bytes );
+		}
+		catch ( _err ) {
+			throw new Error( 'Exception: Invalid UTF-8 in BinaryString' );
+		}
+	}
+	if ( codec === 'utf16' ) {
+		let bigEndian = true;
+		if ( bytes.length >= 2 && bytes[0] === 0xfe && bytes[1] === 0xff ) {
+			bytes = bytes.subarray( 2 );
+		}
+		else if ( bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xfe ) {
+			bigEndian = false;
+			bytes = bytes.subarray( 2 );
+		}
+		if ( bytes.length % 2 !== 0 ) {
+			throw new Error( 'Exception: UTF-16 input length must be a multiple of 2 bytes' );
+		}
+		const units = [];
+		for ( let i = 0; i < bytes.length; i += 2 ) {
+			units.push( bigEndian
+				? ( bytes[i] << 8 ) | bytes[i + 1]
+				: ( bytes[i + 1] << 8 ) | bytes[i] );
+		}
+		let out = '';
+		for ( let i = 0; i < units.length; i++ ) {
+			const unit = units[i];
+			if ( unit >= 0xd800 && unit <= 0xdbff ) {
+				const next = units[i + 1];
+				if ( next == null || next < 0xdc00 || next > 0xdfff ) {
+					throw new Error( 'Exception: Invalid UTF-16 in BinaryString' );
+				}
+				out += String.fromCharCode( unit, next );
+				i++;
+				continue;
+			}
+			if ( unit >= 0xdc00 && unit <= 0xdfff ) {
+				throw new Error( 'Exception: Invalid UTF-16 in BinaryString' );
+			}
+			out += String.fromCharCode( unit );
+		}
+		return out;
+	}
+	if ( codec === 'utf32' ) {
+		let bigEndian = true;
+		if (
+			bytes.length >= 4
+			&& bytes[0] === 0x00 && bytes[1] === 0x00 && bytes[2] === 0xfe && bytes[3] === 0xff
+		) {
+			bytes = bytes.subarray( 4 );
+		}
+		else if (
+			bytes.length >= 4
+			&& bytes[0] === 0xff && bytes[1] === 0xfe && bytes[2] === 0x00 && bytes[3] === 0x00
+		) {
+			bigEndian = false;
+			bytes = bytes.subarray( 4 );
+		}
+		if ( bytes.length % 4 !== 0 ) {
+			throw new Error( 'Exception: UTF-32 input length must be a multiple of 4 bytes' );
+		}
+		let out = '';
+		for ( let i = 0; i < bytes.length; i += 4 ) {
+			const point = bigEndian
+				? ( bytes[i] * 0x1000000 ) + ( bytes[i + 1] << 16 ) + ( bytes[i + 2] << 8 ) + bytes[i + 3]
+				: ( bytes[i + 3] * 0x1000000 ) + ( bytes[i + 2] << 16 ) + ( bytes[i + 1] << 8 ) + bytes[i];
+			if ( point > 0x10ffff || ( point >= 0xd800 && point <= 0xdfff ) ) {
+				throw new Error( 'Exception: Invalid UTF-32 in BinaryString' );
+			}
+			out += String.fromCodePoint( point );
+		}
+		return out;
+	}
+	if ( codec === 'latin1' ) {
+		let out = '';
+		for ( const byte of bytes ) {
+			out += String.fromCharCode( byte );
+		}
+		return out;
+	}
+	throw new Error( `Exception: Unsupported encoding: ${encoding}` );
+}
+
+module.exports = {
+	encode,
+	decode,
+	ENCODING_UTF8: 'UTF-8',
+	ENCODING_UTF16: 'UTF-16',
+	ENCODING_UTF32: 'UTF-32',
+	ENCODING_LATIN: 'ISO-8859-1',
+};

package/modules/std/string.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { BinaryString } = require( '../../lib/runtime-helpers' );
+
 function toStringValue( value ) {
 	if ( value instanceof RegExp ) {
 		return value.source;
@@ -272,6 +274,23 @@ function camel( text ) {
 	return ws.map( (w, i) => ( i === 0 ? w : `${w[0].toUpperCase()}${w.slice( 1 )}` ) ).join( '' );
 }
 
+function to_binary( value ) {
+	if ( typeof value !== 'string' && !( value instanceof String ) ) {
+		const type = value == null
+			? 'Null'
+			: ( value && value.bytes instanceof Uint8Array ) ? 'BinaryString' : typeof value;
+		throw new Error( `TypeException: to_binary expects String, got ${type}` );
+	}
+	return new BinaryString( new TextEncoder().encode( String( value ) ) );
+}
+
+function to_string( value ) {
+	if ( !( value && value.bytes instanceof Uint8Array ) ) {
+		throw new Error( 'TypeException: to_string expects BinaryString' );
+	}
+	return new TextDecoder( 'utf-8', { fatal: true } ).decode( value.bytes );
+}
+
 module.exports = {
 	camel,
 	chomp,
@@ -295,5 +314,7 @@ module.exports = {
 	sprint,
 	substr,
 	title,
+	to_binary,
+	to_string,
 	trim,
 };

package/modules/std/time.js

@@ -15,6 +15,7 @@ const MONTH_BY_NAME = new Map( [
 	[ 'nov', 11 ], [ 'november', 11 ],
 	[ 'dec', 12 ], [ 'december', 12 ],
 ] );
+const DAY_ABBR = [ 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' ];
 const WEEKDAY_BY_NAME = new Set( [
 	'sun', 'sunday',
 	'mon', 'monday',
@@ -63,14 +64,72 @@ function offsetSeconds( zone ) {
 	return m[1] === '-' ? -seconds : seconds;
 }
 
-function pad( value, width = 2 ) {
-	return String( value ).padStart( width, '0' );
+function pad( value, width = 2, fill = '0' ) {
+	return String( value ).padStart( width, fill );
 }
 
 function stripTrailingPeriod( text ) {
 	return String( text ).replace( /\.+$/u, '' ).toLowerCase();
 }
 
+function weekdayIndex( parts ) {
+	const date = new Date(
+		parts.year,
+		parts.month - 1,
+		parts.day
+	);
+	return ( ( date.getDay() + 6 ) % 7 ) + 1;
+}
+
+function weekParts( parts ) {
+	const date = new Date(
+		parts.year,
+		parts.month - 1,
+		parts.day
+	);
+	const weekDay = date.getDay() || 7;
+	const shifted = new Date( date );
+	shifted.setDate( date.getDate() + 4 - weekDay );
+	const weekYear = shifted.getFullYear();
+	const yearStart = new Date( weekYear, 0, 1 );
+	return {
+		year: weekYear,
+		week: Math.ceil( ( shifted - yearStart ) / 86400000 / 7 + 1 ),
+	};
+}
+
+function dayOfMonthForDisplay( day ) {
+	return String( day ).padStart( 2, ' ' );
+}
+
+function dayOfYear( parts ) {
+	const start = new Date( parts.year, 0, 1 );
+	const now = new Date( parts.year, parts.month - 1, parts.day );
+	return ( now - start ) / 86400000;
+}
+
+function julianDay( parts ) {
+	let year = parts.year;
+	let month = parts.month;
+	const day = parts.day;
+	if ( month <= 2 ) {
+		year -= 1;
+		month += 12;
+	}
+	const a = Math.floor( ( 14 - month ) / 12 );
+	const y = year + 4800 - a;
+	const m = month + 12 * a - 3;
+	const jd = day
+		+ Math.floor( ( 153 * m + 2 ) / 5 )
+		+ 365 * y
+		+ Math.floor( y / 4 )
+		- Math.floor( y / 100 )
+		+ Math.floor( y / 400 )
+		- 32045;
+	const fraction = ( parts.hour * 3600 + parts.minute * 60 + parts.second ) / 86400;
+	return jd + fraction - 0.5;
+}
+
 function isLeapYear( year ) {
 	if ( year % 4 !== 0 ) return false;
 	if ( year % 100 !== 0 ) return true;
@@ -435,6 +494,39 @@ class Time {
 	mon() { return this._parts().month; }
 	month() { return this.mon(); }
 	year() { return this._parts().year; }
+	yy() { return pad( this._parts().year % 100, 2 ); }
+	day_of_week() { return weekdayIndex( this._parts() ); }
+	day() { return DAY_ABBR[ this.day_of_week() - 1 ]; }
+	day_of_year() { return dayOfYear( this._parts() ); }
+	month_last_day() { return daysInMonth( this._parts().year, this._parts().month ); }
+	hms( separator = ':' ) {
+		const p = this._parts();
+		return `${pad( p.hour )}${String( separator )}${pad( p.minute )}${String( separator )}${pad( p.second )}`;
+	}
+	ymd( separator = '-' ) {
+		const p = this._parts();
+		const sep = String( separator );
+		return `${pad( p.year, 4 )}${sep}${pad( p.month )}${sep}${pad( p.day )}`;
+	}
+	mdy( separator = '-' ) {
+		const p = this._parts();
+		const sep = String( separator );
+		return `${pad( p.month )}${sep}${pad( p.day )}${sep}${pad( p.year, 4 )}`;
+	}
+	dmy( separator = '-' ) {
+		const p = this._parts();
+		const sep = String( separator );
+		return `${pad( p.day )}${sep}${pad( p.month )}${sep}${pad( p.year, 4 )}`;
+	}
+	cdate() {
+		const p = this._parts();
+		return `${DAY_ABBR[ weekdayIndex( p ) - 1 ]} ${MONTHS[p.month - 1]} ${dayOfMonthForDisplay( p.day )} ${pad( p.hour )}:${pad( p.minute )}:${pad( p.second )} ${p.year}`;
+	}
+	tzoffset() { return offsetForEpoch( this._epoch, this._timezone ); }
+	is_leap_year() { return isLeapYear( this._parts().year ); }
+	week() { return weekParts( this._parts() ).week; }
+	week_year() { return weekParts( this._parts() ).year; }
+	julian_day() { return julianDay( this._parts() ); }
 	add_seconds( n ) { return this._clone( this._epoch + Number( n ) ); }
 	add_minutes( n ) { return this.add_seconds( Number( n ) * 60 ); }
 	add_hours( n ) { return this.add_seconds( Number( n ) * 3600 ); }
@@ -509,8 +601,7 @@ class Time {
 	}
 	to_rfc5322( options = {} ) {
 		const p = this._parts();
-		const d = new Date( Date.UTC( p.year, p.month - 1, p.day ) );
-		const weekday = [ 'Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat' ][ d.getUTCDay() ];
+		const weekday = DAY_ABBR[ weekdayIndex( p ) - 1 ];
 		const core = `${pad( p.day )} ${MONTHS[p.month - 1]} ${pad( p.year, 4 )} ${pad( p.hour )}:${pad( p.minute )}:${pad( p.second )} ${formatOffset( offsetForEpoch( this._epoch, this._timezone ), false )}`;
 		return options.include_weekday === false ? core : `${weekday}, ${core}`;
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zuzu-js",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "JavaScript runtime, compiler, and browser bundle for ZuzuScript.",
   "main": "lib/zuzu.js",
   "bin": {
@@ -48,6 +48,7 @@
     "node": ">=16"
   },
   "dependencies": {
+    "@std-uritemplate/std-uritemplate": "^2.0.10",
     "@xmldom/xmldom": "^0.9.10",
     "adm-zip": "^0.5.17",
     "better-sqlite3": "^11.10.0",