@tensor_1/react 2.47.0 → 2.49.0

package/dist/labels-context.d.ts

@@ -1,7 +1,7 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
 import { PaginationLabels } from './components/Pagination.js';
-import { e as SchedulingCalendarLabels } from './SchedulingCalendar-B6TakO2h.js';
+import { e as SchedulingCalendarLabels } from './SchedulingCalendar-WWyFL3Eo.js';
 import { DateRangePickerLabels } from './components/DateRangePicker.js';
 import { DatePickerLabels, DateTimePickerLabels } from './components/DatePicker.js';
 import { SchedulingTimelineLabels } from './components/SchedulingTimeline.js';
@@ -17,10 +17,29 @@ import { OrgChartLabels } from './components/OrgChart.js';
 import { InlineEditLabels } from './components/InlineEdit.js';
 import { DiscardPromptLabels } from './components/DiscardPrompt.js';
 import { SearchBarLabels } from './components/SearchBar.js';
+import { KeyboardGrabLabels } from './hooks/useKeyboardGrab.js';
+import { LightboxLabels } from './components/Lightbox.js';
+import { SortableListLabels } from './components/SortableList.js';
+import { DiffViewerLabels } from './components/DiffViewer.js';
+import { MatchReviewLabels } from './components/MatchReview.js';
+import { QrCodeLabels } from './components/QrCode.js';
+import { CodeDisplayLabels } from './components/CodeDisplay.js';
+import { ContactCardLabels } from './components/ContactCard.js';
+import { PrintLayoutLabels } from './components/PrintLayout.js';
+import { QrScannerLabels } from './components/QrScanner.js';
+import { PasswordInputLabels } from './components/PasswordInput.js';
+import { TimePickerLabels } from './components/TimePicker.js';
+import { TagInputLabels } from './components/TagInput.js';
+import { AccountMenuLabels } from './components/AccountMenu.js';
+import { DisplayPreferencesLabels } from './components/DisplayPreferences.js';
 import { ButtonResultLabels } from './components/ButtonFeedback.js';
+import { AuditLogLabels } from './components/AuditLog.js';
+import { DataWorkspaceLabels } from './components/DataWorkspace.js';
 import './link.js';
 import './calendar-model.js';
 import './scheduling-calendar-model.js';
+import './components/SchedulingResourceDay.js';
+import './scheduling-resource-model.js';
 import './overlay-position.js';
 import './scheduling-timeline-model.js';
 import './text-diff-model.js';
@@ -32,6 +51,14 @@ import './file-model.js';
 import './components/SearchSuggest.js';
 import './components/Button.js';
 import './components/Kbd.js';
+import './diff-model.js';
+import './qr-model.js';
+import './components/Input.js';
+import './components/Avatar.js';
+import './display-preferences-model.js';
+import './components/StatusPill.js';
+import './components/Table.js';
+import './components/TableControls.js';
 
 /**
  * Kit chrome strings by component (HAR-1358; TENSOR C20, MOTUS executive summary #3).
@@ -58,16 +85,28 @@ interface UixLabels {
         next?: string;
         close?: string;
     };
+    /** `Lightbox` (HAR-1826): previous / next / close, the counter, the zoom toggle. */
+    lightbox?: Partial<LightboxLabels>;
     toast?: {
         dismiss?: string;
     };
     toaster?: {
         region?: string;
     };
+    /**
+     * `openNav`: the phone-tier button that opens the navigation drawer; `navigation`: that
+     * drawer's title (HAR-1371).
+     */
     appShell?: {
         skipToContent?: string;
         exitFocus?: string;
+        openNav?: string;
+        navigation?: string;
     };
