@zaisma/game-server 1.4.0 → 1.6.0

package/src/chat.d.ts

@@ -1,9 +1,10 @@
 /**
  * Zaisma's chat filter for your own server (docs/DECISIONS.md, "The text filter catches what matters and
  * leaves the rest alone"). Every chat message to or from an under-18 account is checked on Zaisma's side:
- * contact details in any disguise, moving to another app or meeting up, personal details, slurs and
- * sexual content are stopped. Swearing is only flagged (hasSwearing): blocking it is your call. The answer
- * is one verdict for the whole message, never per receiver, so it never says who's under 18.
+ * contact details in any disguise, moving to another app or meeting up, personal details and sexual
+ * content are stopped. Swearing and slurs are only flagged (hasSwearing, hasSlur): blocking them is your
+ * call. Between adults it only flags, unless you turn the filter on for them too (isAdultFilterEnabled).
+ * The answer is one verdict for the whole message, never per receiver, so it never says who's under 18.
  *
  * checkChat sends the players' passes (as your server received them) and the sender's last few messages to
  * Zaisma (POST <issuer>/v1/chat/check), so a phone number sent a few digits at a time is caught too.
@@ -11,14 +12,17 @@
  * It's for your own server only. In Zaisma rooms the room filters the chat it delivers itself, so a game
  * server running there never sees passes, and checkChat throws a ChatCheckError (own_server_only).
  */
