zuzu-js 0.6.0 → 0.7.1

package/dist/zuzu-browser-worker.js

@@ -1271,15 +1271,17 @@
       function runSwitch(value, cmpName, cases, defaultBody) {
         const cmp = buildComparator(cmpName);
         let runNext = false;
+        let matched = false;
         for (const section of cases) {
-          let matched = false;
+          let sectionMatched = false;
           if (Array.isArray(section.tests)) {
-            matched = section.tests.some((test) => switchTruthy(test(value)));
+            sectionMatched = section.tests.some((test) => switchTruthy(test(value)));
           } else {
-            matched = section.values.some((item) => cmp(value, item));
+            sectionMatched = section.values.some((item) => cmp(value, item));
           }
-          if (matched || runNext) {
-            const result = section.body();
+          if (sectionMatched || runNext) {
+            matched = true;
+            const result = section.body(value);
             runNext = result === true;
             if (!runNext && result && typeof result === "object" && result.__zuzu_return) {
               return result;
@@ -1289,8 +1291,8 @@
             }
           }
         }
-        if (defaultBody) {
-          const result = defaultBody();
+        if (defaultBody && (!matched || runNext)) {
+          const result = defaultBody(value);
           if (result && typeof result === "object" && result.__zuzu_return) {
             return result;
           }
@@ -1793,29 +1795,156 @@
       function replace(text, pattern, replacement, flags = "") {
         return toStringValue(text).replace(normalizePattern(pattern, flags), toStringValue(replacement));
       }
+      function formatWidth(text, width, flags, zeroPad = false) {
+        if (width == null) {
+          return text;
+        }
+        const target = Number(width);
+        const byteLength = new TextEncoder().encode(text).length;
+        if (byteLength >= target) {
+          return text;
+        }
+        const padChar = zeroPad && !flags.includes("-") ? "0" : " ";
+        const fill = padChar.repeat(target - byteLength);
+        if (flags.includes("-")) {
+          return `${text}${fill}`;
+        }
+        if (padChar === "0" && /^[+-]/u.test(text)) {
+          return `${text[0]}${fill}${text.slice(1)}`;
+        }
+        return `${fill}${text}`;
+      }
+      function formatInteger(value, radix, uppercase = false, signed = true) {
+        const number = Number(value ?? 0);
+        const integer = Math.trunc(number);
+        const negative = integer < 0;
+        const magnitude = signed ? Math.abs(integer) : integer >>> 0;
+        let rendered = magnitude.toString(radix);
+        if (uppercase) {
+          rendered = rendered.toUpperCase();
+        }
+        return signed && negative ? `-${rendered}` : rendered;
+      }
+      function signPrefix(rendered, number, flags) {
+        if (rendered.startsWith("-")) {
+          return rendered;
+        }
+        if (number < 0) {
+          return `-${rendered}`;
+        }
+        if (flags.includes("+")) {
+          return `+${rendered}`;
+        }
+        if (flags.includes(" ")) {
+          return ` ${rendered}`;
+        }
+        return rendered;
+      }
+      function normalizeExponent(rendered) {
+        return rendered.replace(/([eE][+-])(\d)$/u, "$10$2");
+      }
+      function trimGeneralFloat(rendered) {
+        return rendered.replace(/(\.\d*?)0+(e[+-]?\d+)$/iu, "$1$2").replace(/\.e/iu, "e").replace(/(\.\d*?)0+$/u, "$1").replace(/\.$/u, "");
+      }
+      function formatFloat(number, precision, kind) {
+        const digits = precision == null ? 6 : Number(precision);
+        if (kind === "f") {
+          return number.toFixed(digits);
+        }
+        if (kind === "e") {
+          return normalizeExponent(number.toExponential(digits));
+        }
+        if (kind === "E") {
+          return normalizeExponent(number.toExponential(digits).toUpperCase());
+        }
+        const significant = precision == null ? 6 : Number(precision);
+        const rendered = trimGeneralFloat(number.toPrecision(significant));
+        return kind === "G" ? rendered.toUpperCase() : rendered;
+      }
       function sprint(format, ...args) {
         let idx = 0;
-        return toStringValue(format).replace(/%([0-9]+)?(?:\.([0-9]+))?([sdfc])/gu, (_token, width, precision, kind) => {
+        const source = toStringValue(format);
+        return source.replace(/%([-+ 0#]*)([0-9]+)?(?:\.([0-9]+))?([sdiuoxXfeEgGc%])/gu, (token, rawFlags, width, precision, kind) => {
+          if (kind === "%") {
+            return "%";
+          }
           const value = args[idx++];
+          const flags = rawFlags || "";
           let out = "";
-          if (kind === "d") {
-            out = String(Math.trunc(Number(value ?? 0)));
-          } else if (kind === "f") {
-            const num = Number(value ?? 0);
-            out = precision != null ? num.toFixed(Number(precision)) : String(num);
+          let zeroPad = false;
+          if (kind === "s") {
+            out = toStringValue(value);
+            if (precision != null) {
+              out = [...out].slice(0, Number(precision)).join("");
+            }
+          } else if (kind === "d" || kind === "i") {
+            const number = Math.trunc(Number(value ?? 0));
+            out = signPrefix(String(Math.abs(number)), number, flags);
+            if (number < 0) {
+              out = `-${Math.abs(number)}`;
+            }
+            zeroPad = flags.includes("0");
+          } else if (kind === "u") {
+            out = formatInteger(value, 10, false, false);
+            zeroPad = flags.includes("0");
+          } else if (kind === "x" || kind === "X") {
+            out = formatInteger(value, 16, kind === "X", true);
+            if (flags.includes("#") && !out.startsWith("-") && Number(value ?? 0) !== 0) {
+              out = `${kind === "X" ? "0X" : "0x"}${out}`;
+            }
+            zeroPad = flags.includes("0");
+          } else if (kind === "o") {
+            out = formatInteger(value, 8, false, true);
+            if (flags.includes("#") && !out.startsWith("-") && !out.startsWith("0")) {
+              out = `0${out}`;
+            }
+            zeroPad = flags.includes("0");
+          } else if (kind === "f" || kind === "e" || kind === "E" || kind === "g" || kind === "G") {
+            const number = Number(value ?? 0);
+            const negative = number < 0 || Object.is(number, -0);
+            out = formatFloat(Math.abs(number), precision, kind);
+            out = signPrefix(out, negative ? -1 : number, flags);
+            zeroPad = flags.includes("0");
           } else if (kind === "c") {
-            out = String.fromCharCode(Number(value ?? 0));
+            out = String.fromCodePoint(Number(value ?? 0));
           } else {
-            out = toStringValue(value);
+            return token;
           }
-          if (width != null) {
-            const target = Number(width);
-            if (out.length < target) {
-              out = `${" ".repeat(target - out.length)}${out}`;
+          return formatWidth(out, width, flags, zeroPad);
+        });
+      }
+      function repeat(count, text, separator = null) {
+        if (arguments.length < 2 || arguments.length > 3) {
+          throw new Error("repeat() expects two or three arguments");
+        }
+        const repetitions = Math.floor(Number(count ?? 0));
+        if (repetitions < 0) {
+          throw new Error("repeat() count cannot be negative");
+        }
+        const textIsBinary = text instanceof BinaryString2;
+        const separatorIsBinary = separator instanceof BinaryString2;
+        if (separator != null && textIsBinary !== separatorIsBinary) {
+          throw new Error("TypeException: repeat() cannot mix String and BinaryString values");
+        }
+        if (textIsBinary) {
+          const source = text.bytes;
+          const sep2 = separator == null ? new Uint8Array(0) : separator.bytes;
+          const total = repetitions === 0 ? 0 : source.length * repetitions + sep2.length * (repetitions - 1);
+          const out = new Uint8Array(total);
+          let offset = 0;
+          for (let i = 0; i < repetitions; i++) {
+            if (i > 0) {
+              out.set(sep2, offset);
+              offset += sep2.length;
             }
+            out.set(source, offset);
+            offset += source.length;
           }
-          return out;
-        });
+          return new BinaryString2(out);
+        }
+        const value = toStringValue(text);
+        const sep = separator == null ? "" : toStringValue(separator);
+        return Array.from({ length: repetitions }, () => value).join(sep);
       }
       function join(separator, values) {
         const sep = toStringValue(separator);
@@ -1908,6 +2037,7 @@
         pad,
         pattern_to_regexp,
         quotemeta,
+        repeat,
         rindex,
         replace,
         search,
@@ -4987,6 +5117,7 @@
         "length",
         "uc",
         "lc",
+        "print",
         "say",
         "class",
         "trait",
@@ -5754,7 +5885,7 @@
             addToken("punctuation", ch, start, cursor());
             continue;
           }
-          if (["+", "-", "*", "/", "%", "<", ">", "=", "_", "?", ":", "~", "!", "\\", "&", "|", "^", "@", "\xD7", "\xF7", "\xAC", "\u22C0", "\u22C1", "\u22BB", "\u22BC", "\u22BD", "\u2194", "\u22A8", "\u22AD"].includes(ch)) {
+          if (["+", "-", "*", "/", "%", "<", ">", "=", "_", "?", ":", "~", "!", "#", "\\", "&", "|", "^", "@", "\xD7", "\xF7", "\xAC", "\u22C0", "\u22C1", "\u22BB", "\u22BC", "\u22BD", "\u2194", "\u22A8", "\u22AD"].includes(ch)) {
             advance();
             const value = maybeValuePreservingOperator(ch, peek, advance);
             addToken("operator", value, start, cursor());
@@ -5982,6 +6113,8 @@
                 return parseDieStatement();
               case "warn":
                 return parseWarnStatement();
+              case "print":
+                return parsePrintStatement();
               case "assert":
                 return parseAssertStatement();
               case "debug":
@@ -6197,7 +6330,7 @@
                 name: typed.name
               };
             }
-            if (current().type === "identifier" || current().type === "keyword") {
+            if ((current().type === "identifier" || current().type === "keyword") && !(current().type === "keyword" && current().value === "but")) {
               const name2 = expectIdentifier("Expected unpacked binding name after type");
               return {
                 key: bindingIdentifierKey(name2),
@@ -6946,6 +7079,28 @@
           }, start, previous());
           return finishStatement(stmt, "Expected ; after warn statement");
         }
+        function parsePrintStatement() {
+          const start = expect("keyword", "print");
+          const args = [];
+          if (!(current().type === "punctuation" && current().value === ";")) {
+            args.push(parseExpression());
+            while (match("punctuation", ",")) {
+              args.push(parseExpression());
+            }
+          }
+          const stmt = withLoc({
+            type: "ExpressionStatement",
+            expression: withLoc({
+              type: "CallExpression",
+              callee: withLoc({
+                type: "Identifier",
+                name: "print"
+              }, start, start),
+              arguments: args
+            }, start, previous() || start)
+          }, start, previous() || start);
+          return finishStatement(stmt, "Expected ; after print statement");
+        }
         function parseAssertStatement() {
           const start = expect("keyword", "assert");
           const argument = parseExpression();
@@ -7359,7 +7514,7 @@
           }, startLocFromNode(left), endLocFromNode(right));
         }
         function parseUnary() {
-          if (current().type === "operator" && ["-", "+", "++", "--", "!", "~", "\\", "\u221A", "\xAC"].includes(current().value) || current().type === "keyword" && ["not", "typeof", "abs", "sqrt", "floor", "ceil", "round", "int", "length", "uc", "lc"].includes(current().value)) {
+          if (current().type === "operator" && ["-", "+", "++", "--", "!", "~", "#", "\\", "\u221A", "\xAC"].includes(current().value) || current().type === "keyword" && ["not", "typeof", "abs", "sqrt", "floor", "ceil", "round", "int", "length", "uc", "lc"].includes(current().value)) {
             const op = current();
             index++;
             const argument = op.value === "\\" ? parseReferenceTarget() : parseUnary();
@@ -7481,10 +7636,7 @@
               const key = current();
               index++;
               property = withLoc(
-                key.type === "identifier" ? {
-                  type: "BraceIdentifier",
-                  name: key.value
-                } : {
+                {
                   type: "StringLiteral",
                   value: key.value
                 },
@@ -8687,15 +8839,7 @@ globalThis[${JSON.stringify(node.id.name)}] = ${name2};` : declaration;
           return emitSpecialFunctionPreamble(signature);
         }
         const lines = [];
-        const required = params.reduce((count, param) => {
-          if (param.type === "Parameter") {
-            return count + (!param.optional && param.defaultValue == null && !param.rest ? 1 : 0);
-          }
-          if (param.type === "SpecialParameter" && param.special === "lead_rest") {
-            return count + 1;
-          }
-          return count;
-        }, 0);
+        const required = minimumAcceptedArgumentCount(params);
         lines.push("const __argc__ = arguments.length;");
         lines.push(`if ( arguments.length < ${required} ) { throw new Error( "Wrong number of arguments" ); }`);
         let argIndex = 0;
@@ -9242,7 +9386,7 @@ ${cleanup}
         const valueNames = entries.map(() => `__zuzu_unpack_value_${loopCounter++}`);
         for (let i = 0; i < entries.length; i++) {
           prelude.push(
-            `const ${valueNames[i]} = ${emitUnpackEntryValue(sourceName, entries[i])};`
+            `const ${valueNames[i]} = ${emitUnpackEntryValue(sourceName, entries[i], i)};`
           );
         }
         if (node.init && expressionRetainsCollectionValues(node.init)) {
@@ -9266,7 +9410,7 @@ ${cleanup}
         const valueNames = entries.map(() => `__zuzu_unpack_value_${loopCounter++}`);
         for (let i = 0; i < entries.length; i++) {
           lines.push(
-            `const ${valueNames[i]} = ${emitUnpackEntryValue(sourceName, entries[i])};`
+            `const ${valueNames[i]} = ${emitUnpackEntryValue(sourceName, entries[i], i)};`
           );
         }
         if (node.init && expressionRetainsCollectionValues(node.init)) {
@@ -9277,9 +9421,9 @@ ${cleanup}
         }
         return lines.join("\n");
       }
-      function emitUnpackEntryValue(sourceName, entry) {
+      function emitUnpackEntryValue(sourceName, entry, index) {
         const defaultThunk = entry.defaultValue ? `() => ${emitExpression(entry.defaultValue)}` : "null";
-        return `__zuzu_unpack_value( ${sourceName}, ${emitExpression(entry.key)}, ${defaultThunk}, ${JSON.stringify(entry.name)}, ${entry.declaredType ? JSON.stringify(entry.declaredType) : "null"}, ${entry.isWeakStorage ? "true" : "false"} )`;
+        return `__zuzu_unpack_value( ${sourceName}, () => ${emitExpression(entry.key)}, ${defaultThunk}, ${JSON.stringify(entry.name)}, ${entry.declaredType ? JSON.stringify(entry.declaredType) : "null"}, ${entry.isWeakStorage ? "true" : "false"}, ${index} )`;
       }
       function emitBlockStatement(node, cleanupNames, options = {}) {
         if (node.type === "VariableDeclaration" && node.id && cleanupNames.includes(node.id.name)) {
@@ -9291,30 +9435,25 @@ ${cleanup}
         return emitStatement(node, options);
       }
       function emitSwitchStatement(node, options = {}) {
+        const switchHereName = "__zuzu_switch_value";
+        const emitSwitchTest = (section, index) => withEmitContext({
+          ...currentEmitContext(),
+          chainHereName: switchHereName
+        }, () => emitSwitchTestExpression(section, index, node.comparator));
+        const emitSwitchBody = (block) => emitBlock(block, {
+          ...options,
+          chainHereName: switchHereName,
+          inSwitchSection: true,
+          loopDepth: 0
+        });
         if (options.asyncContext && !options.syncEval) {
-          const cases2 = node.cases.map((section) => `{ tests: [ ${section.values.map((value, index) => `async function( __zuzu_switch_value ) { return __zuzu_truthy( ${emitSwitchTestExpression(section, index, node.comparator)} ); }`).join(", ")} ], body: async function() ${emitBlock(section.consequent, {
-            ...options,
-            inSwitchSection: true,
-            loopDepth: 0
-          })} }`);
-          const defaultBody2 = node.defaultCase ? `async function() ${emitBlock(node.defaultCase.consequent, {
-            ...options,
-            inSwitchSection: true,
-            loopDepth: 0
-          })}` : "null";
+          const cases2 = node.cases.map((section) => `{ tests: [ ${section.values.map((value, index) => `async function( ${switchHereName} ) { return __zuzu_truthy( ${emitSwitchTest(section, index)} ); }`).join(", ")} ], body: async function( ${switchHereName} ) ${emitSwitchBody(section.consequent)} }`);
+          const defaultBody2 = node.defaultCase ? `async function( ${switchHereName} ) ${emitSwitchBody(node.defaultCase.consequent)}` : "null";
           const tail2 = switchStatementContainsReturn(node) ? options.inSwitchSection ? "if ( __zuzu_switch_result && __zuzu_switch_result.__zuzu_return ) { return __zuzu_switch_result; }" : "if ( __zuzu_switch_result && __zuzu_switch_result.__zuzu_return ) { return __zuzu_switch_result.value; }" : "";
           return `{ let __zuzu_switch_result = await __zuzu_switch_async( ${emitExpression(node.discriminant)}, ${JSON.stringify(node.comparator)}, [ ${cases2.join(", ")} ], ${defaultBody2} ); ${tail2} }`;
         }
-        const cases = node.cases.map((section) => `{ tests: [ ${section.values.map((value, index) => `function( __zuzu_switch_value ) { return __zuzu_truthy( ${emitSwitchTestExpression(section, index, node.comparator)} ); }`).join(", ")} ], body: function() ${emitBlock(section.consequent, {
-          ...options,
-          inSwitchSection: true,
-          loopDepth: 0
-        })} }`);
-        const defaultBody = node.defaultCase ? `function() ${emitBlock(node.defaultCase.consequent, {
-          ...options,
-          inSwitchSection: true,
-          loopDepth: 0
-        })}` : "null";
+        const cases = node.cases.map((section) => `{ tests: [ ${section.values.map((value, index) => `function( ${switchHereName} ) { return __zuzu_truthy( ${emitSwitchTest(section, index)} ); }`).join(", ")} ], body: function( ${switchHereName} ) ${emitSwitchBody(section.consequent)} }`);
+        const defaultBody = node.defaultCase ? `function( ${switchHereName} ) ${emitSwitchBody(node.defaultCase.consequent)}` : "null";
         const tail = switchStatementContainsReturn(node) ? options.inSwitchSection ? "if ( __zuzu_switch_result && __zuzu_switch_result.__zuzu_return ) { return __zuzu_switch_result; }" : "if ( __zuzu_switch_result && __zuzu_switch_result.__zuzu_return ) { return __zuzu_switch_result.value; }" : "";
         return `{ let __zuzu_switch_result = __zuzu_switch( ${emitExpression(node.discriminant)}, ${JSON.stringify(node.comparator)}, [ ${cases.join(", ")} ], ${defaultBody} ); ${tail} }`;
       }
@@ -9363,7 +9502,7 @@ ${cleanup}
         if (node.isPredeclared) {
           return `__zuzu_bodyless_function( ${JSON.stringify(node.id.name)} )`;
         }
-        return `( ${emitFunctionLike(node, `${node.isAsync ? "async " : ""}function()`, {
+        const fn2 = emitFunctionLike(node, `${node.isAsync ? "async " : ""}function()`, {
           ...meta,
           asyncContext: node.isAsync === true,
           extraPreamble: [
@@ -9376,7 +9515,37 @@ ${cleanup}
           scopeNames: /* @__PURE__ */ new Set(["self", "__zuzu_super_class__", "__zuzu_super_method__", "__zuzu_super_static__"]),
           fieldNames: meta.fieldNames || [],
           methodSelfName: meta.methodSelfName || "self"
-        })} )`;
+        });
+        const min = minimumAcceptedArgumentCount(node.params);
+        const max = maximumAcceptedArgumentCount(node.params);
+        const maxLiteral = max == null ? "null" : max;
+        return [
+          "( () => {",
+          `const __zuzu_method = ( ${fn2} );`,
+          `Object.defineProperty( __zuzu_method, "__zuzu_min_args", { value: ${min} } );`,
+          `Object.defineProperty( __zuzu_method, "__zuzu_max_args", { value: ${maxLiteral} } );`,
+          "return __zuzu_method;",
+          "} )()"
+        ].join(" ");
+      }
+      function minimumAcceptedArgumentCount(params) {
+        return params.reduce((count, param) => {
+          if (param.type === "Parameter") {
+            return count + (!param.optional && param.defaultValue == null && !param.rest ? 1 : 0);
+          }
+          if (param.type === "SpecialParameter" && param.special === "lead_rest") {
+            return count + 1;
+          }
+          return count;
+        }, 0);
+      }
+      function maximumAcceptedArgumentCount(params) {
+        for (const param of params) {
+          if (param.rest || param.type === "SpecialParameter") {
+            return null;
+          }
+        }
+        return params.length;
       }
       function emitClassDeclarationWithName(node, runtimeName, options = {}) {
         if (node.shorthand && node.traits.length === 0) {
@@ -9751,6 +9920,9 @@ ${cleanup}
         if (node.operator === "length") {
           return `__zuzu_length( ${emitExpression(node.argument)} )`;
         }
+        if (node.operator === "#") {
+          return `__zuzu_cardinality( ${emitExpression(node.argument)} )`;
+        }
         if (node.operator === "uc") {
           return `__zuzu_uc( ${emitExpression(node.argument)} )`;
         }
@@ -10408,6 +10580,9 @@ ${cleanup}
             validateExpression(node.iterable, scope);
             validateForBody(node, scope);
             return;
+          case "SwitchStatement":
+            validateSwitchStatement(node, scope);
+            return;
           case "ExpressionStatement":
             validateExpression(node.expression, scope);
             return;
@@ -10448,6 +10623,18 @@ ${cleanup}
         validateStatement(node.body, loopScope);
         validateStatement(node.elseBlock, new Scope(scope));
       }
+      function validateSwitchStatement(node, scope) {
+        validateExpression(node.discriminant, scope);
+        const switchScope = new Scope(scope);
+        switchScope.declare("^^", false, node);
+        for (const caseNode of node.cases || []) {
+          for (const value of caseNode.values || []) {
+            validateExpression(value, switchScope);
+          }
+          validateStatement(caseNode.consequent, switchScope);
+        }
+        validateStatement(node.defaultCase, switchScope);
+      }
       function validateFunctionBody(node, parentScope) {
         const scope = new Scope(parentScope);
         for (const param of node.params || []) {
@@ -11563,7 +11750,7 @@ ${cleanup}
     "package.json"(exports2, module2) {
       module2.exports = {
         name: "zuzu-js",
-        version: "0.6.0",
+        version: "0.7.1",
         description: "JavaScript runtime, compiler, and browser bundle for ZuzuScript.",
         main: "lib/zuzu.js",
         bin: {
@@ -12343,6 +12530,23 @@ ${cleanup}
         }
         return String(value);
       }
+      function outputString(value) {
+        value = resolveWeakValue(value);
+        if (value == null) {
+          return "";
+        }
+        if (typeof value === "number" || Object.prototype.toString.call(value) === "[object Number]") {
+          const numeric = Number(value);
+          if (Number.isNaN(numeric)) {
+            return "NaN";
+          }
+          if (!Number.isFinite(numeric)) {
+            return numeric > 0 ? "Inf" : "-Inf";
+          }
+          return String(numeric);
+        }
+        return zuzuStringify(value);
+      }
       function zuzuOperatorString(value) {
         return operatorString(value);
       }
@@ -12584,20 +12788,22 @@ ${cleanup}
           }
         };
         let runNext = false;
+        let matched = false;
         for (const section of cases) {
-          let matched = false;
+          let sectionMatched = false;
           if (Array.isArray(section.tests)) {
             for (const test of section.tests) {
               if (zuzuTruthy(await taskRuntime2.awaitValue(test(value)))) {
-                matched = true;
+                sectionMatched = true;
                 break;
               }
             }
           } else {
-            matched = section.values.some((item) => cmp(value, item));
+            sectionMatched = section.values.some((item) => cmp(value, item));
           }
-          if (matched || runNext) {
-            const result = await taskRuntime2.awaitValue(section.body());
+          if (sectionMatched || runNext) {
+            matched = true;
+            const result = await taskRuntime2.awaitValue(section.body(value));
             runNext = result === true;
             if (!runNext && result && typeof result === "object" && result.__zuzu_return) {
               return result;
@@ -12607,8 +12813,8 @@ ${cleanup}
             }
           }
         }
-        if (defaultBody) {
-          const result = await taskRuntime2.awaitValue(defaultBody());
+        if (defaultBody && (!matched || runNext)) {
+          const result = await taskRuntime2.awaitValue(defaultBody(value));
           if (result && typeof result === "object" && result.__zuzu_return) {
             return result;
           }
@@ -12651,6 +12857,16 @@ ${cleanup}
         }
         return [...zuzuOperatorString(value)].length;
       }
+      function operatorCardinality(value) {
+        value = resolveWeakValue(value);
+        if (Array.isArray(value) || isPairListLike(value) || value instanceof ZuzuBag || isSetLike(value) || value && typeof value === "object" && value.constructor && value.constructor.name === "Object") {
+          return lengthOf(value);
+        }
+        if (value && value.constructor && value.constructor.__zuzu_class_name && typeof value.count === "function") {
+          return value.count();
+        }
+        return operatorLength(value);
+      }
       function regexReplaceValue(current, pattern, replacement) {
         const source = zuzuOperatorString(current);
         const regex = operatorRegexp(pattern);
@@ -13923,6 +14139,25 @@ ${cleanup}
           }
           proto = Object.getPrototypeOf(proto);
         }
+        if (object && object.constructor && object.constructor.__zuzu_class_name && typeof object.__call__ === "function") {
+          const minArgs = Number(object.__call__.__zuzu_min_args || 0);
+          const maxArgs = object.__call__.__zuzu_max_args;
+          if (minArgs > 3 || maxArgs != null && Number(maxArgs) < 3) {
+            throw new Error("Wrong number of arguments");
+          }
+          const fallbackArgs = args.slice();
+          let namedArgs = makePairList([]);
+          const lastArg = fallbackArgs.length > 0 ? fallbackArgs[fallbackArgs.length - 1] : null;
+          if (isPairListLike(lastArg) && lastArg.__zuzu_temporary_call_args === true) {
+            namedArgs = lastArg;
+            fallbackArgs.pop();
+          }
+          return object.__call__(
+            String(property),
+            makeArray(fallbackArgs),
+            namedArgs
+          );
+        }
         throw new TypeError(`${String(property)} is not a function`);
       }
       function zuzuMaybeDemolish(value, preserved = null) {
@@ -14499,12 +14734,7 @@ ${cleanup}
           }
           const moduleSearchRoots = this.getModuleSearchRoots();
           const emit = (value) => {
-            let line = String(value);
-            if (line === "Infinity") {
-              line = "Inf";
-            } else if (line === "-Infinity") {
-              line = "-Inf";
-            }
+            const line = outputString(value);
             if (this.outputLines) {
               this.outputLines.push(line);
             }
@@ -14515,6 +14745,19 @@ ${cleanup}
               this.host.consoleLog(line);
             }
           };
+          const emitNoNewline = (value) => {
+            const line = outputString(value);
+            if (this.outputLines) {
+              this.outputLines.push(line);
+            }
+            if (typeof this.stdoutHandler === "function") {
+              this.stdoutHandler(line);
+            } else if (typeof process !== "undefined" && process.stdout) {
+              process.stdout.write(line);
+            } else {
+              this.host.consoleLog(line);
+            }
+          };
           const emitStderr = (value) => {
             const line = String(value);
             if (typeof this.stderrHandler === "function") {
@@ -14593,29 +14836,36 @@ ${cleanup}
           };
           const unpackDeclarationSource = (input) => {
             const value = resolveWeakValue(input);
-            if (isPairListLike(value) || zuzuTypeof(value) === "Dict") {
+            if (Array.isArray(value) || isPairListLike(value) || zuzuTypeof(value) === "Dict") {
               return value;
             }
             throw new ZuzuTypeException(
-              `Declaration unpacking expects Dict or PairList, got ${zuzuTypeof(value)}`
+              `Declaration unpacking expects Dict, PairList, or Array, got ${zuzuTypeof(value)}`
             );
           };
-          const unpackDeclarationValue = (source, key, defaultThunk, name2, typeName2, isWeakStorage) => {
+          const unpackDeclarationValue = (source, keyThunk, defaultThunk, name2, typeName2, isWeakStorage, index) => {
             const valueSource = unpackDeclarationSource(source);
-            const normalized = normalizeDictKey(key);
             let value;
             let found = false;
-            if (isPairListLike(valueSource)) {
-              const pair = valueSource.list.find(
-                (entry) => entry[0] === normalized
-              );
-              if (pair) {
-                value = pair[1];
+            if (Array.isArray(valueSource)) {
+              if (index >= 0 && index < valueSource.length) {
+                value = resolveWeakValue(valueSource[index]);
+                found = true;
+              }
+            } else {
+              const normalized = normalizeDictKey(keyThunk());
+              if (isPairListLike(valueSource)) {
+                const pair = valueSource.list.find(
+                  (entry) => entry[0] === normalized
+                );
+                if (pair) {
+                  value = pair[1];
+                  found = true;
+                }
+              } else if (Object.prototype.hasOwnProperty.call(valueSource, normalized)) {
+                value = valueSource[normalized];
                 found = true;
               }
-            } else if (Object.prototype.hasOwnProperty.call(valueSource, normalized)) {
-              value = valueSource[normalized];
-              found = true;
             }
             if (!found) {
               value = typeof defaultThunk === "function" ? defaultThunk() : null;
@@ -14930,7 +15180,7 @@ ${cleanup}
                 for (let i = 0; i < value.length; i++) {
                   out += value[i];
                   if (i < parts.length) {
-                    out += String(parts[i]);
+                    out += outputString(parts[i]);
                   }
                 }
                 emit(out);
@@ -14938,6 +15188,20 @@ ${cleanup}
               }
               emit(value);
             },
+            print(value, ...parts) {
+              if (Array.isArray(value) && Object.prototype.hasOwnProperty.call(value, "raw")) {
+                let out = "";
+                for (let i = 0; i < value.length; i++) {
+                  out += value[i];
+                  if (i < parts.length) {
+                    out += outputString(parts[i]);
+                  }
+                }
+                emitNoNewline(out);
+                return;
+              }
+              emitNoNewline(value);
+            },
             __zuzu_switch: runSwitch,
             __zuzu_switch_async: runSwitchAsync,
             __zuzu_match: runMatch,
@@ -15244,6 +15508,7 @@ ${cleanup}
               return asIterable(value);
             },
             __zuzu_length: operatorLength,
+            __zuzu_cardinality: operatorCardinality,
             __zuzu_num(value) {
               return zuzuToNumber(value);
             },
@@ -41613,9 +41878,9 @@ ${lines.join("\n")}
     }
   });
 
-  // ../../../../../tmp/zuzu-browser-build.UGYrnC/browser-stdlib.generated.js
+  // ../../../../../tmp/zuzu-browser-build.3mYmJh/browser-stdlib.generated.js
   var require_browser_stdlib_generated = __commonJS({
-    "../../../../../tmp/zuzu-browser-build.UGYrnC/browser-stdlib.generated.js"(exports2, module2) {
+    "../../../../../tmp/zuzu-browser-build.3mYmJh/browser-stdlib.generated.js"(exports2, module2) {
       "use strict";
       function createBrowserStdlib2() {
         const jsModules = /* @__PURE__ */ Object.create(null);
@@ -47853,7 +48118,7 @@ class ZZTemplate extends ZTemplate {
     }
   });
 
-  // ../../../../../tmp/zuzu-browser-build.UGYrnC/browser-worker-entry.generated.js
+  // ../../../../../tmp/zuzu-browser-build.3mYmJh/browser-worker-entry.generated.js
   var { createBrowserStdlib } = require_browser_stdlib_generated();
   globalThis.__ZUZU_BROWSER_DEFAULT_RUNTIME_OPTIONS__ = createBrowserStdlib();
   var { installBrowserWorker } = require_browser_worker_entry();