@patrickdk77/xfa-flatten 0.0.0-stage → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (74) hide show
  1. package/LICENSE +21 -0
  2. package/LICENSE-APACHE-2.0 +202 -0
  3. package/NOTICE +14 -0
  4. package/README.md +112 -2
  5. package/dist/barcode-paint.d.ts +11 -0
  6. package/dist/barcode-paint.js +135 -0
  7. package/dist/barcode.d.ts +45 -0
  8. package/dist/barcode.js +750 -0
  9. package/dist/canvas.d.ts +59 -0
  10. package/dist/canvas.js +179 -0
  11. package/dist/cli.d.ts +2 -0
  12. package/dist/cli.js +34 -0
  13. package/dist/css.d.ts +48 -0
  14. package/dist/css.js +288 -0
  15. package/dist/deadline.d.ts +6 -0
  16. package/dist/deadline.js +18 -0
  17. package/dist/filters.d.ts +21 -0
  18. package/dist/filters.js +296 -0
  19. package/dist/flatten.d.ts +25 -0
  20. package/dist/flatten.js +319 -0
  21. package/dist/font-metrics.d.ts +9 -0
  22. package/dist/font-metrics.js +215 -0
  23. package/dist/fonts.d.ts +36 -0
  24. package/dist/fonts.js +144 -0
  25. package/dist/images.d.ts +23 -0
  26. package/dist/images.js +519 -0
  27. package/dist/index.d.ts +2 -0
  28. package/dist/index.js +5 -0
  29. package/dist/index.mjs +3 -0
  30. package/dist/layout.d.ts +64 -0
  31. package/dist/layout.js +779 -0
  32. package/dist/limits.d.ts +2 -0
  33. package/dist/limits.js +6 -0
  34. package/dist/locale.d.ts +29 -0
  35. package/dist/locale.js +97 -0
  36. package/dist/paint.d.ts +15 -0
  37. package/dist/paint.js +533 -0
  38. package/dist/pdf-crypt.d.ts +35 -0
  39. package/dist/pdf-crypt.js +261 -0
  40. package/dist/pdf-read.d.ts +140 -0
  41. package/dist/pdf-read.js +1026 -0
  42. package/dist/pdf417-table.d.ts +2 -0
  43. package/dist/pdf417-table.js +146 -0
  44. package/dist/pdfjs-repair.d.ts +13 -0
  45. package/dist/pdfjs-repair.js +257 -0
  46. package/dist/pdfjs.d.ts +16 -0
  47. package/dist/pdfjs.js +62 -0
  48. package/dist/picture.d.ts +40 -0
  49. package/dist/picture.js +678 -0
  50. package/dist/saslprep.d.ts +11 -0
  51. package/dist/saslprep.js +178 -0
  52. package/dist/style.d.ts +29 -0
  53. package/dist/style.js +178 -0
  54. package/dist/text.d.ts +44 -0
  55. package/dist/text.js +199 -0
  56. package/dist/tiff.d.ts +3 -0
  57. package/dist/tiff.js +270 -0
  58. package/dist/tree.d.ts +23 -0
  59. package/dist/tree.js +54 -0
  60. package/dist/types.d.ts +31 -0
  61. package/dist/types.js +2 -0
  62. package/dist/writer.d.ts +38 -0
  63. package/dist/writer.js +145 -0
  64. package/dist/xfa-apply.d.ts +49 -0
  65. package/dist/xfa-apply.js +617 -0
  66. package/dist/xfa-model.d.ts +42 -0
  67. package/dist/xfa-model.js +227 -0
  68. package/dist/xfa-paint.d.ts +24 -0
  69. package/dist/xfa-paint.js +275 -0
  70. package/dist/xfa-spec.d.ts +47 -0
  71. package/dist/xfa-spec.js +3 -0
  72. package/dist/xml.d.ts +30 -0
  73. package/dist/xml.js +211 -0
  74. package/package.json +83 -4
