zuzu-js 0.2.0 → 0.4.0

package/stdlib/modules/std/colour.zzm

@@ -167,6 +167,7 @@ const _COLOUR_KEYWORDS := {
 	plum: "#dda0dd",
 	powderblue: "#b0e0e6",
 	purple: "#800080",
+	rebeccapurple: "#663399",
 	red: "#ff0000",
 	rosybrown: "#bc8f8f",
 	royalblue: "#4169e1",

package/stdlib/modules/std/config.zzm

@@ -534,11 +534,12 @@ class Config extends Node {
 	}
 
 	method clone () {
-		let cloned := new Config( raw: _merge_values( {}, self.raw, {} ) );
-		cloned._layers := _layers.to_Array();
-		cloned._source := _source;
-		cloned._format := _format;
-		return cloned;
+		return new Config(
+			raw: _merge_values( {}, self.raw, {} ),
+			_layers: _layers.copy(),
+			_source: _source,
+			_format: _format,
+		);
 	}
 
 	method _delegate_node () {

package/stdlib/modules/std/getopt.zzm

@@ -126,21 +126,6 @@ function _normalize_schema_type ( raw_type ) {
 	if ( raw_type ≡ null ) {
 		return "Boolean";
 	}
-	if ( raw_type instanceof Function ) {
-		let function_name := null;
-		try {
-			function_name := raw_type.name;
-		}
-		catch {
-		}
-		if (
-			function_name ≡ "Boolean" or
-			function_name ≡ "Number" or
-			function_name ≡ "String"
-		) {
-			return function_name;
-		}
-	}
 	if ( raw_type ≡ Boolean ) {
 		return "Boolean";
 	}
@@ -150,6 +135,9 @@ function _normalize_schema_type ( raw_type ) {
 	if ( raw_type ≡ String ) {
 		return "String";
 	}
+	if ( raw_type instanceof Function ) {
+		return "String";
+	}
 	let type_name := "" _ raw_type;
 	if ( type_name ≡ "" ) {
 		return "Boolean";

package/stdlib/modules/std/net/url.zzm

@@ -54,9 +54,51 @@ C<query_params>.
 
 =item C<< fill_template(template, values) >>
 
-Parameters: C<template> is an RFC6570-style template and C<values> is a
-dictionary or pair list. Returns: C<String>. Fills the template using
-C<values>.
+Parameters: C<template> is an RFC 6570 URI Template and C<values> is a
+dictionary or pair list of template variables. Returns: C<String>.
+Expands the template using C<values>.
+
+This is a complete implementation of RFC 6570 (all four levels),
+validated against the official URI Template test suite. All expression
+operators are supported:
+
+=over
+
+=item * C<{var}> - simple string expansion;
+
+=item * C<{+var}> - reserved expansion, leaving URI-reserved characters
+and percent-encoded triplets intact;
+
+=item * C<{#var}> - fragment expansion;
+
+=item * C<{.var}> - label expansion with a dot prefix;
+
+=item * C<{/var}> - path segment expansion;
+
+=item * C<{;var}> - path-style parameter expansion;
+
+=item * C<{?var}> - form-style query expansion;
+
+=item * C<{&var}> - form-style query continuation.
+
+=back
+
+Each variable in an expression may take the C<:N> prefix modifier
+(expand only the first I<N> characters of a string value, with I<N>
+between 1 and 9999) or the C<*> explode modifier (expand list and
+dictionary members as separate items), and expressions may name several
+variables separated by commas, for example C<{?q,page,lang}>.
+
+Variable values may be Strings (or Numbers and Booleans, which are
+rendered as text), Arrays (RFC 6570 list values), or Dicts and pair
+lists (RFC 6570 associative values; dictionary keys are expanded in
+sorted order). Variables that are null, missing, or empty lists or
+dictionaries are undefined per RFC 6570 and are omitted from the
+expansion.
+
+Invalid templates - unbalanced braces, unknown operators, malformed
+variable names or modifiers, or a C<:N> prefix applied to a list or
+dictionary value - throw an exception.
 
 =back
 

package/stdlib/modules/std/string/encode.zzm

@@ -0,0 +1,95 @@
+=encoding utf8
+
+=head1 NAME
+
+std/string/encode - Character-encoding conversions between Strings and BinaryStrings.
+
+=head1 SYNOPSIS
+
+  from std/string/encode import *;
+
+  let bytes := encode( "héllo", ENCODING_UTF16 );
+  let text := decode( bytes, "UTF-16" );
+
+=head1 IMPLEMENTATION SUPPORT
+
+This module is supported by all implementations of ZuzuScript.
+
+=head1 DESCRIPTION
+
+This module converts between text (C<String>) and encoded bytes
+(C<BinaryString>).
+
+All implementations support UTF-8, UTF-16, UTF-32, and ISO-8859-1
+(Latin-1). Implementations are encouraged to support additional
+encodings where the host platform makes that practical; programs that
+need to run on every implementation should restrict themselves to the
+four required encodings.
+
+Encoding names are matched case-insensitively, so C<"utf-8"> and
+C<"UTF-8"> are equivalent.
+
+For UTF-16 and UTF-32, C<encode> produces the canonical form: big-endian
+with no byte order mark. This is deterministic and identical across
+implementations. C<decode> honours a leading byte order mark (consuming
+it and switching to little-endian where it says so) and otherwise
+assumes big-endian input.
+
+Invalid input raises an exception: unknown encoding names, bytes that do
+not form valid text in the requested encoding, and characters that the
+target encoding cannot represent (for example, encoding C<"😀"> as
+ISO-8859-1) all throw.
+
+=head1 EXPORTS
+
+=head2 Functions
+
+=over
+
+=item * C<encode(String text, String encoding)>
+
+Parameters: C<text> is the text to encode; C<encoding> names the target
+encoding and defaults to C<"UTF-8">. Returns: C<BinaryString>. Encodes
+C<text> as bytes. Throws a TypeException if C<text> is not a C<String>,
+and an exception if the encoding is unknown or cannot represent a
+character in C<text>.
+
+=item * C<decode(BinaryString bytes, String encoding)>
+
+Parameters: C<bytes> is the encoded input; C<encoding> names the source
+encoding and defaults to C<"UTF-8">. Returns: C<String>. Decodes
+C<bytes> into text. Throws a TypeException if C<bytes> is not a
+C<BinaryString>, and an exception if the encoding is unknown or the
+bytes are not valid for it.
+
+=back
+
+=head2 Constants
+
+=over
+
+=item C<ENCODING_UTF8>
+
+Type: C<String>. The value C<"UTF-8">.
+
+=item C<ENCODING_UTF16>
+
+Type: C<String>. The value C<"UTF-16">.
+
+=item C<ENCODING_UTF32>
+
+Type: C<String>. The value C<"UTF-32">.
+
+=item C<ENCODING_LATIN>
+
+Type: C<String>. The value C<"ISO-8859-1">.
+
+=back
+
+=head1 COPYRIGHT AND LICENCE
+
+B<< std/string/encode >> is copyright Toby Inkster.
+
+It is free software; you may redistribute it and/or modify it under
+the terms of either the Artistic License 1.0 or the GNU General Public
+License version 2.