-/** Why a message was stopped. The same reasons as Zaisma.checkChat, plus chat_paused and not_allowed_to_chat. */
+/**
+ * Why a message was stopped. The same reasons as Zaisma.checkChat, plus chat_paused, not_allowed_to_chat and
+ * unchecked (Zaisma couldn't be reached). slur is v1's and no longer given: slurs are flagged (hasSlur), never stopped.
+ */
 export type ChatCheckReason = "contact_details" | "personal_details" | "slur" | "sexual" | "chat_paused" | "unchecked" | "too_long" | "not_allowed_to_chat";
 export interface ChatCheck {
     /** Whether to deliver it. */
     isAllowed: boolean;
     /**
-     * Why not; null when it's allowed. chat_paused: the sender's chat is paused or removed. unchecked: Zaisma
-     * couldn't check it, so don't deliver it (try again in a moment). too_long: over 2000 characters.
+     * Why not; null when it's allowed. chat_paused: the sender's chat is paused or removed. unchecked: your
+     * server couldn't reach Zaisma, so don't deliver it (try again in a moment). too_long: over 2000 characters.
      * not_allowed_to_chat: canChat says the sender and a receiver may not chat (Zaisma checks it too).
      */
     reason: ChatCheckReason | null;
@@ -26,6 +30,8 @@ export interface ChatCheck {
     message: string | null;
     /** Whether it swears. Zaisma allows it; block it yourself if your game doesn't. */
     hasSwearing: boolean;
+    /** Whether it has a slur. Zaisma allows it too, so your game and its moderators decide. */
+    hasSlur: boolean;
 }
 export interface ChatCheckOptions {
     /** The message. */
@@ -34,7 +40,15 @@ export interface ChatCheckOptions {
     senderPass: string;
     /** The passes of everyone it would reach, up to 50. */
     receiverPasses: string[];
+    /** Check chat between adults too, as for under-18s; each message Zaisma's AI looks at counts on your hosting meter. False by default. */
+    isAdultFilterEnabled?: boolean;
 }
+/** Chat in rooms (room.chat), for both Zaisma's rooms and your own server's runner: past any human's typing, so it only stops floods. */
+export declare const CHAT_ROOM_LIMITS: {
+    /** Chat messages one player may send in any chatWindowDurationMs; past it, chat_too_fast. */
+    readonly maximumChatMessageCount: 20;
+    readonly chatWindowDurationMs: 10000;
+};
 export declare const CHAT_CHECK_LIMITS: {
     /** The longest message checked, in characters: the whole text is checked, and a longer one is refused (too_long), never cut. */
     readonly maximumMessageCharacterCount: 2000;
@@ -56,8 +70,9 @@ export declare class ChatCheckError extends Error {
 /**
  * Check one chat message with Zaisma's filter. Call it on every chat message your server delivers, after
  * canChat says the players may chat, and deliver it only when isAllowed (Zaisma applies canChat's rule
- * too, so a message to anyone who may not chat is stopped). It's free. When Zaisma can't be
- * reached it answers unchecked: don't deliver the message.
+ * too, so a message to anyone who may not chat is stopped). It's free, except the checks of chat between
+ * adults when isAdultFilterEnabled. When Zaisma can't be reached it answers unchecked: don't deliver the message.
+ * The runner (zaisma-game-server) does all this for room.chat in its rooms.
  *
  *   const check = await checkChat({ text, senderPass, receiverPasses: [receiverPass] });
  *   if (!check.isAllowed || check.hasSwearing) return reply(sender, check.message ?? "No swearing here.");

package/src/chat.js

@@ -1,9 +1,10 @@
 /**
  * Zaisma's chat filter for your own server (docs/DECISIONS.md, "The text filter catches what matters and
  * leaves the rest alone"). Every chat message to or from an under-18 account is checked on Zaisma's side:
- * contact details in any disguise, moving to another app or meeting up, personal details, slurs and
- * sexual content are stopped. Swearing is only flagged (hasSwearing): blocking it is your call. The answer
- * is one verdict for the whole message, never per receiver, so it never says who's under 18.
+ * contact details in any disguise, moving to another app or meeting up, personal details and sexual
+ * content are stopped. Swearing and slurs are only flagged (hasSwearing, hasSlur): blocking them is your
+ * call. Between adults it only flags, unless you turn the filter on for them too (isAdultFilterEnabled).
+ * The answer is one verdict for the whole message, never per receiver, so it never says who's under 18.
  *
  * checkChat sends the players' passes (as your server received them) and the sender's last few messages to
  * Zaisma (POST <issuer>/v1/chat/check), so a phone number sent a few digits at a time is caught too.
@@ -12,6 +13,12 @@
  * server running there never sees passes, and checkChat throws a ChatCheckError (own_server_only).
  */
 import { OutsideCallError } from "./outside-calls.js";
+/** Chat in rooms (room.chat), for both Zaisma's rooms and your own server's runner: past any human's typing, so it only stops floods. */
+export const CHAT_ROOM_LIMITS = {
+    /** Chat messages one player may send in any chatWindowDurationMs; past it, chat_too_fast. */
+    maximumChatMessageCount: 20,
+    chatWindowDurationMs: 10_000,
+};
 export const CHAT_CHECK_LIMITS = {
     /** The longest message checked, in characters: the whole text is checked, and a longer one is refused (too_long), never cut. */
     maximumMessageCharacterCount: 2000,
@@ -34,9 +41,9 @@ export class ChatCheckError extends Error {
         this.fix = fix;
     }
 }
-const UNCHECKED = { isAllowed: false, reason: "unchecked", message: "This message couldn't be checked. Try again in a moment.", hasSwearing: false };
-const TOO_LONG = { isAllowed: false, reason: "too_long", message: "That message is too long to send.", hasSwearing: false };
-const REASONS = ["contact_details", "personal_details", "slur", "sexual", "chat_paused", "unchecked", "too_long", "not_allowed_to_chat"];
+const UNCHECKED = { isAllowed: false, reason: "unchecked", message: "This message couldn't be checked. Try again in a moment.", hasSwearing: false, hasSlur: false };
+const TOO_LONG = { isAllowed: false, reason: "too_long", message: "That message is too long to send.", hasSwearing: false, hasSlur: false };
+const REASONS = ["contact_details", "personal_details", "sexual", "chat_paused", "unchecked", "too_long", "not_allowed_to_chat"];
 /** Each sender's last messages, by the sender's pass's player ID: only in this process's memory. */
 const recentBySender = new Map();
 /** The claims of a pass, unchecked: Zaisma checks the signature. Only to find whose it is and where it's from. */
@@ -67,13 +74,16 @@ function rememberText(senderPlayerId, text, nowMs) {
 /**
  * Check one chat message with Zaisma's filter. Call it on every chat message your server delivers, after
  * canChat says the players may chat, and deliver it only when isAllowed (Zaisma applies canChat's rule
- * too, so a message to anyone who may not chat is stopped). It's free. When Zaisma can't be
- * reached it answers unchecked: don't deliver the message.
+ * too, so a message to anyone who may not chat is stopped). It's free, except the checks of chat between
+ * adults when isAdultFilterEnabled. When Zaisma can't be reached it answers unchecked: don't deliver the message.
+ * The runner (zaisma-game-server) does all this for room.chat in its rooms.
  *
  *   const check = await checkChat({ text, senderPass, receiverPasses: [receiverPass] });
  *   if (!check.isAllowed || check.hasSwearing) return reply(sender, check.message ?? "No swearing here.");
  */
 export async function checkChat({ text, senderPass, receiverPasses }) {
+    // Read apart from the destructuring, which is v1's signature as it's locked (test/contracts).
+    const isAdultFilterEnabled = arguments[0]?.isAdultFilterEnabled === true;
     const claims = readClaims(String(senderPass ?? ""));
     if (typeof claims.sub !== "string" || !isZaismaIssuer(claims.iss) || !Array.isArray(receiverPasses))
         return UNCHECKED;
@@ -87,7 +97,7 @@ export async function checkChat({ text, senderPass, receiverPasses }) {
         const response = await fetch(`${claims.iss}/v1/chat/check`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ gameSlug: claims.aud, senderPass, receiverPasses: receiverPasses.slice(0, CHAT_CHECK_LIMITS.maximumReceiverCount), text: message, recentTexts }),
+            body: JSON.stringify({ gameSlug: claims.aud, senderPass, receiverPasses: receiverPasses.slice(0, CHAT_CHECK_LIMITS.maximumReceiverCount), text: message, recentTexts, isAdultFilterEnabled }),
             signal: AbortSignal.timeout(CHAT_CHECK_LIMITS.checkTimeoutMs),
         });
         if (!response.ok)
@@ -96,12 +106,12 @@ export async function checkChat({ text, senderPass, receiverPasses }) {
         if (typeof answer.isAllowed !== "boolean")
             return UNCHECKED;
         const reason = typeof answer.reason === "string" && REASONS.includes(answer.reason) ? answer.reason : null;
-        return { isAllowed: answer.isAllowed, reason, message: typeof answer.message === "string" ? answer.message : null, hasSwearing: answer.hasSwearing === true };
+        return { isAllowed: answer.isAllowed, reason, message: typeof answer.message === "string" ? answer.message : null, hasSwearing: answer.hasSwearing === true, hasSlur: answer.hasSlur === true };
     }
     catch (error) {
         // In Zaisma rooms the gateway refuses the call to Zaisma's own address: checkChat is for a game server on your own server.
         if (error instanceof OutsideCallError && ["unreachable_host", "not_https", "host_not_allowed"].includes(error.code)) {
-            throw new ChatCheckError("checkChat is for a game server on your own server. In Zaisma rooms the room runs Zaisma's chat filter on the chat it delivers.", "Send chat through Zaisma's chat hosting in rooms once it's out; until then, check what a player types in the game with Zaisma.checkChat, or offer preset phrases and emotes.");
+            throw new ChatCheckError("checkChat is for a game server on your own server. In Zaisma rooms the room runs Zaisma's chat filter on the chat it delivers.", "In Zaisma rooms, send chat with room.chat in the game; the room filters it.");
         }
         return UNCHECKED;
     }

package/src/index.d.ts

@@ -1,10 +1,10 @@
-export { BUSY_CLOSE_CODE, ENDED_CLOSE_CODE, GAME_SERVER_OPTIONS, GameServerError, NO_ANSWER_CLOSE_CODE, REMOVED_CLOSE_CODE, ROOM_LIMITS, SEAT_GONE_CLOSE_CODE, VERSION_UPDATE_CLOSE_CODE, defineGameServer, type Audience, type AwayInfo, type AwayMode, type AwayReason, type BroadcastOptions, type Delivery, type GameServer, type GameServerErrorCode, type HandlerResult, type IdleCheck, type JoinAnswer, type JoinInfo, type KickOptions, type LeaveInfo, type LeaveReason, type MoveOptions, type MoveResult, type Player, type Purchase, type Refusal, type ReserveOptions, type RestoreInfo, type Room, type RoomErrorCode, type RoomInfo, type SendOptions, type VersionUpdate, } from "./room.ts";
+export { BUSY_CLOSE_CODE, ENDED_CLOSE_CODE, GAME_SERVER_OPTIONS, GameServerError, NO_ANSWER_CLOSE_CODE, REMOVED_CLOSE_CODE, ROOM_LIMITS, SEAT_GONE_CLOSE_CODE, VERSION_UPDATE_CLOSE_CODE, defineGameServer, type Audience, type AwayInfo, type AwayMode, type AwayReason, type BroadcastOptions, type Delivery, type GameServer, type GameServerErrorCode, type HandlerResult, type IdleCheck, type JoinAnswer, type ChatAnswer, type ChatInfo, type JoinInfo, type KickOptions, type LeaveInfo, type LeaveReason, type MoveOptions, type MoveResult, type Player, type Purchase, type Refusal, type ReserveOptions, type RestoreInfo, type Room, type RoomErrorCode, type RoomInfo, type SendOptions, type VersionUpdate, } from "./room.ts";
 export { REQUEST_LIMITS, type RequestErrorCode, type Server } from "./requests.ts";
 export { SCHEDULE_LIMITS, type Schedule, type ScheduledRun } from "./schedules.ts";
 export { WEBHOOK_LIMITS, verifyWebhook, type WebhookError, type WebhookErrorCode, type WebhookEvent, type WebhookEventKind, type WebhookHeaders } from "./webhooks.ts";
 export { DATABASE_LIMITS, DatabaseError, type DatabaseErrorCode, type DatabaseRow, type DatabaseStatement, type DatabaseValue, type GameDatabase } from "./database.ts";
 export { OUTSIDE_CALL_LIMITS, OutsideCallError, type OutsideCallErrorCode } from "./outside-calls.ts";
 export { PASS_ISSUER_URL, PASS_TOKEN_TYPE, PASS_VERSION_NUMBER, PassError, RECEIPT_ISSUER_URL, RECEIPT_TOKEN_TYPE, RECEIPT_VERSION_NUMBER, ReceiptError, canChat, passesAreFriends, passesHaveBlockBetween, verifyPass, verifyReceipt, type PassClaims, type PassErrorCode, type PassExpectations, type PlayerKind, type PublicKey, type ReceiptClaims, type ReceiptErrorCode, type ReceiptExpectations, type WhoCanChat } from "./pass.ts";
-export { CHAT_CHECK_LIMITS, ChatCheckError, checkChat, type ChatCheck, type ChatCheckOptions, type ChatCheckReason } from "./chat.ts";
+export { CHAT_CHECK_LIMITS, CHAT_ROOM_LIMITS, ChatCheckError, checkChat, type ChatCheck, type ChatCheckOptions, type ChatCheckReason } from "./chat.ts";
 export { guestName, isRoomCode } from "./names.ts";
 export { relay } from "./relay.ts";

package/src/index.js

@@ -7,6 +7,6 @@ export { WEBHOOK_LIMITS, verifyWebhook } from "./webhooks.js";
 export { DATABASE_LIMITS, DatabaseError } from "./database.js";
 export { OUTSIDE_CALL_LIMITS, OutsideCallError } from "./outside-calls.js";
 export { PASS_ISSUER_URL, PASS_TOKEN_TYPE, PASS_VERSION_NUMBER, PassError, RECEIPT_ISSUER_URL, RECEIPT_TOKEN_TYPE, RECEIPT_VERSION_NUMBER, ReceiptError, canChat, passesAreFriends, passesHaveBlockBetween, verifyPass, verifyReceipt } from "./pass.js";
-export { CHAT_CHECK_LIMITS, ChatCheckError, checkChat } from "./chat.js";
+export { CHAT_CHECK_LIMITS, CHAT_ROOM_LIMITS, ChatCheckError, checkChat } from "./chat.js";
 export { guestName, isRoomCode } from "./names.js";
 export { relay } from "./relay.js";

package/src/pass.d.ts

@@ -28,9 +28,9 @@ export interface PassClaims {
      */
     who_can_chat?: WhoCanChat | (string & {});
     /**
-     * For accounts that chat with anyone, the group they can chat in (chat_group_…): two such players
-     * chat when their groups match (canChat). Opaque and different in every game, so it never says an
-     * age; a game could guess which group is the younger one from its size.
+     * For accounts that chat at all (friends or anyone), the group they can chat in (chat_group_…): two
+     * players chat only when their groups match (canChat), friends included. Opaque and different in every
+     * game, so it never says an age; a game could guess which group is the younger one from its size.
      */
     chat_group_id?: string;
     /**
@@ -88,11 +88,12 @@ export declare function passesHaveBlockBetween(first: PassClaims, second: PassCl
  */
 export declare function passesAreFriends(first: PassClaims, second: PassClaims): boolean;
 /**
- * Whether two players may chat, by the passes your server checked (verifyPass): both accounts, no block
- * between them, neither letting nobody chat, and either friends or both letting anyone chat, in the same
- * chat group. Guests and accounts set to nobody never chat; accounts set to friends chat only with
- * friends (passesAreFriends). Use it on every message your own server delivers, text or voice; Zaisma's
- * chat check (checkChat) applies the same rule, and Zaisma rooms will do the same for you.
+ * Whether two players may chat, by the passes your server checked (verifyPass): both accounts in the same
+ * chat group, no block between them, neither letting nobody chat, and either friends or both letting
+ * anyone chat. Guests and accounts set to nobody never chat; accounts set to friends chat only with
+ * friends (passesAreFriends); friends in different chat groups don't chat. Use it on every message your
+ * own server delivers, text or voice; Zaisma's chat check (checkChat) applies the same rule, and so do
+ * rooms (room.chat), on Zaisma and in the runner.
  */
 export declare function canChat(first: PassClaims, second: PassClaims): boolean;
 export type PublicKey = JsonWebKey & {

package/src/pass.js

@@ -44,11 +44,12 @@ export function passesAreFriends(first, second) {
     return lists(first, second) && lists(second, first);
 }
 /**
- * Whether two players may chat, by the passes your server checked (verifyPass): both accounts, no block
- * between them, neither letting nobody chat, and either friends or both letting anyone chat, in the same
- * chat group. Guests and accounts set to nobody never chat; accounts set to friends chat only with
- * friends (passesAreFriends). Use it on every message your own server delivers, text or voice; Zaisma's
- * chat check (checkChat) applies the same rule, and Zaisma rooms will do the same for you.
+ * Whether two players may chat, by the passes your server checked (verifyPass): both accounts in the same
+ * chat group, no block between them, neither letting nobody chat, and either friends or both letting
+ * anyone chat. Guests and accounts set to nobody never chat; accounts set to friends chat only with
+ * friends (passesAreFriends); friends in different chat groups don't chat. Use it on every message your
+ * own server delivers, text or voice; Zaisma's chat check (checkChat) applies the same rule, and so do
+ * rooms (room.chat), on Zaisma and in the runner.
  */
 export function canChat(first, second) {
     mustBePasses(first, second, "canChat");
@@ -59,9 +60,10 @@ export function canChat(first, second) {
     const isOpenTo = (whoCanChat) => whoCanChat === "friends" || whoCanChat === "anyone";
     if (!isOpenTo(first.who_can_chat) || !isOpenTo(second.who_can_chat))
         return false;
-    if (passesAreFriends(first, second))
-        return true;
-    return first.who_can_chat === "anyone" && second.who_can_chat === "anyone" && typeof first.chat_group_id === "string" && first.chat_group_id === second.chat_group_id;
+    // Chat never leaves a chat group, friends included.
+    if (typeof first.chat_group_id !== "string" || first.chat_group_id !== second.chat_group_id)
+        return false;
+    return passesAreFriends(first, second) || (first.who_can_chat === "anyone" && second.who_can_chat === "anyone");
 }
 // Plain class fields (no TypeScript-only syntax) so Node can run this file directly.
 export class PassError extends Error {

package/src/qr-code.d.ts

@@ -0,0 +1,20 @@
+/**
+ * QR codes for game and room links (docs/DECISIONS.md, "QR codes"): players get one behind Share,
+ * developers on the dashboard and through the API and MCP. Byte mode, error correction level M,
+ * versions 1 to 10 (up to 213 bytes, far more than a link needs). Written here rather than taken from a
+ * package so the site's page and the API draw the same code with no dependency; it follows ISO/IEC
+ * 18004 the way Project Nayuki's reference encoder does.
+ */
+export declare const QR_CODE_LIMITS: {
+    /** Version 10 at level M holds 213 bytes. */
+    readonly maximumTextBytes: 213;
+    /** Light modules around the code, as the standard asks. */
+    readonly quietZoneModuleCount: 4;
+};
+/**
+ * The code's modules for `text`, as rows of dark (true) and light (false), with no quiet zone. Throws
+ * a RangeError when the text is over QR_CODE_LIMITS.maximumTextBytes in UTF-8.
+ */
+export declare function qrCodeModules(text: string): boolean[][];
+/** The code for `text` as an SVG document: dark modules on white, with the quiet zone, one unit a module. */
+export declare function qrCodeSvg(text: string): string;

package/src/qr-code.js

@@ -0,0 +1,319 @@
+/**
+ * QR codes for game and room links (docs/DECISIONS.md, "QR codes"): players get one behind Share,
+ * developers on the dashboard and through the API and MCP. Byte mode, error correction level M,
+ * versions 1 to 10 (up to 213 bytes, far more than a link needs). Written here rather than taken from a
+ * package so the site's page and the API draw the same code with no dependency; it follows ISO/IEC
+ * 18004 the way Project Nayuki's reference encoder does.
+ */
+export const QR_CODE_LIMITS = {
+    /** Version 10 at level M holds 213 bytes. */
+    maximumTextBytes: 213,
+    /** Light modules around the code, as the standard asks. */
+    quietZoneModuleCount: 4,
+};
+// Level M: error correction codewords per block and blocks, by version (index 0 unused).
+const ERROR_CORRECTION_CODEWORD_COUNTS_PER_BLOCK = [0, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26];
+const ERROR_CORRECTION_BLOCK_COUNTS = [0, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5];
+/** Error correction level M (medium)'s two bits in the format information. */
+const MEDIUM_CORRECTION_FORMAT_NUMBER = 0;
+const HIGHEST_VERSION_NUMBER = 10;
+const isBitSet = (bitsNumber, bitIndex) => ((bitsNumber >>> bitIndex) & 1) !== 0;
+function rawDataModuleCount(versionNumber) {
+    let moduleCount = (16 * versionNumber + 128) * versionNumber + 64;
+    if (versionNumber >= 2) {
+        const alignmentCount = Math.floor(versionNumber / 7) + 2;
+        moduleCount -= (25 * alignmentCount - 10) * alignmentCount - 55;
+        if (versionNumber >= 7)
+            moduleCount -= 36;
+    }
+    return moduleCount;
+}
+const dataCodewordCount = (versionNumber) => Math.floor(rawDataModuleCount(versionNumber) / 8) - ERROR_CORRECTION_CODEWORD_COUNTS_PER_BLOCK[versionNumber] * ERROR_CORRECTION_BLOCK_COUNTS[versionNumber];
+// Reed-Solomon over GF(256) with the polynomial 0x11D.
+function multiplied(leftNumber, rightNumber) {
+    let productNumber = 0;
+    for (let bitIndex = 7; bitIndex >= 0; bitIndex--) {
+        productNumber = (productNumber << 1) ^ ((productNumber >>> 7) * 0x11d);
+        productNumber ^= ((rightNumber >>> bitIndex) & 1) * leftNumber;
+    }
+    return productNumber;
+}
+function divisorOf(degreeCount) {
+    const coefficients = new Array(degreeCount).fill(0);
+    coefficients[degreeCount - 1] = 1;
+    let rootNumber = 1;
+    for (let stepIndex = 0; stepIndex < degreeCount; stepIndex++) {
+        for (let index = 0; index < coefficients.length; index++) {
+            coefficients[index] = multiplied(coefficients[index], rootNumber);
+            if (index + 1 < coefficients.length)
+                coefficients[index] = coefficients[index] ^ coefficients[index + 1];
+        }
+        rootNumber = multiplied(rootNumber, 0x02);
+    }
+    return coefficients;
+}
+function remainderOf(codewords, divisor) {
+    const remainders = divisor.map(() => 0);
+    for (const codewordNumber of codewords) {
+        const factorNumber = codewordNumber ^ remainders.shift();
+        remainders.push(0);
+        divisor.forEach((coefficientNumber, index) => (remainders[index] = remainders[index] ^ multiplied(coefficientNumber, factorNumber)));
+    }
+    return remainders;
+}
+/** The data codewords with their error correction, split into blocks and interleaved. */
+function withErrorCorrection(dataCodewords, versionNumber) {
+    const blockCount = ERROR_CORRECTION_BLOCK_COUNTS[versionNumber];
+    const blockCorrectionCount = ERROR_CORRECTION_CODEWORD_COUNTS_PER_BLOCK[versionNumber];
+    const rawCodewordCount = Math.floor(rawDataModuleCount(versionNumber) / 8);
+    const shortBlockCount = blockCount - (rawCodewordCount % blockCount);
+    const shortBlockCodewordCount = Math.floor(rawCodewordCount / blockCount);
+    const divisor = divisorOf(blockCorrectionCount);
+    const blocks = [];
+    for (let blockIndex = 0, startIndex = 0; blockIndex < blockCount; blockIndex++) {
+        const block = dataCodewords.slice(startIndex, startIndex + shortBlockCodewordCount - blockCorrectionCount + (blockIndex < shortBlockCount ? 0 : 1));
+        startIndex += block.length;
+        const correction = remainderOf(block, divisor);
+        if (blockIndex < shortBlockCount)
+            block.push(0);
+        blocks.push(block.concat(correction));
+    }
+    const interleaved = [];
+    for (let codewordIndex = 0; codewordIndex < blocks[0].length; codewordIndex++) {
+        blocks.forEach((block, blockIndex) => {
+            if (codewordIndex !== shortBlockCodewordCount - blockCorrectionCount || blockIndex >= shortBlockCount)
+                interleaved.push(block[codewordIndex]);
+        });
+    }
+    return interleaved;
+}
+function alignmentIndexes(versionNumber, sideModuleCount) {
+    if (versionNumber === 1)
+        return [];
+    const alignmentCount = Math.floor(versionNumber / 7) + 2;
+    const stepModuleCount = Math.ceil((versionNumber * 4 + 4) / (alignmentCount * 2 - 2)) * 2;
+    const indexes = [6];
+    for (let moduleIndex = sideModuleCount - 7; indexes.length < alignmentCount; moduleIndex -= stepModuleCount)
+        indexes.splice(1, 0, moduleIndex);
+    return indexes;
+}
+/** The standard's eight masks, by column and row. */
+const MASKS = [
+    (columnIndex, rowIndex) => (columnIndex + rowIndex) % 2 === 0,
+    (...indexes) => indexes[1] % 2 === 0,
+    (columnIndex) => columnIndex % 3 === 0,
+    (columnIndex, rowIndex) => (columnIndex + rowIndex) % 3 === 0,
+    (columnIndex, rowIndex) => (Math.floor(columnIndex / 3) + Math.floor(rowIndex / 2)) % 2 === 0,
+    (columnIndex, rowIndex) => ((columnIndex * rowIndex) % 2) + ((columnIndex * rowIndex) % 3) === 0,
+    (columnIndex, rowIndex) => (((columnIndex * rowIndex) % 2) + ((columnIndex * rowIndex) % 3)) % 2 === 0,
+    (columnIndex, rowIndex) => (((columnIndex + rowIndex) % 2) + ((columnIndex * rowIndex) % 3)) % 2 === 0,
+];
+/** A score for how hard a masked code is to read (lower is better), from the standard's rules. */
+function penaltyPointCount(modules) {
+    const sideModuleCount = modules.length;
+    let pointCount = 0;
+    const scoreLines = (isDarkAt) => {
+        for (let lineIndex = 0; lineIndex < sideModuleCount; lineIndex++) {
+            let runModuleCount = 0;
+            let isRunDark = false;
+            const line = [];
+            for (let alongIndex = 0; alongIndex < sideModuleCount; alongIndex++) {
+                const isDark = isDarkAt(lineIndex, alongIndex);
+                line.push(isDark);
+                if (alongIndex > 0 && isDark === isRunDark) {
+                    runModuleCount++;
+                    if (runModuleCount === 5)
+                        pointCount += 3;
+                    else if (runModuleCount > 5)
+                        pointCount++;
+                }
+                else {
+                    isRunDark = isDark;
+                    runModuleCount = 1;
+                }
+            }
+            // Finder-like runs: dark-light-dark-dark-dark-light-dark with four light modules on a side.
+            const padded = [false, false, false, false, ...line, false, false, false, false];
+            for (let startIndex = 0; startIndex + 11 <= padded.length; startIndex++) {
+                const isDarkAtOffset = (offsetIndex) => padded[startIndex + offsetIndex];
+                if (!(isDarkAtOffset(4) && !isDarkAtOffset(5) && isDarkAtOffset(6) && isDarkAtOffset(7) && isDarkAtOffset(8) && !isDarkAtOffset(9) && isDarkAtOffset(10)))
+                    continue;
+                const isLightBefore = !isDarkAtOffset(0) && !isDarkAtOffset(1) && !isDarkAtOffset(2) && !isDarkAtOffset(3);
+                const isLightAfter = startIndex + 15 <= padded.length && !isDarkAtOffset(11) && !isDarkAtOffset(12) && !isDarkAtOffset(13) && !isDarkAtOffset(14);
+                if (isLightBefore || isLightAfter)
+                    pointCount += 40;
+            }
+        }
+    };
+    scoreLines((rowIndex, columnIndex) => modules[rowIndex][columnIndex]);
+    scoreLines((columnIndex, rowIndex) => modules[rowIndex][columnIndex]);
+    for (let rowIndex = 0; rowIndex + 1 < sideModuleCount; rowIndex++) {
+        for (let columnIndex = 0; columnIndex + 1 < sideModuleCount; columnIndex++) {
+            const isDark = modules[rowIndex][columnIndex];
+            if (isDark === modules[rowIndex][columnIndex + 1] && isDark === modules[rowIndex + 1][columnIndex] && isDark === modules[rowIndex + 1][columnIndex + 1])
+                pointCount += 3;
+        }
+    }
+    const darkModuleCount = modules.flat().filter(Boolean).length;
+    const moduleCount = sideModuleCount * sideModuleCount;
+    pointCount += (Math.ceil(Math.abs(darkModuleCount * 20 - moduleCount * 10) / moduleCount) - 1) * 10;
+    return pointCount;
+}
+/**
+ * The code's modules for `text`, as rows of dark (true) and light (false), with no quiet zone. Throws
+ * a RangeError when the text is over QR_CODE_LIMITS.maximumTextBytes in UTF-8.
+ */
+export function qrCodeModules(text) {
+    const textBytes = [...new TextEncoder().encode(text)];
+    const neededBitCount = (candidateNumber) => 4 + (candidateNumber < 10 ? 8 : 16) + textBytes.length * 8;
+    let versionNumber = 1;
+    while (versionNumber <= HIGHEST_VERSION_NUMBER && neededBitCount(versionNumber) > dataCodewordCount(versionNumber) * 8)
+        versionNumber++;
+    if (versionNumber > HIGHEST_VERSION_NUMBER)
+        throw new RangeError(`The text is ${textBytes.length} bytes; a QR code here holds at most ${QR_CODE_LIMITS.maximumTextBytes}.`);
+    // The bit stream: byte mode, the length, the bytes, a terminator, then padding.
+    const capacityBitCount = dataCodewordCount(versionNumber) * 8;
+    const bits = [];
+    const append = (bitsNumber, bitCount) => {
+        for (let bitIndex = bitCount - 1; bitIndex >= 0; bitIndex--)
+            bits.push((bitsNumber >>> bitIndex) & 1);
+    };
+    append(0b0100, 4);
+    append(textBytes.length, versionNumber < 10 ? 8 : 16);
+    for (const textByte of textBytes)
+        append(textByte, 8);
+    append(0, Math.min(4, capacityBitCount - bits.length));
+    append(0, (8 - (bits.length % 8)) % 8);
+    for (let padByte = 0xec; bits.length < capacityBitCount; padByte ^= 0xec ^ 0x11)
+        append(padByte, 8);
+    const dataCodewords = [];
+    for (let bitIndex = 0; bitIndex < bits.length; bitIndex += 8)
+        dataCodewords.push(bits.slice(bitIndex, bitIndex + 8).reduce((byteNumber, bitNumber) => (byteNumber << 1) | bitNumber, 0));
+    const codewords = withErrorCorrection(dataCodewords, versionNumber);
+    const sideModuleCount = versionNumber * 4 + 17;
+    const modules = Array.from({ length: sideModuleCount }, () => new Array(sideModuleCount).fill(false));
+    const isFunction = Array.from({ length: sideModuleCount }, () => new Array(sideModuleCount).fill(false));
+    const setFunction = (columnIndex, rowIndex, isDark) => {
+        modules[rowIndex][columnIndex] = isDark;
+        isFunction[rowIndex][columnIndex] = true;
+    };
+    for (let moduleIndex = 0; moduleIndex < sideModuleCount; moduleIndex++) {
+        setFunction(6, moduleIndex, moduleIndex % 2 === 0);
+        setFunction(moduleIndex, 6, moduleIndex % 2 === 0);
+    }
+    const finderCenters = [[3, 3], [sideModuleCount - 4, 3], [3, sideModuleCount - 4]];
+    for (const [centerColumnIndex, centerRowIndex] of finderCenters) {
+        for (let rowOffsetIndex = -4; rowOffsetIndex <= 4; rowOffsetIndex++) {
+            for (let columnOffsetIndex = -4; columnOffsetIndex <= 4; columnOffsetIndex++) {
+                const columnIndex = centerColumnIndex + columnOffsetIndex;
+                const rowIndex = centerRowIndex + rowOffsetIndex;
+                const ringIndex = Math.max(Math.abs(columnOffsetIndex), Math.abs(rowOffsetIndex));
+                if (columnIndex >= 0 && columnIndex < sideModuleCount && rowIndex >= 0 && rowIndex < sideModuleCount)
+                    setFunction(columnIndex, rowIndex, ringIndex !== 2 && ringIndex !== 4);
+            }
+        }
+    }
+    const alignments = alignmentIndexes(versionNumber, sideModuleCount);
+    const lastAlignmentIndex = alignments.length - 1;
+    alignments.forEach((centerColumnIndex, alignmentColumnIndex) => alignments.forEach((centerRowIndex, alignmentRowIndex) => {
+        const isCorner = (alignmentColumnIndex === 0 && alignmentRowIndex === 0) || (alignmentColumnIndex === 0 && alignmentRowIndex === lastAlignmentIndex) || (alignmentColumnIndex === lastAlignmentIndex && alignmentRowIndex === 0);
+        if (isCorner)
+            return;
+        for (let rowOffsetIndex = -2; rowOffsetIndex <= 2; rowOffsetIndex++) {
+            for (let columnOffsetIndex = -2; columnOffsetIndex <= 2; columnOffsetIndex++) {
+                setFunction(centerColumnIndex + columnOffsetIndex, centerRowIndex + rowOffsetIndex, Math.max(Math.abs(columnOffsetIndex), Math.abs(rowOffsetIndex)) !== 1);
+            }
+        }
+    }));
+    const drawFormat = (maskIndex) => {
+        const formatNumber = (MEDIUM_CORRECTION_FORMAT_NUMBER << 3) | maskIndex;
+        let remainderNumber = formatNumber;
+        for (let stepIndex = 0; stepIndex < 10; stepIndex++)
+            remainderNumber = (remainderNumber << 1) ^ ((remainderNumber >>> 9) * 0x537);
+        const formatBitsNumber = ((formatNumber << 10) | remainderNumber) ^ 0x5412;
+        for (let bitIndex = 0; bitIndex <= 5; bitIndex++)
+            setFunction(8, bitIndex, isBitSet(formatBitsNumber, bitIndex));
+        setFunction(8, 7, isBitSet(formatBitsNumber, 6));
+        setFunction(8, 8, isBitSet(formatBitsNumber, 7));
+        setFunction(7, 8, isBitSet(formatBitsNumber, 8));
+        for (let bitIndex = 9; bitIndex < 15; bitIndex++)
+            setFunction(14 - bitIndex, 8, isBitSet(formatBitsNumber, bitIndex));
+        for (let bitIndex = 0; bitIndex < 8; bitIndex++)
+            setFunction(sideModuleCount - 1 - bitIndex, 8, isBitSet(formatBitsNumber, bitIndex));
+        for (let bitIndex = 8; bitIndex < 15; bitIndex++)
+            setFunction(8, sideModuleCount - 15 + bitIndex, isBitSet(formatBitsNumber, bitIndex));
+        setFunction(8, sideModuleCount - 8, true);
+    };
+    drawFormat(0);
+    if (versionNumber >= 7) {
+        let remainderNumber = versionNumber;
+        for (let stepIndex = 0; stepIndex < 12; stepIndex++)
+            remainderNumber = (remainderNumber << 1) ^ ((remainderNumber >>> 11) * 0x1f25);
+        const versionBitsNumber = (versionNumber << 12) | remainderNumber;
+        for (let bitIndex = 0; bitIndex < 18; bitIndex++) {
+            const farIndex = sideModuleCount - 11 + (bitIndex % 3);
+            const nearIndex = Math.floor(bitIndex / 3);
+            setFunction(farIndex, nearIndex, isBitSet(versionBitsNumber, bitIndex));
+            setFunction(nearIndex, farIndex, isBitSet(versionBitsNumber, bitIndex));
+        }
+    }
+    // The codewords, zigzagging up and down two columns at a time from the bottom right.
+    let codewordBitIndex = 0;
+    for (let rightColumnIndex = sideModuleCount - 1; rightColumnIndex >= 1; rightColumnIndex -= 2) {
+        if (rightColumnIndex === 6)
+            rightColumnIndex = 5;
+        for (let stepIndex = 0; stepIndex < sideModuleCount; stepIndex++) {
+            for (let pairIndex = 0; pairIndex < 2; pairIndex++) {
+                const columnIndex = rightColumnIndex - pairIndex;
+                const rowIndex = ((rightColumnIndex + 1) & 2) === 0 ? sideModuleCount - 1 - stepIndex : stepIndex;
+                if (!isFunction[rowIndex][columnIndex] && codewordBitIndex < codewords.length * 8) {
+                    modules[rowIndex][columnIndex] = isBitSet(codewords[codewordBitIndex >>> 3], 7 - (codewordBitIndex & 7));
+                    codewordBitIndex++;
+                }
+            }
+        }
+    }
+    // The mask that reads best.
+    const masked = (maskIndex) => {
+        const copy = modules.map((row) => row.slice());
+        for (let rowIndex = 0; rowIndex < sideModuleCount; rowIndex++) {
+            for (let columnIndex = 0; columnIndex < sideModuleCount; columnIndex++) {
+                if (!isFunction[rowIndex][columnIndex] && MASKS[maskIndex](columnIndex, rowIndex))
+                    copy[rowIndex][columnIndex] = !copy[rowIndex][columnIndex];
+            }
+        }
+        return copy;
+    };
+    let bestMaskIndex = 0;
+    let bestPointCount = Infinity;
+    for (let maskIndex = 0; maskIndex < MASKS.length; maskIndex++) {
+        drawFormat(maskIndex);
+        const pointCount = penaltyPointCount(masked(maskIndex));
+        if (pointCount < bestPointCount) {
+            bestMaskIndex = maskIndex;
+            bestPointCount = pointCount;
+        }
+    }
+    drawFormat(bestMaskIndex);
+    return masked(bestMaskIndex);
+}
+/** The code for `text` as an SVG document: dark modules on white, with the quiet zone, one unit a module. */
+export function qrCodeSvg(text) {
+    const modules = qrCodeModules(text);
+    const marginModuleCount = QR_CODE_LIMITS.quietZoneModuleCount;
+    const sideModuleCount = modules.length + marginModuleCount * 2;
+    let path = "";
+    modules.forEach((row, rowIndex) => {
+        for (let columnIndex = 0; columnIndex < row.length; columnIndex++) {
+            if (!row[columnIndex])
+                continue;
+            let runEndIndex = columnIndex;
+            while (runEndIndex + 1 < row.length && row[runEndIndex + 1])
+                runEndIndex++;
+            const runModuleCount = runEndIndex - columnIndex + 1;
+            path += `M${columnIndex + marginModuleCount} ${rowIndex + marginModuleCount}h${runModuleCount}v1h-${runModuleCount}z`;
+            columnIndex = runEndIndex;
+        }
+    });
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${sideModuleCount} ${sideModuleCount}" shape-rendering="crispEdges"><rect width="${sideModuleCount}" height="${sideModuleCount}" fill="#fff"/><path d="${path}" fill="#000"/></svg>`;
+}