+    /** `ThemeSwitcher` and `DisplayPreferences` (HAR-1372): the setting names and their choices. */
+    displayPreferences?: Partial<DisplayPreferencesLabels>;
+    /** `AccountMenu` (HAR-1371): the menu's name. */
+    accountMenu?: Partial<AccountMenuLabels>;
     sidebar?: {
         expand?: string;
         collapse?: string;
@@ -77,32 +116,67 @@ interface UixLabels {
     };
     /** `SearchBar` (HAR-2030): the clear button's name and the submit button's text. */
     searchBar?: Partial<SearchBarLabels>;
-    /** `resultsOne` / `resultsMany`: the polite result count; `{count}`. */
+    /**
+     * `resultsOne` / `resultsMany`: the polite result count; `{count}`. Items mode (HAR-1378):
+     * `empty` when nothing matches, `recent` the heading of the recent items.
+     */
     commandPalette?: {
         input?: string;
         resultsOne?: string;
         resultsMany?: string;
+        empty?: string;
+        recent?: string;
     };
+    /** `QrCode` (HAR-1251): the text shown when the value is too long for a QR code. */
+    qrCode?: Partial<QrCodeLabels>;
+    /** `CodeDisplay` (HAR-1253): the countdown, the expiry announcements, the copy button's words. */
+    codeDisplay?: Partial<CodeDisplayLabels>;
+    /** `ContactCard` (HAR-1379): the Email / Call actions and the erased and unavailable states. */
+    contactCard?: Partial<ContactCardLabels>;
+    /** `PrintSignature` (HAR-986): the captions of the signature line and the stamp box. */
+    printLayout?: Partial<PrintLayoutLabels>;
+    /** `QrScanner` (HAR-1254): the start / stop buttons, every state's title and text, the read announcement. */
+    qrScanner?: Partial<QrScannerLabels>;
     entityPicker?: Partial<EntityPickerLabels>;
     tree?: Partial<TreeLabels>;
     /** `OrgChart` (HAR-1807): loading and error rows, the report count, the zoom toolbar. */
     orgChart?: Partial<OrgChartLabels>;
     inlineEdit?: Partial<InlineEditLabels>;
+    /** `SortableList` (HAR-1375): the grip, Move up / Move down, the move announcement. */
+    sortableList?: Partial<SortableListLabels>;
+    /** `useKeyboardGrab` (HAR-2590): picked up, dropped, cancelled; `{label}`. */
+    keyboardGrab?: Partial<KeyboardGrabLabels>;
+    /** `typeToConfirmMismatch` (HAR-1831): `{value}` is the text to type. */
     confirmDialog?: {
         typeToConfirm?: string;
         compensation?: string;
+        typeToConfirmMismatch?: string;
     };
     schedulingCalendar?: Partial<SchedulingCalendarLabels>;
     dateRangePicker?: Partial<DateRangePickerLabels>;
     datePicker?: Partial<DatePickerLabels>;
     dateTimePicker?: Partial<DateTimePickerLabels>;
+    /** `TimePicker` (HAR-1835), also the time part of `DateTimePicker`. */
+    timePicker?: Partial<TimePickerLabels>;
     schedulingTimeline?: Partial<SchedulingTimelineLabels>;
     textDiff?: Partial<TextDiffLabels>;
+    /** `DiffViewer` (HAR-1369): the version names, the resolution buttons, the summary. */
+    diffViewer?: Partial<DiffViewerLabels>;
+    /** `MatchReview` (HAR-1369): the decision table, bulk actions and the adopt mode. */
+    matchReview?: Partial<MatchReviewLabels>;
+    /** `AuditLog` (HAR-987): the filters, Details, Show older entries, and every state. */
+    auditLog?: Partial<AuditLogLabels>;
+    /** `DataWorkspace` (HAR-1388): the toolbar, selection, footer and states. */
+    dataWorkspace?: Partial<DataWorkspaceLabels>;
     filterEditor?: Partial<FilterEditorLabels>;
     select?: Partial<SelectLabels>;
     ruleBuilder?: Partial<RuleBuilderLabels>;
     fileUpload?: Partial<FileUploadLabels>;
     attachment?: Partial<AttachmentLabels>;
+    /** `TagInput` (HAR-1377): the chips' × names, the announcements and the refusals. */
+    tagInput?: Partial<TagInputLabels>;
+    /** `PasswordInput` (HAR-1376): the reveal toggle's name. */
+    passwordInput?: Partial<PasswordInputLabels>;
     /** `remove`: the name of a removable chip's × button; `{label}` is the chip text. */
     chip?: {
         remove?: string;
@@ -111,6 +185,8 @@ interface UixLabels {
     alert?: {
         dismiss?: string;
     };
+    /** Not words: the date format of every date field (HAR-2432). See {@link UixDateFormat}. */
+    dateFormat?: UixDateFormat;
     /** Read by `useUixLabels()` callers; `Pagination` itself is server-safe and takes `labels`. */
     pagination?: Partial<PaginationLabels>;
     /** Read by `useUixLabels()` callers; `BulkBar` itself is server-safe and takes `label`. */
@@ -118,6 +194,20 @@ interface UixLabels {
         region?: string;
     };
 }
+/**
+ * One date format for every date field below the provider (HAR-2432): `DatePicker`,
+ * `DateTimePicker`, `DateRangePicker` and `TimePicker` (its `locale`). Each field's own prop wins.
+ */
+interface UixDateFormat {
+    /** The locale of the field's text, month and weekday names, and the clock. */
+    locale?: string;
+    /** How a field writes a `YYYY-MM-DD` date, e.g. `(d) => d.split('-').reverse().join('.')`. */
+    formatDate?: (date: string) => string;
+    /** Read typed text into `YYYY-MM-DD`, or `null` when it is not a date. Pass it with `formatDate`. */
+    parseDate?: (text: string) => string | null;
+    /** The date field's placeholder, e.g. `TT.MM.JJJJ`. */
+    placeholder?: string;
+}
 interface UixLabelsProviderProps {
     labels: UixLabels;
     children?: ReactNode;
@@ -127,4 +217,4 @@ declare function UixLabelsProvider({ labels, children }: UixLabelsProviderProps)
 /** The chrome strings in effect here (empty outside a provider). */
 declare function useUixLabels(): UixLabels;
 
-export { type UixLabels, UixLabelsProvider, type UixLabelsProviderProps, useUixLabels };
+export { type UixDateFormat, type UixLabels, UixLabelsProvider, type UixLabelsProviderProps, useUixLabels };

package/dist/motion.d.ts

@@ -0,0 +1,11 @@
+declare const KEY_OPENED = "data-uix-key-opened";
+/** Start following the input modality (idempotent; capture phase, so nothing can hide it). */
+declare function watchInputModality(): void;
+/** Was the input that led here a key press? `false` before any input and on the server. */
+declare function keyboardInitiated(): boolean;
+/** Mark `el` instant when the current open or close came from the keyboard; clear it otherwise. */
+declare function markKeyOpened(el: Element | null | undefined): void;
+/** A time token (`--uix-dur-exit`) in milliseconds, read from `el` (default: the root), or `fallback`. */
+declare function tokenMs(name: string, fallback: number, el?: Element | null): number;
+
+export { KEY_OPENED, keyboardInitiated, markKeyOpened, tokenMs, watchInputModality };

package/dist/motion.js

@@ -0,0 +1,35 @@
+const KEY_OPENED = "data-uix-key-opened";
+let keyboard = false;
+let watching = false;
+function watchInputModality() {
+  if (watching || typeof document === "undefined") return;
+  watching = true;
+  document.addEventListener("keydown", (event) => {
+    if (!["Shift", "Control", "Alt", "Meta"].includes(event.key)) keyboard = true;
+  }, true);
+  document.addEventListener("pointerdown", () => {
+    keyboard = false;
+  }, true);
+}
+function keyboardInitiated() {
+  return keyboard;
+}
+function markKeyOpened(el) {
+  if (!el) return;
+  if (keyboard) el.setAttribute(KEY_OPENED, "");
+  else el.removeAttribute(KEY_OPENED);
+}
+function tokenMs(name, fallback, el) {
+  if (typeof getComputedStyle === "undefined" || typeof document === "undefined") return fallback;
+  const raw = getComputedStyle(el ?? document.documentElement).getPropertyValue(name).trim();
+  const m = /^(-?\d*\.?\d+)(ms|s)$/.exec(raw);
+  if (!m) return fallback;
+  return m[2] === "s" ? Number(m[1]) * 1e3 : Number(m[1]);
+}
+export {
+  KEY_OPENED,
+  keyboardInitiated,
+  markKeyOpened,
+  tokenMs,
+  watchInputModality
+};

package/dist/overlay-stack.d.ts

@@ -0,0 +1,6 @@
+/** Register an open overlay; the returned function removes it (call it when it closes). */
+declare function pushLayer(token: object): () => void;
+/** Whether `token` is the newest open overlay. */
+declare const isTopLayer: (token: object) => boolean;
+
+export { isTopLayer, pushLayer };

package/dist/overlay-stack.js

@@ -0,0 +1,13 @@
+const layers = [];
+function pushLayer(token) {
+  layers.push(token);
+  return () => {
+    const i = layers.lastIndexOf(token);
+    if (i >= 0) layers.splice(i, 1);
+  };
+}
+const isTopLayer = (token) => layers[layers.length - 1] === token;
+export {
+  isTopLayer,
+  pushLayer
+};

package/dist/qr-model.d.ts

@@ -0,0 +1,65 @@
+/**
+ * A QR Code encoder (ISO/IEC 18004) for `QrCode` (HAR-1251): byte mode (UTF-8), the four
+ * error-correction levels, versions 1 to 40, all eight masks scored by the standard's
+ * penalty rules. Pure and dependency-free, so a consumer never pulls a QR library in for a
+ * poster or a voucher. `qr-model.test.mjs` decodes its output with a reference decoder.
+ *
+ * The algorithm follows the standard's own construction (function patterns, Reed-Solomon over
+ * GF(256) with 0x11D, zig-zag placement, BCH-coded format and version information).
+ */
+/** How much of the symbol can be lost and still read: about 7, 15, 25 and 30 % of codewords. */
+type QrErrorCorrection = 'L' | 'M' | 'Q' | 'H';
+interface QrMatrix {
+    /** 1 to 40. Each version is 4 modules wider than the one before (version 1 is 21 × 21). */
+    version: number;
+    /** Modules per side, without the quiet zone. */
+    size: number;
+    errorCorrection: QrErrorCorrection;
+    /** The mask the penalty rules chose, 0 to 7. */
+    mask: number;
+    /** `modules[y][x]` is true for a dark module. */
+    modules: boolean[][];
+}
+interface QrEncodeOptions {
+    /** Default `M`: survives a crease or a smudge on a printed poster. */
+    errorCorrection?: QrErrorCorrection;
+    /**
+     * The smallest version to use (1 to 40); a larger one is chosen when the text needs it. A
+     * value that is not a finite number throws a `RangeError` (it is a mistake, not a long text).
+     */
+    minVersion?: number;
+    /**
+     * Mark text with characters beyond ASCII as UTF-8 with an ECI 26 designator (12 bits before
+     * the data). Off by default: most scanners read UTF-8 without it and a few old ones misread a
+     * symbol that has one; turn it on for a scanner that assumes ISO 8859-1 otherwise.
+     */
+    eci?: boolean;
+    /** Force a mask (0 to 7) instead of the lowest-penalty one; for tests. */
+    mask?: number;
+}
+/** Thrown when the text does not fit in version 40 at the requested level. */
+declare class QrCapacityError extends Error {
+    readonly bytes: number;
+    readonly errorCorrection: QrErrorCorrection;
+    constructor(bytes: number, errorCorrection: QrErrorCorrection);
+}
+/** Data codewords (bytes) a version holds at a level. */
+declare function qrDataCapacity(version: number, errorCorrection: QrErrorCorrection): number;
+/**
+ * The smallest version that holds `bytes` bytes at a level, or undefined past version 40.
+ * `headerBits` counts bits before the byte segment (12 for an ECI designator).
+ */
+declare function qrVersionFor(bytes: number, errorCorrection: QrErrorCorrection, minVersion?: number, headerBits?: number): number | undefined;
+/**
+ * Encodes `text` (as UTF-8 bytes) into a QR matrix: the smallest version that fits at the
+ * level, the mask with the lowest penalty. Throws `QrCapacityError` past version 40
+ * (2,953 bytes at L, 1,273 at H).
+ */
+declare function encodeQr(text: string, options?: QrEncodeOptions): QrMatrix;
+/**
+ * The dark modules as one SVG path in module units, offset by `margin` (the quiet zone):
+ * one `h`-run per stretch of dark modules in a row, so a version-10 symbol is one short path.
+ */
+declare function qrPath(matrix: QrMatrix, margin?: number): string;
+
+export { QrCapacityError, type QrEncodeOptions, type QrErrorCorrection, type QrMatrix, encodeQr, qrDataCapacity, qrPath, qrVersionFor };

package/dist/qr-model.js

@@ -0,0 +1,323 @@
+class QrCapacityError extends Error {
+  constructor(bytes, errorCorrection) {
+    super(`QR: ${bytes} bytes do not fit in version 40 at error correction ${errorCorrection}`);
+    this.name = "QrCapacityError";
+    this.bytes = bytes;
+    this.errorCorrection = errorCorrection;
+  }
+}
+const LEVEL_INDEX = { L: 0, M: 1, Q: 2, H: 3 };
+const FORMAT_BITS = { L: 1, M: 0, Q: 3, H: 2 };
+const ECC_PER_BLOCK = [
+  [-1, 7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+  [-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28],
+  [-1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+  [-1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]
+];
+const BLOCKS = [
+  [-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25],
+  [-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49],
+  [-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68],
+  [-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81]
+];
+function rawDataModules(version) {
+  let result = (16 * version + 128) * version + 64;
+  if (version >= 2) {
+    const align = Math.floor(version / 7) + 2;
+    result -= (25 * align - 10) * align - 55;
+    if (version >= 7) result -= 36;
+  }
+  return result;
+}
+function qrDataCapacity(version, errorCorrection) {
+  const level = LEVEL_INDEX[errorCorrection];
+  return Math.floor(rawDataModules(version) / 8) - ECC_PER_BLOCK[level][version] * BLOCKS[level][version];
+}
+const segmentBits = (bytes, version) => 4 + (version <= 9 ? 8 : 16) + bytes * 8;
+const ECI_UTF8_BITS = 12;
+function qrVersionFor(bytes, errorCorrection, minVersion = 1, headerBits = 0) {
+  if (!Number.isFinite(minVersion)) throw new RangeError(`QR: minVersion must be a number from 1 to 40, not ${minVersion}`);
+  for (let version = Math.max(1, Math.min(40, Math.floor(minVersion))); version <= 40; version += 1) {
+    if (bytes < (version <= 9 ? 256 : 65536) && headerBits + segmentBits(bytes, version) <= qrDataCapacity(version, errorCorrection) * 8) return version;
+  }
+  return void 0;
+}
+function gfMultiply(x, y) {
+  let z = 0;
+  for (let i = 7; i >= 0; i -= 1) {
+    z = z << 1 ^ (z >>> 7) * 285;
+    z ^= (y >>> i & 1) * x;
+  }
+  return z;
+}
+function rsDivisor(degree) {
+  const result = new Array(degree).fill(0);
+  result[degree - 1] = 1;
+  let root = 1;
+  for (let i = 0; i < degree; i += 1) {
+    for (let j = 0; j < result.length; j += 1) {
+      result[j] = gfMultiply(result[j], root);
+      if (j + 1 < result.length) result[j] ^= result[j + 1];
+    }
+    root = gfMultiply(root, 2);
+  }
+  return result;
+}
+function rsRemainder(data, divisor) {
+  const result = divisor.map(() => 0);
+  for (const byte of data) {
+    const factor = byte ^ result.shift();
+    result.push(0);
+    divisor.forEach((coefficient, i) => {
+      result[i] ^= gfMultiply(coefficient, factor);
+    });
+  }
+  return result;
+}
+function withErrorCorrection(data, version, errorCorrection) {
+  const level = LEVEL_INDEX[errorCorrection];
+  const blockCount = BLOCKS[level][version];
+  const eccLength = ECC_PER_BLOCK[level][version];
+  const rawCodewords = Math.floor(rawDataModules(version) / 8);
+  const shortBlocks = blockCount - rawCodewords % blockCount;
+  const shortLength = Math.floor(rawCodewords / blockCount);
+  const divisor = rsDivisor(eccLength);
+  const blocks = [];
+  for (let i = 0, k = 0; i < blockCount; i += 1) {
+    const block = data.slice(k, k + shortLength - eccLength + (i < shortBlocks ? 0 : 1));
+    k += block.length;
+    const ecc = rsRemainder(block, divisor);
+    if (i < shortBlocks) block.push(0);
+    blocks.push(block.concat(ecc));
+  }
+  const result = [];
+  for (let i = 0; i < blocks[0].length; i += 1) {
+    blocks.forEach((block, j) => {
+      if (i !== shortLength - eccLength || j >= shortBlocks) result.push(block[i]);
+    });
+  }
+  return result;
+}
+function dataCodewords(bytes, version, errorCorrection, eci) {
+  const bits = [];
+  const append = (value, length) => {
+    for (let i = length - 1; i >= 0; i -= 1) bits.push(value >>> i & 1);
+  };
+  if (eci) {
+    append(7, 4);
+    append(26, 8);
+  }
+  append(4, 4);
+  append(bytes.length, version <= 9 ? 8 : 16);
+  for (const byte of bytes) append(byte, 8);
+  const capacity = qrDataCapacity(version, errorCorrection) * 8;
+  append(0, Math.min(4, capacity - bits.length));
+  append(0, (8 - bits.length % 8) % 8);
+  for (let pad = 236; bits.length < capacity; pad ^= 236 ^ 17) append(pad, 8);
+  const codewords = [];
+  for (let i = 0; i < bits.length; i += 8) codewords.push(bits.slice(i, i + 8).reduce((byte, bit) => byte << 1 | bit, 0));
+  return codewords;
+}
+function alignmentPositions(version) {
+  if (version === 1) return [];
+  const count = Math.floor(version / 7) + 2;
+  const step = Math.floor((version * 8 + count * 3 + 5) / (count * 4 - 4)) * 2;
+  const result = [6];
+  for (let position = version * 4 + 17 - 7; result.length < count; position -= step) result.splice(1, 0, position);
+  return result;
+}
+const MASKS = [
+  (x, y) => (x + y) % 2 === 0,
+  (_x, y) => y % 2 === 0,
+  (x) => x % 3 === 0,
+  (x, y) => (x + y) % 3 === 0,
+  (x, y) => (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0,
+  (x, y) => x * y % 2 + x * y % 3 === 0,
+  (x, y) => (x * y % 2 + x * y % 3) % 2 === 0,
+  (x, y) => ((x + y) % 2 + x * y % 3) % 2 === 0
+];
+class QrSymbol {
+  constructor(version, errorCorrection) {
+    this.version = version;
+    this.errorCorrection = errorCorrection;
+    this.size = version * 4 + 17;
+    this.modules = Array.from({ length: this.size }, () => new Array(this.size).fill(false));
+    this.reserved = Array.from({ length: this.size }, () => new Array(this.size).fill(false));
+    this.drawFunctionPatterns();
+  }
+  set(x, y, dark) {
+    this.modules[y][x] = dark;
+    this.reserved[y][x] = true;
+  }
+  drawFunctionPatterns() {
+    const { size } = this;
+    for (let i = 0; i < size; i += 1) {
+      this.set(6, i, i % 2 === 0);
+      this.set(i, 6, i % 2 === 0);
+    }
+    for (const [cx, cy] of [[3, 3], [size - 4, 3], [3, size - 4]]) {
+      for (let dy = -4; dy <= 4; dy += 1) {
+        for (let dx = -4; dx <= 4; dx += 1) {
+          const x = cx + dx;
+          const y = cy + dy;
+          if (x < 0 || x >= size || y < 0 || y >= size) continue;
+          const ring = Math.max(Math.abs(dx), Math.abs(dy));
+          this.set(x, y, ring !== 2 && ring !== 4);
+        }
+      }
+    }
+    const positions = alignmentPositions(this.version);
+    const last = positions.length - 1;
+    positions.forEach((cx, i) => positions.forEach((cy, j) => {
+      if (i === 0 && j === 0 || i === 0 && j === last || i === last && j === 0) return;
+      for (let dy = -2; dy <= 2; dy += 1) {
+        for (let dx = -2; dx <= 2; dx += 1) this.set(cx + dx, cy + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+      }
+    }));
+    this.drawFormat(0);
+    this.drawVersion();
+  }
+  drawFormat(mask) {
+    const data = FORMAT_BITS[this.errorCorrection] << 3 | mask;
+    let remainder = data;
+    for (let i = 0; i < 10; i += 1) remainder = remainder << 1 ^ (remainder >>> 9) * 1335;
+    const bits = (data << 10 | remainder) ^ 21522;
+    const bit = (i) => (bits >>> i & 1) !== 0;
+    const { size } = this;
+    for (let i = 0; i <= 5; i += 1) this.set(8, i, bit(i));
+    this.set(8, 7, bit(6));
+    this.set(8, 8, bit(7));
+    this.set(7, 8, bit(8));
+    for (let i = 9; i < 15; i += 1) this.set(14 - i, 8, bit(i));
+    for (let i = 0; i < 8; i += 1) this.set(size - 1 - i, 8, bit(i));
+    for (let i = 8; i < 15; i += 1) this.set(8, size - 15 + i, bit(i));
+    this.set(8, size - 8, true);
+  }
+  drawVersion() {
+    if (this.version < 7) return;
+    let remainder = this.version;
+    for (let i = 0; i < 12; i += 1) remainder = remainder << 1 ^ (remainder >>> 11) * 7973;
+    const bits = this.version << 12 | remainder;
+    for (let i = 0; i < 18; i += 1) {
+      const dark = (bits >>> i & 1) !== 0;
+      const a = this.size - 11 + i % 3;
+      const b = Math.floor(i / 3);
+      this.set(a, b, dark);
+      this.set(b, a, dark);
+    }
+  }
+  drawCodewords(codewords) {
+    const { size } = this;
+    let i = 0;
+    for (let right = size - 1; right >= 1; right -= 2) {
+      if (right === 6) right = 5;
+      for (let vertical = 0; vertical < size; vertical += 1) {
+        for (let j = 0; j < 2; j += 1) {
+          const x = right - j;
+          const upward = (right + 1 & 2) === 0;
+          const y = upward ? size - 1 - vertical : vertical;
+          if (this.reserved[y][x] || i >= codewords.length * 8) continue;
+          this.modules[y][x] = (codewords[i >>> 3] >>> 7 - (i & 7) & 1) !== 0;
+          i += 1;
+        }
+      }
+    }
+  }
+  /** XORs a mask over the data modules; applying it twice undoes it. */
+  applyMask(mask) {
+    const flip = MASKS[mask];
+    for (let y = 0; y < this.size; y += 1) {
+      for (let x = 0; x < this.size; x += 1) {
+        if (!this.reserved[y][x] && flip(x, y)) this.modules[y][x] = !this.modules[y][x];
+      }
+    }
+  }
+  /** The standard's four penalty rules: runs, 2 × 2 blocks, finder look-alikes, dark balance. */
+  penalty() {
+    const { size, modules } = this;
+    let score = 0;
+    const line = (get) => {
+      let run = 1;
+      for (let i = 1; i <= size; i += 1) {
+        if (i < size && get(i) === get(i - 1)) {
+          run += 1;
+          continue;
+        }
+        if (run >= 5) score += 3 + (run - 5);
+        run = 1;
+      }
+      for (let i = 0; i + 11 <= size; i += 1) {
+        const window = Array.from({ length: 11 }, (_, k) => get(i + k));
+        const core = window[4] && !window[5] && window[6] && window[7] && window[8] && !window[9] && window[10];
+        const coreReverse = window[0] && !window[1] && window[2] && window[3] && window[4] && !window[5] && window[6];
+        if (core && !window[0] && !window[1] && !window[2] && !window[3]) score += 40;
+        if (coreReverse && !window[7] && !window[8] && !window[9] && !window[10]) score += 40;
+      }
+    };
+    for (let y = 0; y < size; y += 1) line((x) => modules[y][x]);
+    for (let x = 0; x < size; x += 1) line((y) => modules[y][x]);
+    let dark = 0;
+    for (let y = 0; y < size; y += 1) {
+      for (let x = 0; x < size; x += 1) {
+        const value = modules[y][x];
+        if (value) dark += 1;
+        if (x + 1 < size && y + 1 < size && value === modules[y][x + 1] && value === modules[y + 1][x] && value === modules[y + 1][x + 1]) score += 3;
+      }
+    }
+    const total = size * size;
+    score += (Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1) * 10;
+    return score;
+  }
+}
+function utf8(text) {
+  if (typeof TextEncoder !== "undefined") return new TextEncoder().encode(text);
+  const escaped = unescape(encodeURIComponent(text));
+  return Uint8Array.from(escaped, (c) => c.charCodeAt(0));
+}
+function encodeQr(text, options = {}) {
+  const errorCorrection = options.errorCorrection ?? "M";
+  const bytes = utf8(text);
+  const eci = options.eci === true && bytes.some((byte) => byte >= 128);
+  const version = qrVersionFor(bytes.length, errorCorrection, options.minVersion ?? 1, eci ? ECI_UTF8_BITS : 0);
+  if (version === void 0) throw new QrCapacityError(bytes.length, errorCorrection);
+  const symbol = new QrSymbol(version, errorCorrection);
+  symbol.drawCodewords(withErrorCorrection(dataCodewords(bytes, version, errorCorrection, eci), version, errorCorrection));
+  let mask = options.mask;
+  if (mask === void 0) {
+    let best = Infinity;
+    for (let candidate = 0; candidate < 8; candidate += 1) {
+      symbol.applyMask(candidate);
+      symbol.drawFormat(candidate);
+      const score = symbol.penalty();
+      if (score < best) {
+        best = score;
+        mask = candidate;
+      }
+      symbol.applyMask(candidate);
+    }
+  }
+  symbol.applyMask(mask);
+  symbol.drawFormat(mask);
+  return { version, size: symbol.size, errorCorrection, mask, modules: symbol.modules };
+}
+function qrPath(matrix, margin = 4) {
+  const parts = [];
+  matrix.modules.forEach((row, y) => {
+    for (let x = 0; x < row.length; x += 1) {
+      if (!row[x]) continue;
+      let end = x;
+      while (end + 1 < row.length && row[end + 1]) end += 1;
+      const length = end - x + 1;
+      parts.push(`M${x + margin} ${y + margin}h${length}v1h-${length}z`);
+      x = end;
+    }
+  });
+  return parts.join("");
+}
+export {
+  QrCapacityError,
+  encodeQr,
+  qrDataCapacity,
+  qrPath,
+  qrVersionFor
+};