@@ -0,0 +1,750 @@
1
+ "use strict";
2
+ // Barcode encoders for the types XFA forms use most: Code 39, Code 128, QR Code and PDF417.
3
+ // Linear codes come back as module widths (bar first); 2D codes as a grid of dark modules.
4
+ Object.defineProperty(exports, "__esModule", { value: true });
5
+ exports.MAX_LINEAR_LENGTH = void 0;
6
+ exports.encodeCode39 = encodeCode39;
7
+ exports.encodeCode128 = encodeCode128;
8
+ exports.encodeQr = encodeQr;
9
+ exports.encodePdf417 = encodePdf417;
10
+ const pdf417_table_1 = require("./pdf417-table");
11
+ /** The longest value a linear code (Code 39, Code 128) takes. A longer one could not be printed at a readable size. */
12
+ exports.MAX_LINEAR_LENGTH = 1000;
13
+ /** Byte-mode capacities: QR version 40-L holds 2953 bytes; PDF417 holds at most 1850. */
14
+ const QR_MAX_BYTES = 2953;
15
+ const PDF417_MAX_BYTES = 1850;
16
+ /**
17
+ * The bytes a 2D code carries for `data`: ISO 8859-1 when every character is in it (the default reading of QR and
18
+ * PDF417 byte mode, so no ECI is needed), else UTF-8 with the ECI designator for UTF-8 (26). Null past `max` bytes,
19
+ * checked on the string length before anything is encoded.
20
+ */
21
+ function payloadBytes(data, max) {
22
+ if (data.length > max)
23
+ return null;
24
+ let latin1 = true;
25
+ for (let i = 0; i < data.length; i++)
26
+ if (data.charCodeAt(i) > 0xff)
27
+ latin1 = false;
28
+ const bytes = latin1 ? Buffer.from(data, 'latin1') : Buffer.from(data, 'utf8');
29
+ return bytes.length > max ? null : { bytes, utf8: !latin1 };
30
+ }
31
+ // Code 39: narrow (n) and wide (w) elements for each character, bar first, nine elements.
32
+ const C39_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%*';
33
+ const C39 = [
34
+ 'nnnwwnwnn',
35
+ 'wnnwnnnnw',
36
+ 'nnwwnnnnw',
37
+ 'wnwwnnnnn',
38
+ 'nnnwwnnnw',
39
+ 'wnnwwnnnn',
40
+ 'nnwwwnnnn',
41
+ 'nnnwnnwnw',
42
+ 'wnnwnnwnn',
43
+ 'nnwwnnwnn',
44
+ 'wnnnnwnnw',
45
+ 'nnwnnwnnw',
46
+ 'wnwnnwnnn',
47
+ 'nnnnwwnnw',
48
+ 'wnnnwwnnn',
49
+ 'nnwnwwnnn',
50
+ 'nnnnnwwnw',
51
+ 'wnnnnwwnn',
52
+ 'nnwnnwwnn',
53
+ 'nnnnwwwnn',
54
+ 'wnnnnnnww',
55
+ 'nnwnnnnww',
56
+ 'wnwnnnnwn',
57
+ 'nnnnwnnww',
58
+ 'wnnnwnnwn',
59
+ 'nnwnwnnwn',
60
+ 'nnnnnnwww',
61
+ 'wnnnnnwwn',
62
+ 'nnwnnnwwn',
63
+ 'nnnnwnwwn',
64
+ 'wwnnnnnnw',
65
+ 'nwwnnnnnw',
66
+ 'wwwnnnnnn',
67
+ 'nwnnwnnnw',
68
+ 'wwnnwnnnn',
69
+ 'nwwnwnnnn',
70
+ 'nwnnnnwnw',
71
+ 'wwnnnnwnn',
72
+ 'nwwnnnwnn',
73
+ 'nwnwnwnnn',
74
+ 'nwnwnnnwn',
75
+ 'nwnnnwnwn',
76
+ 'nnnwnwnwn',
77
+ 'nwnnwnwnn',
78
+ ];
79
+ /**
80
+ * Full ASCII Code 39 (code3of9extended): each ASCII character as one or two Code 39 characters. Index is the character
81
+ * code, 0 to 127.
82
+ */
83
+ const C39_FULL_ASCII = (() => {
84
+ const out = [];
85
+ const letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
86
+ for (let c = 0; c < 128; c++) {
87
+ const ch = String.fromCharCode(c);
88
+ if (c === 0)
89
+ out.push('%U');
90
+ else if (c <= 26)
91
+ out.push(`$${letters[c - 1]}`);
92
+ else if (c <= 31)
93
+ out.push(`%${'ABCDE'[c - 27]}`);
94
+ else if (c === 32 || c === 45 || c === 46 || (c >= 48 && c <= 57) || (c >= 65 && c <= 90))
95
+ out.push(ch);
96
+ else if (c <= 44)
97
+ out.push(`/${'ABCDEFGHIJKL'[c - 33]}`);
98
+ else if (c === 47)
99
+ out.push('/O');
100
+ else if (c === 58)
101
+ out.push('/Z');
102
+ else if (c <= 63)
103
+ out.push(`%${'FGHIJ'[c - 59]}`);
104
+ else if (c === 64)
105
+ out.push('%V');
106
+ else if (c <= 95)
107
+ out.push(`%${'KLMNO'[c - 91]}`);
108
+ else if (c === 96)
109
+ out.push('%W');
110
+ else if (c <= 122)
111
+ out.push(`+${letters[c - 97]}`);
112
+ else
113
+ out.push(`%${'PQRST'[c - 123]}`);
114
+ }
115
+ return out;
116
+ })();
117
+ /**
118
+ * Code 39. Plain Code 39 upper-cases the value and takes 0-9, A-Z and - . space $ / + %. The extended form takes any
119
+ * ASCII character. Null for a value the symbology cannot carry or longer than MAX_LINEAR_LENGTH.
120
+ */
121
+ function encodeCode39(data, ratio = 3, options = {}) {
122
+ if (data.length > exports.MAX_LINEAR_LENGTH)
123
+ return null;
124
+ let symbols;
125
+ if (options.extended) {
126
+ symbols = '';
127
+ for (let i = 0; i < data.length; i++) {
128
+ const pair = C39_FULL_ASCII[data.charCodeAt(i)];
129
+ if (pair === undefined)
130
+ return null;
131
+ symbols += pair;
132
+ }
133
+ }
134
+ else
135
+ symbols = data.toUpperCase();
136
+ let text = options.extended ? data : symbols;
137
+ if (options.checkDigit) {
138
+ let sum = 0;
139
+ for (const ch of symbols) {
140
+ const k = C39_CHARS.indexOf(ch);
141
+ if (k < 0 || k > 42)
142
+ return null;
143
+ sum += k;
144
+ }
145
+ const check = C39_CHARS[sum % 43];
146
+ symbols += check;
147
+ if (options.printCheckDigit)
148
+ text += check;
149
+ }
150
+ const r = ratio >= 2 && ratio <= 3 ? ratio : 3;
151
+ const widths = [];
152
+ const chars = `*${symbols}*`;
153
+ for (let i = 0; i < chars.length; i++) {
154
+ const k = C39_CHARS.indexOf(chars[i]);
155
+ if (k < 0 || (chars[i] === '*' && i > 0 && i < chars.length - 1))
156
+ return null;
157
+ for (const e of C39[k])
158
+ widths.push(e === 'w' ? r : 1);
159
+ if (i < chars.length - 1)
160
+ widths.push(1);
161
+ }
162
+ return { kind: 'linear', widths, text };
163
+ }
164
+ // Code 128 patterns: six element widths (bar first) for values 0 to 105, then the stop pattern.
165
+ const C128 = [
166
+ '212222',
167
+ '222122',
168
+ '222221',
169
+ '121223',
170
+ '121322',
171
+ '131222',
172
+ '122213',
173
+ '122312',
174
+ '132212',
175
+ '221213',
176
+ '221312',
177
+ '231212',
178
+ '112232',
179
+ '122132',
180
+ '122231',
181
+ '113222',
182
+ '123122',
183
+ '123221',
184
+ '223211',
185
+ '221132',
186
+ '221231',
187
+ '213212',
188
+ '223112',
189
+ '312131',
190
+ '311222',
191
+ '321122',
192
+ '321221',
193
+ '312212',
194
+ '322112',
195
+ '322211',
196
+ '212123',
197
+ '212321',
198
+ '232121',
199
+ '111323',
200
+ '131123',
201
+ '131321',
202
+ '112313',
203
+ '132113',
204
+ '132311',
205
+ '211313',
206
+ '231113',
207
+ '231311',
208
+ '112133',
209
+ '112331',
210
+ '132131',
211
+ '113123',
212
+ '113321',
213
+ '133121',
214
+ '313121',
215
+ '211331',
216
+ '231131',
217
+ '213113',
218
+ '213311',
219
+ '213131',
220
+ '311123',
221
+ '311321',
222
+ '331121',
223
+ '312113',
224
+ '312311',
225
+ '332111',
226
+ '314111',
227
+ '221411',
228
+ '431111',
229
+ '111224',
230
+ '111422',
231
+ '121124',
232
+ '121421',
233
+ '141122',
234
+ '141221',
235
+ '112214',
236
+ '112412',
237
+ '122114',
238
+ '122411',
239
+ '142112',
240
+ '142211',
241
+ '241211',
242
+ '221114',
243
+ '413111',
244
+ '241112',
245
+ '134111',
246
+ '111242',
247
+ '121142',
248
+ '121241',
249
+ '114212',
250
+ '124112',
251
+ '124211',
252
+ '411212',
253
+ '421112',
254
+ '421211',
255
+ '212141',
256
+ '214121',
257
+ '412121',
258
+ '111143',
259
+ '111341',
260
+ '131141',
261
+ '114113',
262
+ '114311',
263
+ '411113',
264
+ '411311',
265
+ '113141',
266
+ '114131',
267
+ '311141',
268
+ '411131',
269
+ '211412',
270
+ '211214',
271
+ '211232',
272
+ '2331112',
273
+ ];
274
+ /**
275
+ * Code 128 with code sets B and C (and A for control characters), switching to C for runs of four or more digits.
276
+ * Null for a character outside ASCII or a value longer than MAX_LINEAR_LENGTH.
277
+ */
278
+ function encodeCode128(data) {
279
+ if (data.length > exports.MAX_LINEAR_LENGTH)
280
+ return null;
281
+ const codes = [];
282
+ let set = null;
283
+ let i = 0;
284
+ const digitRun = (from) => {
285
+ let n = 0;
286
+ while (from + n < data.length && data.charCodeAt(from + n) >= 48 && data.charCodeAt(from + n) <= 57)
287
+ n++;
288
+ return n;
289
+ };
290
+ while (i < data.length) {
291
+ const run = digitRun(i);
292
+ const useC = run >= 4 && (run % 2 === 0 || set === 'C' || i + run === data.length || run >= 5);
293
+ if (useC || (set === 'C' && run >= 2)) {
294
+ if (set !== 'C') {
295
+ codes.push(set === null ? 105 : 99);
296
+ set = 'C';
297
+ }
298
+ const pairs = Math.floor(run / 2);
299
+ for (let p = 0; p < pairs; p++) {
300
+ codes.push(Number(data.slice(i, i + 2)));
301
+ i += 2;
302
+ }
303
+ continue;
304
+ }
305
+ const c = data.charCodeAt(i);
306
+ if (c > 127)
307
+ return null;
308
+ const want = c < 32 ? 'A' : c >= 96 ? 'B' : set === 'A' ? 'A' : 'B';
309
+ if (set !== want) {
310
+ codes.push(set === null ? (want === 'A' ? 103 : 104) : want === 'A' ? 101 : 100);
311
+ set = want;
312
+ }
313
+ codes.push(want === 'A' ? (c < 32 ? c + 64 : c - 32) : c - 32);
314
+ i++;
315
+ }
316
+ if (codes.length === 0)
317
+ return null;
318
+ let sum = codes[0];
319
+ for (let k = 1; k < codes.length; k++)
320
+ sum += codes[k] * k;
321
+ codes.push(sum % 103, 106);
322
+ const widths = [];
323
+ for (const code of codes)
324
+ for (const d of C128[code])
325
+ widths.push(Number(d));
326
+ return { kind: 'linear', widths, text: data };
327
+ }
328
+ // Reed-Solomon over GF(256) with the QR polynomial 0x11D.
329
+ function gfMul(x, y) {
330
+ let z = 0;
331
+ for (let i = 7; i >= 0; i--) {
332
+ z = (z << 1) ^ ((z >>> 7) * 0x11d);
333
+ z ^= ((y >>> i) & 1) * x;
334
+ }
335
+ return z & 255;
336
+ }
337
+ function rsDivisor(degree) {
338
+ const result = new Array(degree).fill(0);
339
+ result[degree - 1] = 1;
340
+ let root = 1;
341
+ for (let i = 0; i < degree; i++) {
342
+ for (let j = 0; j < result.length; j++) {
343
+ result[j] = gfMul(result[j], root);
344
+ if (j + 1 < result.length)
345
+ result[j] ^= result[j + 1];
346
+ }
347
+ root = gfMul(root, 2);
348
+ }
349
+ return result;
350
+ }
351
+ function rsRemainder(data, divisor) {
352
+ const result = new Array(divisor.length).fill(0);
353
+ for (const b of data) {
354
+ const factor = b ^ (result.shift() ?? 0);
355
+ result.push(0);
356
+ divisor.forEach((coef, i) => {
357
+ result[i] ^= gfMul(coef, factor);
358
+ });
359
+ }
360
+ return result;
361
+ }
362
+ // QR tables by error correction level L, M, Q, H and version 1 to 40 (index 0 unused).
363
+ const QR_ECC_PER_BLOCK = [
364
+ [-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],
365
+ [-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],
366
+ [-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],
367
+ [-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],
368
+ ];
369
+ const QR_BLOCKS = [
370
+ [-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],
371
+ [-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],
372
+ [-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],
373
+ [-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],
374
+ ];
375
+ /** Format bits for levels L, M, Q, H. */
376
+ const QR_ECL_BITS = [1, 0, 3, 2];
377
+ function rawModules(ver) {
378
+ let r = (16 * ver + 128) * ver + 64;
379
+ if (ver >= 2) {
380
+ const n = Math.floor(ver / 7) + 2;
381
+ r -= (25 * n - 10) * n - 55;
382
+ if (ver >= 7)
383
+ r -= 36;
384
+ }
385
+ return r;
386
+ }
387
+ function dataCodewords(ver, ecl) {
388
+ return Math.floor(rawModules(ver) / 8) - QR_ECC_PER_BLOCK[ecl][ver] * QR_BLOCKS[ecl][ver];
389
+ }
390
+ function alignmentPositions(ver) {
391
+ if (ver === 1)
392
+ return [];
393
+ const n = Math.floor(ver / 7) + 2;
394
+ const step = Math.floor((ver * 8 + n * 3 + 5) / (n * 4 - 4)) * 2;
395
+ const out = [6];
396
+ for (let pos = ver * 4 + 17 - 7; out.length < n; pos -= step)
397
+ out.splice(1, 0, pos);
398
+ return out;
399
+ }
400
+ /**
401
+ * QR Code in byte mode. eclIndex 0 to 3 is L, M, Q, H. Text outside ISO 8859-1 goes as UTF-8 behind an ECI 26
402
+ * designator.
403
+ */
404
+ function encodeQr(data, eclIndex) {
405
+ const ecl = Math.max(0, Math.min(3, Math.round(eclIndex)));
406
+ const payload = payloadBytes(data, QR_MAX_BYTES);
407
+ if (!payload)
408
+ return null;
409
+ const bytes = payload.bytes;
410
+ const eciBits = payload.utf8 ? 12 : 0;
411
+ let ver = 1;
412
+ for (; ver <= 40; ver++) {
413
+ const ccBits = ver <= 9 ? 8 : 16;
414
+ if (eciBits + 4 + ccBits + bytes.length * 8 <= dataCodewords(ver, ecl) * 8)
415
+ break;
416
+ }
417
+ if (ver > 40)
418
+ return null;
419
+ const capacity = dataCodewords(ver, ecl) * 8;
420
+ const bits = [];
421
+ const put = (v, n) => {
422
+ for (let i = n - 1; i >= 0; i--)
423
+ bits.push((v >>> i) & 1);
424
+ };
425
+ if (payload.utf8) {
426
+ put(7, 4);
427
+ put(26, 8);
428
+ }
429
+ put(4, 4);
430
+ put(bytes.length, ver <= 9 ? 8 : 16);
431
+ for (const b of bytes)
432
+ put(b, 8);
433
+ put(0, Math.min(4, capacity - bits.length));
434
+ put(0, (8 - (bits.length % 8)) % 8);
435
+ for (let pad = 0xec; bits.length < capacity; pad ^= 0xec ^ 0x11)
436
+ put(pad, 8);
437
+ const cw = [];
438
+ for (let i = 0; i < bits.length; i += 8) {
439
+ let v = 0;
440
+ for (let k = 0; k < 8; k++)
441
+ v = (v << 1) | bits[i + k];
442
+ cw.push(v);
443
+ }
444
+ // Split into blocks, add error correction, interleave.
445
+ const numBlocks = QR_BLOCKS[ecl][ver];
446
+ const eccLen = QR_ECC_PER_BLOCK[ecl][ver];
447
+ const raw = Math.floor(rawModules(ver) / 8);
448
+ const numShort = numBlocks - (raw % numBlocks);
449
+ const shortLen = Math.floor(raw / numBlocks);
450
+ const div = rsDivisor(eccLen);
451
+ const blocks = [];
452
+ for (let i = 0, k = 0; i < numBlocks; i++) {
453
+ const dat = cw.slice(k, k + shortLen - eccLen + (i < numShort ? 0 : 1));
454
+ k += dat.length;
455
+ const ecc = rsRemainder(dat, div);
456
+ if (i < numShort)
457
+ dat.push(0);
458
+ blocks.push([...dat, ...ecc]);
459
+ }
460
+ const all = [];
461
+ for (let i = 0; i < blocks[0].length; i++) {
462
+ blocks.forEach((b, j) => {
463
+ if (i !== shortLen - eccLen || j >= numShort)
464
+ all.push(b[i]);
465
+ });
466
+ }
467
+ const size = ver * 4 + 17;
468
+ const best = bestMask(size, ver, ecl, all);
469
+ return { kind: 'matrix', rows: best, rowHeight: 1, quiet: 4 };
470
+ }
471
+ function bestMask(size, ver, ecl, codewords) {
472
+ let best = null;
473
+ let bestPenalty = Number.POSITIVE_INFINITY;
474
+ for (let mask = 0; mask < 8; mask++) {
475
+ const m = buildQr(size, ver, ecl, codewords, mask);
476
+ const p = penalty(m);
477
+ if (p < bestPenalty) {
478
+ bestPenalty = p;
479
+ best = m;
480
+ }
481
+ }
482
+ return best ?? buildQr(size, ver, ecl, codewords, 0);
483
+ }
484
+ function buildQr(size, ver, ecl, codewords, mask) {
485
+ const mod = Array.from({ length: size }, () => new Array(size).fill(false));
486
+ const fn = Array.from({ length: size }, () => new Array(size).fill(false));
487
+ const set = (x, y, dark) => {
488
+ mod[y][x] = dark;
489
+ fn[y][x] = true;
490
+ };
491
+ for (let i = 0; i < size; i++) {
492
+ set(6, i, i % 2 === 0);
493
+ set(i, 6, i % 2 === 0);
494
+ }
495
+ const finder = (cx, cy) => {
496
+ for (let dy = -4; dy <= 4; dy++) {
497
+ for (let dx = -4; dx <= 4; dx++) {
498
+ const d = Math.max(Math.abs(dx), Math.abs(dy));
499
+ const x = cx + dx;
500
+ const y = cy + dy;
501
+ if (x >= 0 && x < size && y >= 0 && y < size)
502
+ set(x, y, d !== 2 && d !== 4);
503
+ }
504
+ }
505
+ };
506
+ finder(3, 3);
507
+ finder(size - 4, 3);
508
+ finder(3, size - 4);
509
+ const al = alignmentPositions(ver);
510
+ for (let i = 0; i < al.length; i++) {
511
+ for (let j = 0; j < al.length; j++) {
512
+ if ((i === 0 && j === 0) || (i === 0 && j === al.length - 1) || (i === al.length - 1 && j === 0))
513
+ continue;
514
+ for (let dy = -2; dy <= 2; dy++)
515
+ for (let dx = -2; dx <= 2; dx++)
516
+ set(al[i] + dx, al[j] + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
517
+ }
518
+ }
519
+ const drawFormat = () => {
520
+ const data = (QR_ECL_BITS[ecl] << 3) | mask;
521
+ let rem = data;
522
+ for (let i = 0; i < 10; i++)
523
+ rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
524
+ const b = ((data << 10) | rem) ^ 0x5412;
525
+ const bit = (k) => ((b >>> k) & 1) !== 0;
526
+ for (let i = 0; i <= 5; i++)
527
+ set(8, i, bit(i));
528
+ set(8, 7, bit(6));
529
+ set(8, 8, bit(7));
530
+ set(7, 8, bit(8));
531
+ for (let i = 9; i < 15; i++)
532
+ set(14 - i, 8, bit(i));
533
+ for (let i = 0; i < 8; i++)
534
+ set(size - 1 - i, 8, bit(i));
535
+ for (let i = 8; i < 15; i++)
536
+ set(8, size - 15 + i, bit(i));
537
+ set(8, size - 8, true);
538
+ };
539
+ drawFormat();
540
+ if (ver >= 7) {
541
+ let rem = ver;
542
+ for (let i = 0; i < 12; i++)
543
+ rem = (rem << 1) ^ ((rem >>> 11) * 0x1f25);
544
+ const b = (ver << 12) | rem;
545
+ for (let i = 0; i < 18; i++) {
546
+ const dark = ((b >>> i) & 1) !== 0;
547
+ const a = size - 11 + (i % 3);
548
+ const c = Math.floor(i / 3);
549
+ set(a, c, dark);
550
+ set(c, a, dark);
551
+ }
552
+ }
553
+ // Data in the zigzag order, two columns at a time from the right, skipping the timing column.
554
+ let bitIndex = 0;
555
+ for (let right = size - 1; right >= 1; right -= 2) {
556
+ if (right === 6)
557
+ right = 5;
558
+ for (let vert = 0; vert < size; vert++) {
559
+ for (let j = 0; j < 2; j++) {
560
+ const x = right - j;
561
+ const upward = ((right + 1) & 2) === 0;
562
+ const y = upward ? size - 1 - vert : vert;
563
+ if (!fn[y][x] && bitIndex < codewords.length * 8) {
564
+ mod[y][x] = ((codewords[bitIndex >>> 3] >>> (7 - (bitIndex & 7))) & 1) !== 0;
565
+ bitIndex++;
566
+ }
567
+ }
568
+ }
569
+ }
570
+ for (let y = 0; y < size; y++) {
571
+ for (let x = 0; x < size; x++) {
572
+ if (fn[y][x])
573
+ continue;
574
+ let inv = false;
575
+ switch (mask) {
576
+ case 0:
577
+ inv = (x + y) % 2 === 0;
578
+ break;
579
+ case 1:
580
+ inv = y % 2 === 0;
581
+ break;
582
+ case 2:
583
+ inv = x % 3 === 0;
584
+ break;
585
+ case 3:
586
+ inv = (x + y) % 3 === 0;
587
+ break;
588
+ case 4:
589
+ inv = (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0;
590
+ break;
591
+ case 5:
592
+ inv = ((x * y) % 2) + ((x * y) % 3) === 0;
593
+ break;
594
+ case 6:
595
+ inv = (((x * y) % 2) + ((x * y) % 3)) % 2 === 0;
596
+ break;
597
+ default:
598
+ inv = (((x + y) % 2) + ((x * y) % 3)) % 2 === 0;
599
+ break;
600
+ }
601
+ if (inv)
602
+ mod[y][x] = !mod[y][x];
603
+ }
604
+ }
605
+ return mod;
606
+ }
607
+ /** A simplified mask penalty: long runs, 2x2 blocks and dark balance (finder-like patterns are not scored). */
608
+ function penalty(m) {
609
+ const n = m.length;
610
+ let p = 0;
611
+ for (let y = 0; y < n; y++) {
612
+ for (const horizontal of [true, false]) {
613
+ let run = 1;
614
+ for (let x = 1; x < n; x++) {
615
+ const a = horizontal ? m[y][x] : m[x][y];
616
+ const b = horizontal ? m[y][x - 1] : m[x - 1][y];
617
+ if (a === b)
618
+ run++;
619
+ else {
620
+ if (run >= 5)
621
+ p += run - 2;
622
+ run = 1;
623
+ }
624
+ }
625
+ if (run >= 5)
626
+ p += run - 2;
627
+ }
628
+ }
629
+ let dark = 0;
630
+ for (let y = 0; y < n; y++) {
631
+ for (let x = 0; x < n; x++) {
632
+ if (m[y][x])
633
+ dark++;
634
+ if (x + 1 < n && y + 1 < n && m[y][x] === m[y][x + 1] && m[y][x] === m[y + 1][x] && m[y][x] === m[y + 1][x + 1])
635
+ p += 3;
636
+ }
637
+ }
638
+ const total = n * n;
639
+ p += Math.floor(Math.abs(dark * 20 - total * 10) / total) * 10;
640
+ return p;
641
+ }
642
+ // PDF417: byte compaction, Reed-Solomon over GF(929).
643
+ function pdf417Ecc(data, level) {
644
+ const k = 2 ** (level + 1);
645
+ let g = [1];
646
+ let root = 3;
647
+ for (let i = 1; i <= k; i++) {
648
+ const next = new Array(g.length + 1).fill(0);
649
+ for (let j = 0; j < g.length; j++) {
650
+ next[j + 1] = (next[j + 1] + g[j]) % 929;
651
+ next[j] = (next[j] + 929 - ((g[j] * root) % 929)) % 929;
652
+ }
653
+ g = next;
654
+ root = (root * 3) % 929;
655
+ }
656
+ const coef = g.slice(0, k);
657
+ const e = new Array(k).fill(0);
658
+ for (const d of data) {
659
+ const t1 = (d + e[k - 1]) % 929;
660
+ for (let j = k - 1; j >= 1; j--) {
661
+ const t2 = (t1 * coef[j]) % 929;
662
+ e[j] = (e[j - 1] + 929 - t2) % 929;
663
+ }
664
+ e[0] = (929 - ((t1 * coef[0]) % 929)) % 929;
665
+ }
666
+ return e.map(v => (v === 0 ? 0 : 929 - v)).reverse();
667
+ }
668
+ function byteCompaction(bytes) {
669
+ const out = [bytes.length % 6 === 0 ? 924 : 901];
670
+ let i = 0;
671
+ for (; i + 6 <= bytes.length; i += 6) {
672
+ let v = 0n;
673
+ for (let k = 0; k < 6; k++)
674
+ v = v * 256n + BigInt(bytes[i + k]);
675
+ const group = [];
676
+ for (let k = 0; k < 5; k++) {
677
+ group.unshift(Number(v % 900n));
678
+ v /= 900n;
679
+ }
680
+ out.push(...group);
681
+ }
682
+ for (; i < bytes.length; i++)
683
+ out.push(bytes[i]);
684
+ return out;
685
+ }
686
+ const PDF417_START = [8, 1, 1, 1, 1, 1, 1, 3];
687
+ const PDF417_STOP = [7, 1, 1, 3, 1, 1, 1, 2, 1];
688
+ /**
689
+ * PDF417 in byte compaction. columns is the preferred number of data columns (1 to 30); 0 asks for a near-square
690
+ * symbol. When the data does not fit at that width, the nearest column count it fits is taken. rowHeight is the row
691
+ * height in modules; each row is listed once. Text outside ISO 8859-1 goes as UTF-8 behind an ECI 26 designator.
692
+ */
693
+ function encodePdf417(data, level, columns, rowHeight) {
694
+ const ecLevel = Math.max(0, Math.min(8, Math.round(level)));
695
+ const bytes = payloadBytes(data, PDF417_MAX_BYTES);
696
+ if (!bytes)
697
+ return null;
698
+ const payload = [...(bytes.utf8 ? [927, 26] : []), ...byteCompaction(bytes.bytes)];
699
+ const eccCount = 2 ** (ecLevel + 1);
700
+ const need = payload.length + 1 + eccCount;
701
+ const want = columns ? Math.max(1, Math.min(30, Math.round(columns))) : Math.max(1, Math.min(30, Math.round(Math.sqrt(need / 3))));
702
+ const fits = (c) => {
703
+ const r = Math.max(3, Math.ceil(need / c));
704
+ return r <= 90 && r * c <= 928;
705
+ };
706
+ // The fitting column count nearest the one wanted, wider first on a tie.
707
+ let cols = 0;
708
+ for (let d = 0; d < 30 && cols === 0; d++) {
709
+ if (want + d <= 30 && fits(want + d))
710
+ cols = want + d;
711
+ else if (want - d >= 1 && fits(want - d))
712
+ cols = want - d;
713
+ }
714
+ if (cols === 0)
715
+ return null;
716
+ const rows = Math.max(3, Math.ceil(need / cols));
717
+ const dataCount = rows * cols - eccCount;
718
+ const cw = [dataCount, ...payload];
719
+ while (cw.length < dataCount)
720
+ cw.push(900);
721
+ const all = [...cw, ...pdf417Ecc(cw, ecLevel)];
722
+ const out = [];
723
+ const h = Math.max(1, Math.round(rowHeight));
724
+ for (let r = 0; r < rows; r++) {
725
+ const rowCluster = r % 3;
726
+ const base = 30 * Math.floor(r / 3);
727
+ const rl = [base + Math.floor((rows - 1) / 3), base + ecLevel * 3 + ((rows - 1) % 3), base + (cols - 1)];
728
+ const rr = [base + (cols - 1), base + Math.floor((rows - 1) / 3), base + ecLevel * 3 + ((rows - 1) % 3)];
729
+ const row = [];
730
+ const widths = (w) => {
731
+ w.forEach((n, i) => {
732
+ for (let k = 0; k < n; k++)
733
+ row.push(i % 2 === 0);
734
+ });
735
+ };
736
+ const pattern = (codeword) => {
737
+ const p = (0, pdf417_table_1.pdf417Pattern)(rowCluster, codeword);
738
+ for (let b = 16; b >= 0; b--)
739
+ row.push(((p >>> b) & 1) === 1);
740
+ };
741
+ widths(PDF417_START);
742
+ pattern(rl[rowCluster]);
743
+ for (let c = 0; c < cols; c++)
744
+ pattern(all[r * cols + c]);
745
+ pattern(rr[rowCluster]);
746
+ widths(PDF417_STOP);
747
+ out.push(row);
748
+ }
749
+ return { kind: 'matrix', rows: out, rowHeight: h, quiet: 2 };
750
+ }