bjchy-auth-sdk
Version:
朝阳区认证SDK - 简洁易用的扫码登录和请求工具包
1,861 lines • 80.7 kB
JavaScript
import { ref, computed, watch, onMounted, onUnmounted, createElementBlock, openBlock, createCommentVNode, createElementVNode, toDisplayString, normalizeStyle } from "vue";
import axios from "axios";
const STREET_MAP = {
"blz": { key: "blz", name: "八里庄街道" },
"yyc": { key: "yyc", name: "亚运村街道" },
"hjl": { key: "hjl", name: "呼家楼街道" }
};
function detectStreetKey(url = window.location.href) {
const urlParams = new URLSearchParams(window.location.search);
const streetParam = urlParams.get("street");
if (streetParam && STREET_MAP[streetParam]) {
return streetParam;
}
const pathSegments = window.location.pathname.split("/").filter((segment) => segment);
for (const segment of pathSegments) {
if (STREET_MAP[segment]) {
return segment;
}
}
const hostname = window.location.hostname.toLowerCase();
for (const streetKey in STREET_MAP) {
if (hostname.includes(streetKey)) {
return streetKey;
}
}
const streetKeys = Object.keys(STREET_MAP).join("|");
const regex2 = new RegExp(`(${streetKeys})`, "gi");
const match = url.match(regex2);
if (match && match[0] && STREET_MAP[match[0].toLowerCase()]) {
const foundKey = match[0].toLowerCase();
return foundKey;
}
const savedStreet = localStorage.getItem("bjchy_current_street");
if (savedStreet && STREET_MAP[savedStreet]) {
return savedStreet;
}
return null;
}
function getStreetConfig(streetKey) {
return STREET_MAP[streetKey] || null;
}
function setCurrentStreet(streetKey) {
if (STREET_MAP[streetKey]) {
localStorage.setItem("bjchy_current_street", streetKey);
if (typeof window !== "undefined") {
window.__BJCHY_CURRENT_STREET__ = streetKey;
}
}
}
function getCurrentStreetKey() {
if (typeof window !== "undefined" && window.__BJCHY_CURRENT_STREET__) {
return window.__BJCHY_CURRENT_STREET__;
}
const savedStreet = localStorage.getItem("bjchy_current_street");
if (savedStreet && STREET_MAP[savedStreet]) {
return savedStreet;
}
return detectStreetKey();
}
function getValidStreetKeys() {
return Object.keys(STREET_MAP);
}
const DEFAULT_SDK_CONFIG = {
// baseURL: 'https://pdb.bjchy.gov.cn/mdb2/webapi',
baseURL: "https://pdb.bjchy.gov.cn/mdb3/api",
timeout: 1e4,
tokenKey: "bjchy_token",
enableAutoDetectStreet: true,
enableTokenAutoRefresh: true,
loginUrl: "/",
// token过期后跳转的页面，默认为 '/'
tokenErrorCodes: [
// 需要触发登录跳转的token错误码
"TOKEN_EXPIRED",
// Token已过期
"INVALID_TOKEN",
// Token无效
"TOKEN_MALFORMED",
// Token格式错误
"TOKEN_NOT_ACTIVE",
// Token尚未生效
"MISSING_TOKEN",
// Token缺失
"MISSING_AUTH_HEADER",
// 缺少授权头
"INVALID_AUTH_FORMAT",
// 授权头格式错误
"TOKEN_EXTRACTION_ERROR"
// Token提取失败
]
};
let currentConfig = { ...DEFAULT_SDK_CONFIG };
const configListeners = /* @__PURE__ */ new Set();
function configureSDK(config = {}) {
console.log("📝 配置SDK:", config);
const newConfig = { ...currentConfig, ...config };
if (config.baseURL && typeof config.baseURL !== "string") {
throw new Error("baseURL 必须是字符串类型");
}
if (config.timeout && (typeof config.timeout !== "number" || config.timeout <= 0)) {
throw new Error("timeout 必须是正数");
}
const oldConfig = { ...currentConfig };
currentConfig = newConfig;
configListeners.forEach((listener) => {
try {
listener(newConfig, oldConfig);
} catch (error) {
console.error("配置监听器执行失败:", error);
}
});
console.log("✅ SDK配置已更新:", currentConfig);
return currentConfig;
}
function getSDKConfig() {
return { ...currentConfig };
}
function resetSDKConfig() {
console.log("🔄 重置SDK配置为默认值");
configureSDK(DEFAULT_SDK_CONFIG);
}
function addConfigListener(listener) {
if (typeof listener !== "function") {
throw new Error("监听器必须是函数");
}
configListeners.add(listener);
}
function removeConfigListener(listener) {
configListeners.delete(listener);
}
function getConfigValue(key) {
return currentConfig[key];
}
function validateConfig() {
const errors = [];
if (!currentConfig.baseURL) {
errors.push("baseURL 不能为空");
} else if (typeof currentConfig.baseURL !== "string") {
errors.push("baseURL 必须是字符串");
} else if (!currentConfig.baseURL.startsWith("http")) {
errors.push("baseURL 必须以 http:// 或 https:// 开头");
}
if (currentConfig.timeout <= 0) {
errors.push("timeout 必须大于 0");
}
if (!currentConfig.tokenKey || typeof currentConfig.tokenKey !== "string") {
errors.push("tokenKey 不能为空且必须是字符串");
}
return {
valid: errors.length === 0,
errors
};
}
function printConfig() {
console.group("🔧 当前SDK配置");
Object.entries(currentConfig).forEach(([key, value]) => {
console.log(`${key}:`, value);
});
console.groupEnd();
}
function createRequest() {
const globalConfig = getSDKConfig();
const instance = axios.create({
baseURL: globalConfig.baseURL,
timeout: globalConfig.timeout,
headers: {
"Content-Type": "application/json"
}
});
instance.interceptors.request.use(
(config) => {
const token = localStorage.getItem(globalConfig.tokenKey);
if (token) {
config.headers.Authorization = `Bearer ${token}`;
}
if (globalConfig.enableAutoDetectStreet) {
const currentStreet = detectStreetKey();
if (currentStreet) {
config.headers["X-Street-Key"] = currentStreet;
}
}
return config;
},
(error) => Promise.reject(error)
);
instance.interceptors.response.use(
(response) => {
const responseData = response.data;
if (responseData && responseData.success === false && responseData.code && globalConfig.tokenErrorCodes.includes(responseData.code)) {
localStorage.removeItem(globalConfig.tokenKey);
localStorage.removeItem("bjchy_user_info");
window.dispatchEvent(new CustomEvent("bjchy-token-expired", {
detail: {
response: responseData,
streetKey: detectStreetKey()
}
}));
const loginUrl = globalConfig.loginUrl || "/";
if (typeof window !== "undefined" && window.location) {
console.log(`🔄 Token失效(${responseData.code})，自动跳转到:`, loginUrl);
console.log("错误信息:", responseData.error || responseData.message);
}
return Promise.reject(new Error(responseData.error || responseData.message || "Token失效"));
}
if (globalConfig.enableTokenAutoRefresh) {
const newToken = response.headers["x-new-token"];
if (newToken) {
localStorage.setItem(globalConfig.tokenKey, newToken);
}
}
return response.data;
},
(error) => {
var _a;
if (((_a = error.response) == null ? void 0 : _a.status) === 401) {
localStorage.removeItem(globalConfig.tokenKey);
localStorage.removeItem("bjchy_user_info");
window.dispatchEvent(new CustomEvent("bjchy-token-expired", {
detail: { error, streetKey: detectStreetKey() }
}));
const loginUrl = globalConfig.loginUrl || "/";
if (typeof window !== "undefined" && window.location) {
console.log("🔄 Token过期(401)，自动跳转到:", loginUrl);
window.location.href = loginUrl;
}
}
return Promise.reject(error);
}
);
instance.get = (url, params = {}) => instance({ method: "GET", url, params });
instance.post = (url, data = {}) => instance({ method: "POST", url, data });
instance.put = (url, data = {}) => instance({ method: "PUT", url, data });
instance.delete = (url, params = {}) => instance({ method: "DELETE", url, params });
return instance;
}
let defaultRequestInstance = createRequest();
addConfigListener((newConfig, oldConfig) => {
const shouldRecreate = newConfig.baseURL !== oldConfig.baseURL || newConfig.timeout !== oldConfig.timeout || newConfig.tokenKey !== oldConfig.tokenKey || newConfig.enableAutoDetectStreet !== oldConfig.enableAutoDetectStreet || newConfig.enableTokenAutoRefresh !== oldConfig.enableTokenAutoRefresh || newConfig.loginUrl !== oldConfig.loginUrl || JSON.stringify(newConfig.tokenErrorCodes) !== JSON.stringify(oldConfig.tokenErrorCodes);
if (shouldRecreate) {
console.log("🔄 全局配置变更，重新创建默认请求实例");
defaultRequestInstance = createRequest();
request.get = defaultRequestInstance.get;
request.post = defaultRequestInstance.post;
request.put = defaultRequestInstance.put;
request.delete = defaultRequestInstance.delete;
Object.setPrototypeOf(request, defaultRequestInstance);
Object.assign(request, defaultRequestInstance);
}
});
const request = new Proxy(defaultRequestInstance, {
get(target, prop) {
return defaultRequestInstance[prop];
},
apply(target, thisArg, argumentsList) {
return defaultRequestInstance.apply(thisArg, argumentsList);
}
});
var browser = {};
var canPromise$1 = function() {
return typeof Promise === "function" && Promise.prototype && Promise.prototype.then;
};
var qrcode = {};
var utils$1 = {};
let toSJISFunction;
const CODEWORDS_COUNT = [
0,
// Not used
26,
44,
70,
100,
134,
172,
196,
242,
292,
346,
404,
466,
532,
581,
655,
733,
815,
901,
991,
1085,
1156,
1258,
1364,
1474,
1588,
1706,
1828,
1921,
2051,
2185,
2323,
2465,
2611,
2761,
2876,
3034,
3196,
3362,
3532,
3706
];
utils$1.getSymbolSize = function getSymbolSize(version2) {
if (!version2) throw new Error('"version" cannot be null or undefined');
if (version2 < 1 || version2 > 40) throw new Error('"version" should be in range from 1 to 40');
return version2 * 4 + 17;
};
utils$1.getSymbolTotalCodewords = function getSymbolTotalCodewords(version2) {
return CODEWORDS_COUNT[version2];
};
utils$1.getBCHDigit = function(data) {
let digit = 0;
while (data !== 0) {
digit++;
data >>>= 1;
}
return digit;
};
utils$1.setToSJISFunction = function setToSJISFunction(f) {
if (typeof f !== "function") {
throw new Error('"toSJISFunc" is not a valid function.');
}
toSJISFunction = f;
};
utils$1.isKanjiModeEnabled = function() {
return typeof toSJISFunction !== "undefined";
};
utils$1.toSJIS = function toSJIS(kanji2) {
return toSJISFunction(kanji2);
};
var errorCorrectionLevel = {};
(function(exports) {
exports.L = { bit: 1 };
exports.M = { bit: 0 };
exports.Q = { bit: 3 };
exports.H = { bit: 2 };
function fromString(string) {
if (typeof string !== "string") {
throw new Error("Param is not a string");
}
const lcStr = string.toLowerCase();
switch (lcStr) {
case "l":
case "low":
return exports.L;
case "m":
case "medium":
return exports.M;
case "q":
case "quartile":
return exports.Q;
case "h":
case "high":
return exports.H;
default:
throw new Error("Unknown EC Level: " + string);
}
}
exports.isValid = function isValid2(level) {
return level && typeof level.bit !== "undefined" && level.bit >= 0 && level.bit < 4;
};
exports.from = function from(value, defaultValue) {
if (exports.isValid(value)) {
return value;
}
try {
return fromString(value);
} catch (e) {
return defaultValue;
}
};
})(errorCorrectionLevel);
function BitBuffer$1() {
this.buffer = [];
this.length = 0;
}
BitBuffer$1.prototype = {
get: function(index) {
const bufIndex = Math.floor(index / 8);
return (this.buffer[bufIndex] >>> 7 - index % 8 & 1) === 1;
},
put: function(num, length) {
for (let i = 0; i < length; i++) {
this.putBit((num >>> length - i - 1 & 1) === 1);
}
},
getLengthInBits: function() {
return this.length;
},
putBit: function(bit) {
const bufIndex = Math.floor(this.length / 8);
if (this.buffer.length <= bufIndex) {
this.buffer.push(0);
}
if (bit) {
this.buffer[bufIndex] |= 128 >>> this.length % 8;
}
this.length++;
}
};
var bitBuffer = BitBuffer$1;
function BitMatrix$1(size) {
if (!size || size < 1) {
throw new Error("BitMatrix size must be defined and greater than 0");
}
this.size = size;
this.data = new Uint8Array(size * size);
this.reservedBit = new Uint8Array(size * size);
}
BitMatrix$1.prototype.set = function(row, col, value, reserved) {
const index = row * this.size + col;
this.data[index] = value;
if (reserved) this.reservedBit[index] = true;
};
BitMatrix$1.prototype.get = function(row, col) {
return this.data[row * this.size + col];
};
BitMatrix$1.prototype.xor = function(row, col, value) {
this.data[row * this.size + col] ^= value;
};
BitMatrix$1.prototype.isReserved = function(row, col) {
return this.reservedBit[row * this.size + col];
};
var bitMatrix = BitMatrix$1;
var alignmentPattern = {};
(function(exports) {
const getSymbolSize3 = utils$1.getSymbolSize;
exports.getRowColCoords = function getRowColCoords(version2) {
if (version2 === 1) return [];
const posCount = Math.floor(version2 / 7) + 2;
const size = getSymbolSize3(version2);
const intervals = size === 145 ? 26 : Math.ceil((size - 13) / (2 * posCount - 2)) * 2;
const positions = [size - 7];
for (let i = 1; i < posCount - 1; i++) {
positions[i] = positions[i - 1] - intervals;
}
positions.push(6);
return positions.reverse();
};
exports.getPositions = function getPositions2(version2) {
const coords = [];
const pos = exports.getRowColCoords(version2);
const posLength = pos.length;
for (let i = 0; i < posLength; i++) {
for (let j = 0; j < posLength; j++) {
if (i === 0 && j === 0 || // top-left
i === 0 && j === posLength - 1 || // bottom-left
i === posLength - 1 && j === 0) {
continue;
}
coords.push([pos[i], pos[j]]);
}
}
return coords;
};
})(alignmentPattern);
var finderPattern = {};
const getSymbolSize2 = utils$1.getSymbolSize;
const FINDER_PATTERN_SIZE = 7;
finderPattern.getPositions = function getPositions(version2) {
const size = getSymbolSize2(version2);
return [
// top-left
[0, 0],
// top-right
[size - FINDER_PATTERN_SIZE, 0],
// bottom-left
[0, size - FINDER_PATTERN_SIZE]
];
};
var maskPattern = {};
(function(exports) {
exports.Patterns = {
PATTERN000: 0,
PATTERN001: 1,
PATTERN010: 2,
PATTERN011: 3,
PATTERN100: 4,
PATTERN101: 5,
PATTERN110: 6,
PATTERN111: 7
};
const PenaltyScores = {
N1: 3,
N2: 3,
N3: 40,
N4: 10
};
exports.isValid = function isValid2(mask) {
return mask != null && mask !== "" && !isNaN(mask) && mask >= 0 && mask <= 7;
};
exports.from = function from(value) {
return exports.isValid(value) ? parseInt(value, 10) : void 0;
};
exports.getPenaltyN1 = function getPenaltyN1(data) {
const size = data.size;
let points = 0;
let sameCountCol = 0;
let sameCountRow = 0;
let lastCol = null;
let lastRow = null;
for (let row = 0; row < size; row++) {
sameCountCol = sameCountRow = 0;
lastCol = lastRow = null;
for (let col = 0; col < size; col++) {
let module = data.get(row, col);
if (module === lastCol) {
sameCountCol++;
} else {
if (sameCountCol >= 5) points += PenaltyScores.N1 + (sameCountCol - 5);
lastCol = module;
sameCountCol = 1;
}
module = data.get(col, row);
if (module === lastRow) {
sameCountRow++;
} else {
if (sameCountRow >= 5) points += PenaltyScores.N1 + (sameCountRow - 5);
lastRow = module;
sameCountRow = 1;
}
}
if (sameCountCol >= 5) points += PenaltyScores.N1 + (sameCountCol - 5);
if (sameCountRow >= 5) points += PenaltyScores.N1 + (sameCountRow - 5);
}
return points;
};
exports.getPenaltyN2 = function getPenaltyN2(data) {
const size = data.size;
let points = 0;
for (let row = 0; row < size - 1; row++) {
for (let col = 0; col < size - 1; col++) {
const last = data.get(row, col) + data.get(row, col + 1) + data.get(row + 1, col) + data.get(row + 1, col + 1);
if (last === 4 || last === 0) points++;
}
}
return points * PenaltyScores.N2;
};
exports.getPenaltyN3 = function getPenaltyN3(data) {
const size = data.size;
let points = 0;
let bitsCol = 0;
let bitsRow = 0;
for (let row = 0; row < size; row++) {
bitsCol = bitsRow = 0;
for (let col = 0; col < size; col++) {
bitsCol = bitsCol << 1 & 2047 | data.get(row, col);
if (col >= 10 && (bitsCol === 1488 || bitsCol === 93)) points++;
bitsRow = bitsRow << 1 & 2047 | data.get(col, row);
if (col >= 10 && (bitsRow === 1488 || bitsRow === 93)) points++;
}
}
return points * PenaltyScores.N3;
};
exports.getPenaltyN4 = function getPenaltyN4(data) {
let darkCount = 0;
const modulesCount = data.data.length;
for (let i = 0; i < modulesCount; i++) darkCount += data.data[i];
const k = Math.abs(Math.ceil(darkCount * 100 / modulesCount / 5) - 10);
return k * PenaltyScores.N4;
};
function getMaskAt(maskPattern2, i, j) {
switch (maskPattern2) {
case exports.Patterns.PATTERN000:
return (i + j) % 2 === 0;
case exports.Patterns.PATTERN001:
return i % 2 === 0;
case exports.Patterns.PATTERN010:
return j % 3 === 0;
case exports.Patterns.PATTERN011:
return (i + j) % 3 === 0;
case exports.Patterns.PATTERN100:
return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 === 0;
case exports.Patterns.PATTERN101:
return i * j % 2 + i * j % 3 === 0;
case exports.Patterns.PATTERN110:
return (i * j % 2 + i * j % 3) % 2 === 0;
case exports.Patterns.PATTERN111:
return (i * j % 3 + (i + j) % 2) % 2 === 0;
default:
throw new Error("bad maskPattern:" + maskPattern2);
}
}
exports.applyMask = function applyMask(pattern, data) {
const size = data.size;
for (let col = 0; col < size; col++) {
for (let row = 0; row < size; row++) {
if (data.isReserved(row, col)) continue;
data.xor(row, col, getMaskAt(pattern, row, col));
}
}
};
exports.getBestMask = function getBestMask(data, setupFormatFunc) {
const numPatterns = Object.keys(exports.Patterns).length;
let bestPattern = 0;
let lowerPenalty = Infinity;
for (let p = 0; p < numPatterns; p++) {
setupFormatFunc(p);
exports.applyMask(p, data);
const penalty = exports.getPenaltyN1(data) + exports.getPenaltyN2(data) + exports.getPenaltyN3(data) + exports.getPenaltyN4(data);
exports.applyMask(p, data);
if (penalty < lowerPenalty) {
lowerPenalty = penalty;
bestPattern = p;
}
}
return bestPattern;
};
})(maskPattern);
var errorCorrectionCode = {};
const ECLevel$1 = errorCorrectionLevel;
const EC_BLOCKS_TABLE = [
// L M Q H
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
2,
2,
1,
2,
2,
4,
1,
2,
4,
4,
2,
4,
4,
4,
2,
4,
6,
5,
2,
4,
6,
6,
2,
5,
8,
8,
4,
5,
8,
8,
4,
5,
8,
11,
4,
8,
10,
11,
4,
9,
12,
16,
4,
9,
16,
16,
6,
10,
12,
18,
6,
10,
17,
16,
6,
11,
16,
19,
6,
13,
18,
21,
7,
14,
21,
25,
8,
16,
20,
25,
8,
17,
23,
25,
9,
17,
23,
34,
9,
18,
25,
30,
10,
20,
27,
32,
12,
21,
29,
35,
12,
23,
34,
37,
12,
25,
34,
40,
13,
26,
35,
42,
14,
28,
38,
45,
15,
29,
40,
48,
16,
31,
43,
51,
17,
33,
45,
54,
18,
35,
48,
57,
19,
37,
51,
60,
19,
38,
53,
63,
20,
40,
56,
66,
21,
43,
59,
70,
22,
45,
62,
74,
24,
47,
65,
77,
25,
49,
68,
81
];
const EC_CODEWORDS_TABLE = [
// L M Q H
7,
10,
13,
17,
10,
16,
22,
28,
15,
26,
36,
44,
20,
36,
52,
64,
26,
48,
72,
88,
36,
64,
96,
112,
40,
72,
108,
130,
48,
88,
132,
156,
60,
110,
160,
192,
72,
130,
192,
224,
80,
150,
224,
264,
96,
176,
260,
308,
104,
198,
288,
352,
120,
216,
320,
384,
132,
240,
360,
432,
144,
280,
408,
480,
168,
308,
448,
532,
180,
338,
504,
588,
196,
364,
546,
650,
224,
416,
600,
700,
224,
442,
644,
750,
252,
476,
690,
816,
270,
504,
750,
900,
300,
560,
810,
960,
312,
588,
870,
1050,
336,
644,
952,
1110,
360,
700,
1020,
1200,
390,
728,
1050,
1260,
420,
784,
1140,
1350,
450,
812,
1200,
1440,
480,
868,
1290,
1530,
510,
924,
1350,
1620,
540,
980,
1440,
1710,
570,
1036,
1530,
1800,
570,
1064,
1590,
1890,
600,
1120,
1680,
1980,
630,
1204,
1770,
2100,
660,
1260,
1860,
2220,
720,
1316,
1950,
2310,
750,
1372,
2040,
2430
];
errorCorrectionCode.getBlocksCount = function getBlocksCount(version2, errorCorrectionLevel2) {
switch (errorCorrectionLevel2) {
case ECLevel$1.L:
return EC_BLOCKS_TABLE[(version2 - 1) * 4 + 0];
case ECLevel$1.M:
return EC_BLOCKS_TABLE[(version2 - 1) * 4 + 1];
case ECLevel$1.Q:
return EC_BLOCKS_TABLE[(version2 - 1) * 4 + 2];
case ECLevel$1.H:
return EC_BLOCKS_TABLE[(version2 - 1) * 4 + 3];
default:
return void 0;
}
};
errorCorrectionCode.getTotalCodewordsCount = function getTotalCodewordsCount(version2, errorCorrectionLevel2) {
switch (errorCorrectionLevel2) {
case ECLevel$1.L:
return EC_CODEWORDS_TABLE[(version2 - 1) * 4 + 0];
case ECLevel$1.M:
return EC_CODEWORDS_TABLE[(version2 - 1) * 4 + 1];
case ECLevel$1.Q:
return EC_CODEWORDS_TABLE[(version2 - 1) * 4 + 2];
case ECLevel$1.H:
return EC_CODEWORDS_TABLE[(version2 - 1) * 4 + 3];
default:
return void 0;
}
};
var polynomial = {};
var galoisField = {};
const EXP_TABLE = new Uint8Array(512);
const LOG_TABLE = new Uint8Array(256);
(function initTables() {
let x = 1;
for (let i = 0; i < 255; i++) {
EXP_TABLE[i] = x;
LOG_TABLE[x] = i;
x <<= 1;
if (x & 256) {
x ^= 285;
}
}
for (let i = 255; i < 512; i++) {
EXP_TABLE[i] = EXP_TABLE[i - 255];
}
})();
galoisField.log = function log(n) {
if (n < 1) throw new Error("log(" + n + ")");
return LOG_TABLE[n];
};
galoisField.exp = function exp(n) {
return EXP_TABLE[n];
};
galoisField.mul = function mul(x, y) {
if (x === 0 || y === 0) return 0;
return EXP_TABLE[LOG_TABLE[x] + LOG_TABLE[y]];
};
(function(exports) {
const GF = galoisField;
exports.mul = function mul2(p1, p2) {
const coeff = new Uint8Array(p1.length + p2.length - 1);
for (let i = 0; i < p1.length; i++) {
for (let j = 0; j < p2.length; j++) {
coeff[i + j] ^= GF.mul(p1[i], p2[j]);
}
}
return coeff;
};
exports.mod = function mod(divident, divisor) {
let result = new Uint8Array(divident);
while (result.length - divisor.length >= 0) {
const coeff = result[0];
for (let i = 0; i < divisor.length; i++) {
result[i] ^= GF.mul(divisor[i], coeff);
}
let offset = 0;
while (offset < result.length && result[offset] === 0) offset++;
result = result.slice(offset);
}
return result;
};
exports.generateECPolynomial = function generateECPolynomial(degree) {
let poly = new Uint8Array([1]);
for (let i = 0; i < degree; i++) {
poly = exports.mul(poly, new Uint8Array([1, GF.exp(i)]));
}
return poly;
};
})(polynomial);
const Polynomial = polynomial;
function ReedSolomonEncoder$1(degree) {
this.genPoly = void 0;
this.degree = degree;
if (this.degree) this.initialize(this.degree);
}
ReedSolomonEncoder$1.prototype.initialize = function initialize(degree) {
this.degree = degree;
this.genPoly = Polynomial.generateECPolynomial(this.degree);
};
ReedSolomonEncoder$1.prototype.encode = function encode(data) {
if (!this.genPoly) {
throw new Error("Encoder not initialized");
}
const paddedData = new Uint8Array(data.length + this.degree);
paddedData.set(data);
const remainder = Polynomial.mod(paddedData, this.genPoly);
const start = this.degree - remainder.length;
if (start > 0) {
const buff = new Uint8Array(this.degree);
buff.set(remainder, start);
return buff;
}
return remainder;
};
var reedSolomonEncoder = ReedSolomonEncoder$1;
var version = {};
var mode = {};
var versionCheck = {};
versionCheck.isValid = function isValid(version2) {
return !isNaN(version2) && version2 >= 1 && version2 <= 40;
};
var regex = {};
const numeric = "[0-9]+";
const alphanumeric = "[A-Z $%*+\\-./:]+";
let kanji = "(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+";
kanji = kanji.replace(/u/g, "\\u");
const byte = "(?:(?![A-Z0-9 $%*+\\-./:]|" + kanji + ")(?:.|[\r\n]))+";
regex.KANJI = new RegExp(kanji, "g");
regex.BYTE_KANJI = new RegExp("[^A-Z0-9 $%*+\\-./:]+", "g");
regex.BYTE = new RegExp(byte, "g");
regex.NUMERIC = new RegExp(numeric, "g");
regex.ALPHANUMERIC = new RegExp(alphanumeric, "g");
const TEST_KANJI = new RegExp("^" + kanji + "$");
const TEST_NUMERIC = new RegExp("^" + numeric + "$");
const TEST_ALPHANUMERIC = new RegExp("^[A-Z0-9 $%*+\\-./:]+$");
regex.testKanji = function testKanji(str) {
return TEST_KANJI.test(str);
};
regex.testNumeric = function testNumeric(str) {
return TEST_NUMERIC.test(str);
};
regex.testAlphanumeric = function testAlphanumeric(str) {
return TEST_ALPHANUMERIC.test(str);
};
(function(exports) {
const VersionCheck = versionCheck;
const Regex = regex;
exports.NUMERIC = {
id: "Numeric",
bit: 1 << 0,
ccBits: [10, 12, 14]
};
exports.ALPHANUMERIC = {
id: "Alphanumeric",
bit: 1 << 1,
ccBits: [9, 11, 13]
};
exports.BYTE = {
id: "Byte",
bit: 1 << 2,
ccBits: [8, 16, 16]
};
exports.KANJI = {
id: "Kanji",
bit: 1 << 3,
ccBits: [8, 10, 12]
};
exports.MIXED = {
bit: -1
};
exports.getCharCountIndicator = function getCharCountIndicator(mode2, version2) {
if (!mode2.ccBits) throw new Error("Invalid mode: " + mode2);
if (!VersionCheck.isValid(version2)) {
throw new Error("Invalid version: " + version2);
}
if (version2 >= 1 && version2 < 10) return mode2.ccBits[0];
else if (version2 < 27) return mode2.ccBits[1];
return mode2.ccBits[2];
};
exports.getBestModeForData = function getBestModeForData(dataStr) {
if (Regex.testNumeric(dataStr)) return exports.NUMERIC;
else if (Regex.testAlphanumeric(dataStr)) return exports.ALPHANUMERIC;
else if (Regex.testKanji(dataStr)) return exports.KANJI;
else return exports.BYTE;
};
exports.toString = function toString(mode2) {
if (mode2 && mode2.id) return mode2.id;
throw new Error("Invalid mode");
};
exports.isValid = function isValid2(mode2) {
return mode2 && mode2.bit && mode2.ccBits;
};
function fromString(string) {
if (typeof string !== "string") {
throw new Error("Param is not a string");
}
const lcStr = string.toLowerCase();
switch (lcStr) {
case "numeric":
return exports.NUMERIC;
case "alphanumeric":
return exports.ALPHANUMERIC;
case "kanji":
return exports.KANJI;
case "byte":
return exports.BYTE;
default:
throw new Error("Unknown mode: " + string);
}
}
exports.from = function from(value, defaultValue) {
if (exports.isValid(value)) {
return value;
}
try {
return fromString(value);
} catch (e) {
return defaultValue;
}
};
})(mode);
(function(exports) {
const Utils2 = utils$1;
const ECCode2 = errorCorrectionCode;
const ECLevel2 = errorCorrectionLevel;
const Mode2 = mode;
const VersionCheck = versionCheck;
const G18 = 1 << 12 | 1 << 11 | 1 << 10 | 1 << 9 | 1 << 8 | 1 << 5 | 1 << 2 | 1 << 0;
const G18_BCH = Utils2.getBCHDigit(G18);
function getBestVersionForDataLength(mode2, length, errorCorrectionLevel2) {
for (let currentVersion = 1; currentVersion <= 40; currentVersion++) {
if (length <= exports.getCapacity(currentVersion, errorCorrectionLevel2, mode2)) {
return currentVersion;
}
}
return void 0;
}
function getReservedBitsCount(mode2, version2) {
return Mode2.getCharCountIndicator(mode2, version2) + 4;
}
function getTotalBitsFromDataArray(segments2, version2) {
let totalBits = 0;
segments2.forEach(function(data) {
const reservedBits = getReservedBitsCount(data.mode, version2);
totalBits += reservedBits + data.getBitsLength();
});
return totalBits;
}
function getBestVersionForMixedData(segments2, errorCorrectionLevel2) {
for (let currentVersion = 1; currentVersion <= 40; currentVersion++) {
const length = getTotalBitsFromDataArray(segments2, currentVersion);
if (length <= exports.getCapacity(currentVersion, errorCorrectionLevel2, Mode2.MIXED)) {
return currentVersion;
}
}
return void 0;
}
exports.from = function from(value, defaultValue) {
if (VersionCheck.isValid(value)) {
return parseInt(value, 10);
}
return defaultValue;
};
exports.getCapacity = function getCapacity(version2, errorCorrectionLevel2, mode2) {
if (!VersionCheck.isValid(version2)) {
throw new Error("Invalid QR Code version");
}
if (typeof mode2 === "undefined") mode2 = Mode2.BYTE;
const totalCodewords = Utils2.getSymbolTotalCodewords(version2);
const ecTotalCodewords = ECCode2.getTotalCodewordsCount(version2, errorCorrectionLevel2);
const dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8;
if (mode2 === Mode2.MIXED) return dataTotalCodewordsBits;
const usableBits = dataTotalCodewordsBits - getReservedBitsCount(mode2, version2);
switch (mode2) {
case Mode2.NUMERIC:
return Math.floor(usableBits / 10 * 3);
case Mode2.ALPHANUMERIC:
return Math.floor(usableBits / 11 * 2);
case Mode2.KANJI:
return Math.floor(usableBits / 13);
case Mode2.BYTE:
default:
return Math.floor(usableBits / 8);
}
};
exports.getBestVersionForData = function getBestVersionForData(data, errorCorrectionLevel2) {
let seg;
const ecl = ECLevel2.from(errorCorrectionLevel2, ECLevel2.M);
if (Array.isArray(data)) {
if (data.length > 1) {
return getBestVersionForMixedData(data, ecl);
}
if (data.length === 0) {
return 1;
}
seg = data[0];
} else {
seg = data;
}
return getBestVersionForDataLength(seg.mode, seg.getLength(), ecl);
};
exports.getEncodedBits = function getEncodedBits2(version2) {
if (!VersionCheck.isValid(version2) || version2 < 7) {
throw new Error("Invalid QR Code version");
}
let d = version2 << 12;
while (Utils2.getBCHDigit(d) - G18_BCH >= 0) {
d ^= G18 << Utils2.getBCHDigit(d) - G18_BCH;
}
return version2 << 12 | d;
};
})(version);
var formatInfo = {};
const Utils$3 = utils$1;
const G15 = 1 << 10 | 1 << 8 | 1 << 5 | 1 << 4 | 1 << 2 | 1 << 1 | 1 << 0;
const G15_MASK = 1 << 14 | 1 << 12 | 1 << 10 | 1 << 4 | 1 << 1;
const G15_BCH = Utils$3.getBCHDigit(G15);
formatInfo.getEncodedBits = function getEncodedBits(errorCorrectionLevel2, mask) {
const data = errorCorrectionLevel2.bit << 3 | mask;
let d = data << 10;
while (Utils$3.getBCHDigit(d) - G15_BCH >= 0) {
d ^= G15 << Utils$3.getBCHDigit(d) - G15_BCH;
}
return (data << 10 | d) ^ G15_MASK;
};
var segments = {};
const Mode$4 = mode;
function NumericData(data) {
this.mode = Mode$4.NUMERIC;
this.data = data.toString();
}
NumericData.getBitsLength = function getBitsLength(length) {
return 10 * Math.floor(length / 3) + (length % 3 ? length % 3 * 3 + 1 : 0);
};
NumericData.prototype.getLength = function getLength() {
return this.data.length;
};
NumericData.prototype.getBitsLength = function getBitsLength2() {
return NumericData.getBitsLength(this.data.length);
};
NumericData.prototype.write = function write(bitBuffer2) {
let i, group, value;
for (i = 0; i + 3 <= this.data.length; i += 3) {
group = this.data.substr(i, 3);
value = parseInt(group, 10);
bitBuffer2.put(value, 10);
}
const remainingNum = this.data.length - i;
if (remainingNum > 0) {
group = this.data.substr(i);
value = parseInt(group, 10);
bitBuffer2.put(value, remainingNum * 3 + 1);
}
};
var numericData = NumericData;
const Mode$3 = mode;
const ALPHA_NUM_CHARS = [
"0",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9",
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I",
"J",
"K",
"L",
"M",
"N",
"O",
"P",
"Q",
"R",
"S",
"T",
"U",
"V",
"W",
"X",
"Y",
"Z",
" ",
"$",
"%",
"*",
"+",
"-",
".",
"/",
":"
];
function AlphanumericData(data) {
this.mode = Mode$3.ALPHANUMERIC;
this.data = data;
}
AlphanumericData.getBitsLength = function getBitsLength3(length) {
return 11 * Math.floor(length / 2) + 6 * (length % 2);
};
AlphanumericData.prototype.getLength = function getLength2() {
return this.data.length;
};
AlphanumericData.prototype.getBitsLength = function getBitsLength4() {
return AlphanumericData.getBitsLength(this.data.length);
};
AlphanumericData.prototype.write = function write2(bitBuffer2) {
let i;
for (i = 0; i + 2 <= this.data.length; i += 2) {
let value = ALPHA_NUM_CHARS.indexOf(this.data[i]) * 45;
value += ALPHA_NUM_CHARS.indexOf(this.data[i + 1]);
bitBuffer2.put(value, 11);
}
if (this.data.length % 2) {
bitBuffer2.put(ALPHA_NUM_CHARS.indexOf(this.data[i]), 6);
}
};
var alphanumericData = AlphanumericData;
const Mode$2 = mode;
function ByteData(data) {
this.mode = Mode$2.BYTE;
if (typeof data === "string") {
this.data = new TextEncoder().encode(data);
} else {
this.data = new Uint8Array(data);
}
}
ByteData.getBitsLength = function getBitsLength5(length) {
return length * 8;
};
ByteData.prototype.getLength = function getLength3() {
return this.data.length;
};
ByteData.prototype.getBitsLength = function getBitsLength6() {
return ByteData.getBitsLength(this.data.length);
};
ByteData.prototype.write = function(bitBuffer2) {
for (let i = 0, l = this.data.length; i < l; i++) {
bitBuffer2.put(this.data[i], 8);
}
};
var byteData = ByteData;
const Mode$1 = mode;
const Utils$2 = utils$1;
function KanjiData(data) {
this.mode = Mode$1.KANJI;
this.data = data;
}
KanjiData.getBitsLength = function getBitsLength7(length) {
return length * 13;
};
KanjiData.prototype.getLength = function getLength4() {
return this.data.length;
};
KanjiData.prototype.getBitsLength = function getBitsLength8() {
return KanjiData.getBitsLength(this.data.length);
};
KanjiData.prototype.write = function(bitBuffer2) {
let i;
for (i = 0; i < this.data.length; i++) {
let value = Utils$2.toSJIS(this.data[i]);
if (value >= 33088 && value <= 40956) {
value -= 33088;
} else if (value >= 57408 && value <= 60351) {
value -= 49472;
} else {
throw new Error(
"Invalid SJIS character: " + this.data[i] + "\nMake sure your charset is UTF-8"
);
}
value = (value >>> 8 & 255) * 192 + (value & 255);
bitBuffer2.put(value, 13);
}
};
var kanjiData = KanjiData;
var dijkstra = { exports: {} };
(function(module) {
var dijkstra2 = {
single_source_shortest_paths: function(graph, s, d) {
var predecessors = {};
var costs = {};
costs[s] = 0;
var open = dijkstra2.PriorityQueue.make();
open.push(s, 0);
var closest, u, v, cost_of_s_to_u, adjacent_nodes, cost_of_e, cost_of_s_to_u_plus_cost_of_e, cost_of_s_to_v, first_visit;
while (!open.empty()) {
closest = open.pop();
u = closest.value;
cost_of_s_to_u = closest.cost;
adjacent_nodes = graph[u] || {};
for (v in adjacent_nodes) {
if (adjacent_nodes.hasOwnProperty(v)) {
cost_of_e = adjacent_nodes[v];
cost_of_s_to_u_plus_cost_of_e = cost_of_s_to_u + cost_of_e;
cost_of_s_to_v = costs[v];
first_visit = typeof costs[v] === "undefined";
if (first_visit || cost_of_s_to_v > cost_of_s_to_u_plus_cost_of_e) {
costs[v] = cost_of_s_to_u_plus_cost_of_e;
open.push(v, cost_of_s_to_u_plus_cost_of_e);
predecessors[v] = u;
}
}
}
}
if (typeof d !== "undefined" && typeof costs[d] === "undefined") {
var msg = ["Could not find a path from ", s, " to ", d, "."].join("");
throw new Error(msg);
}
return predecessors;
},
extract_shortest_path_from_predecessor_list: function(predecessors, d) {
var nodes = [];
var u = d;
while (u) {
nodes.push(u);
predecessors[u];
u = predecessors[u];
}
nodes.reverse();
return nodes;
},
find_path: function(graph, s, d) {
var predecessors = dijkstra2.single_source_shortest_paths(graph, s, d);
return dijkstra2.extract_shortest_path_from_predecessor_list(
predecessors,
d
);
},
/**
* A very naive priority queue implementation.
*/
PriorityQueue: {
make: function(opts) {
var T = dijkstra2.PriorityQueue, t = {}, key;
opts = opts || {};
for (key in T) {
if (T.hasOwnProperty(key)) {
t[key] = T[key];
}
}
t.queue = [];
t.sorter = opts.sorter || T.default_sorter;
return t;
},
default_sorter: function(a, b) {
return a.cost - b.cost;
},
/**
* Add a new item to the queue and ensure the highest priority element
* is at the front of the queue.
*/
push: function(value, cost) {
var item = { value, cost };
this.queue.push(item);
this.queue.sort(this.sorter);
},
/**
* Return the highest priority element in the queue.
*/
pop: function() {
return this.queue.shift();
},
empty: function() {
return this.queue.length === 0;
}
}
};
{
module.exports = dijkstra2;
}
})(dijkstra);
var dijkstraExports = dijkstra.exports;
(function(exports) {
const Mode2 = mode;
const NumericData2 = numericData;
const AlphanumericData2 = alphanumericData;
const ByteData2 = byteData;
const KanjiData2 = kanjiData;
const Regex = regex;
const Utils2 = utils$1;
const dijkstra2 = dijkstraExports;
function getStringByteLength(str) {
return unescape(encodeURIComponent(str)).length;
}
function getSegments(regex2, mode2, str) {
const segments2 = [];
let result;
while ((result = regex2.exec(str)) !== null) {
segments2.push({
data: result[0],
index: result.index,
mode: mode2,
length: result[0].length
});
}
return segments2;
}
function getSegmentsFromString(dataStr) {
const numSegs = getSegments(Regex.NUMERIC, Mode2.NUMERIC, dataStr);
const alphaNumSegs = getSegments(Regex.ALPHANUMERIC, Mode2.ALPHANUMERIC, dataStr);
let byteSegs;
let kanjiSegs;
if (Utils2.isKanjiModeEnabled()) {
byteSegs = getSegments(Regex.BYTE, Mode2.BYTE, dataStr);
kanjiSegs = getSegments(Regex.KANJI, Mode2.KANJI, dataStr);
} else {
byteSegs = getSegments(Regex.BYTE_KANJI, Mode2.BYTE, dataStr);
kanjiSegs = [];
}
const segs = numSegs.concat(alphaNumSegs, byteSegs, kanjiSegs);
return segs.sort(function(s1, s2) {
return s1.index - s2.index;
}).map(function(obj) {
return {
data: obj.data,
mode: obj.mode,
length: obj.length
};
});
}
function getSegmentBitsLength(length, mode2) {
switch (mode2) {
case Mode2.NUMERIC:
return NumericData2.getBitsLength(length);
case Mode2.ALPHANUMERIC:
return AlphanumericData2.getBitsLength(length);
case Mode2.KANJI:
return KanjiData2.getBitsLength(length);
case Mode2.BYTE:
return ByteData2.getBitsLength(length);
}
}
function mergeSegments(segs) {
return segs.reduce(function(acc, curr) {
const prevSeg = acc.length - 1 >= 0 ? acc[acc.length - 1] : null;
if (prevSeg && prevSeg.mode === curr.mode) {
acc[acc.length - 1].data += curr.data;
return acc;
}
acc.push(curr);
return acc;
}, []);
}
function buildNodes(segs) {
const nodes = [];
for (let i = 0; i < segs.length; i++) {
const seg = segs[i];
switch (seg.mode) {
case Mode2.NUMERIC:
nodes.push([
seg,
{ data: seg.data, mode: Mode2.ALPHANUMERIC, length: seg.length },
{ data: seg.data, mode: Mode2.BYTE, length: seg.length }
]);
break;
case Mode2.ALPHANUMERIC:
nodes.push([
seg,
{ data: seg.data, mode: Mode2.BYTE, length: seg.length }
]);
break;
case Mode2.KANJI:
nodes.push([
seg,
{ data: seg.data, mode: Mode2.BYTE, length: getStringByteLength(seg.data) }
]);
break;
case Mode2.BYTE:
nodes.push([
{ data: seg.data, mode: Mode2.BYTE, length: getStringByteLength(seg.data) }
]);
}
}
return nodes;
}
function buildGraph(nodes, version2) {
const table = {};
const graph = { start: {} };
let prevNodeIds = ["start"];
for (let i = 0; i < nodes.length; i++) {
const nodeGroup = nodes[i];
const currentNodeIds = [];
for (let j = 0; j < nodeGroup.length; j++) {
const node = nodeGroup[j];
const key = "" + i + j;
currentNodeIds.push(key);
table[key] = { node, lastCount: 0 };
graph[key] = {};
for (let n = 0; n < prevNodeIds.length; n++) {
const prevNodeId = prevNodeIds[n];
if (table[prevNodeId] && table[prevNodeId].node.mode === node.mode) {
graph[prevNodeId][key] = getSegmentBitsLength(table[prevNodeId].lastCount + node.length, node.mode) - getSegmentBitsLength(table[prevNodeId].lastCount, node.mode);
table[prevNodeId].lastCount += node.length;
} else {
if (table[prevNodeId]) table[prevNodeId].lastCount = node.length;
graph[prevNodeId][key] = getSegmentBitsLength(node.length, node.mode) + 4 + Mode2.getCharCountIndicator(node.mode, version2);
}
}
}
prevNodeIds = currentNodeIds;
}
for (let n = 0; n < prevNodeIds.length; n++) {
graph[prevNodeIds[n]].end = 0;
}
return { map: graph, table };
}
function buildSingleSegment(data, modesHint) {
let mode2;
const bestMode = Mode2.getBestModeForData(data);
mode2 = Mode2.from(modesHint, bestMode);
if (mode2 !== Mode2.BYTE && mode2.bit < bestMode.bit) {
throw new Error('"' + data + '" cannot be encoded with mode ' + Mode2.toString(mode2) + ".\n Suggested mode is: " + Mode2.toString(bestMode));
}
if (mode2 === Mode2.KANJI && !Utils2.isKanjiModeEnabled()) {
mode2 = Mode2.BYTE;
}
switch (mode2) {
case Mode2.NUMERIC:
return new NumericData2(data);
case Mode2.ALPHANUMERIC:
return new AlphanumericData2(data);
case Mode2.KANJI:
return new KanjiData2(data);
case Mode2.BYTE:
return new ByteData2(data);
}
}
exports.fromArray = function fromArray(array) {
return array.reduce(function(acc, seg) {
if (typeof seg === "string") {
acc.push(buildSingleSegment(seg, null));
} else if (seg.data) {
acc.push(buildSingleSegment(seg.data, seg.mode));
}
return acc;
}, []);
};
exports.fromString = function fromString(data, version2) {
const segs = getSegmentsFromString(data, Utils2.isKanjiModeEnabled());
const nodes = buildNodes(segs);
const graph = buildGraph(nodes, version2);
const path = dijkstra2.find_path(graph.map, "start", "end");
const optimizedSegs = [];
for (let i = 1; i < path.length - 1; i++) {
optimizedSegs.push(graph.table[path[i]].node);
}
return exports.fromArray(mergeSegments(optimizedSegs));
};
exports.rawSplit = function rawSplit(data) {
return exports.fromArray(
getSegmentsFromString(data, Utils2.isKanjiModeEnabled())
);
};
})(segments);
const Utils$1 = utils$1;
const ECLevel = errorCorrectionLevel;
const BitBuffer = bitBuffer;
const BitMatrix = bitMatrix;
const AlignmentPattern = alignmentPattern;
const FinderPattern = finderPattern;
const MaskPattern = maskPattern;
const ECCode = errorCorrectionCode;
const ReedSolomonEncoder = reedSolomonEncoder;
const Version = version;
const FormatInfo = formatInfo;
const Mode = mode;
const Segments = segments;
function setupFinderPattern(matrix, version2) {
const size = matrix.size;
const pos = FinderPattern.getPositions(version2);
for (let i = 0; i < pos.length; i++) {
const row = pos[i][0];
const col = pos[i][1];
for (let r = -1; r <= 7; r++) {
if (row + r <= -1 || size <= row + r) continue;
for (let c = -1; c <= 7; c++) {
if (col + c <= -1 || size <= col + c) continue;
if (r >= 0 && r <= 6 && (c === 0 || c === 6) || c >= 0 && c <= 6 && (r === 0 || r === 6) || r >= 2 && r <= 4 && c >= 2 && c <= 4) {
matrix.set(row + r, col + c, true, true);
} else {
matrix.set(row + r, col + c, false, true);
}
}
}
}
}
function setupTimingPattern(matrix) {
const size = matrix.size;
for (let r = 8; r < size - 8; r++) {
const value = r % 2 === 0;
matrix.set(r, 6, value, true);
matrix.set(6, r, value, true);
}
}
function setupAlignmentPattern(matrix, version2) {
const pos = AlignmentPattern.getPositions(version2);
for (let i = 0; i < pos.length; i++) {
const row = pos[i][0];
const col = pos[i][1];
for (let r = -2; r <= 2; r++) {
for (let c = -2; c <= 2; c++) {
if (r === -2 || r === 2 || c === -2 || c === 2 || r === 0 && c === 0) {
matrix.set(row + r, col + c, true, true);
} else {
matrix.set(row + r, col + c, false, true);
}
}
}
}
}
function setupVersionInfo(matrix, version2) {
const size = matrix.size;
const bits = Version.getEncodedBits(version2);
let row, col, mod;
for (let i = 0; i < 18; i++) {
row = Math.floor(i / 3);
col = i % 3 + size - 8 - 3;
mod = (bits >> i & 1) === 1;
matrix.set(row, col, mod, true);
matrix.set(col, row, mod, true);
}
}
function setupFormatInfo(matrix, errorCorrectionLevel2, maskPattern2) {
const size = matrix.size;
const bits = FormatInfo.getEncodedBits(errorCorrectionLevel2, maskPattern2);
let i, mod;
for (i = 0; i < 15; i++) {
mod = (bits >> i & 1) === 1;
if (i < 6) {
matrix.set(i, 8, mod, true);
} else if (i < 8) {
matrix.set(i + 1, 8, mod, true);
} else {
matrix.set(size - 15 + i, 8, mod, true);
}
if (i < 8) {
matrix.set(8, size - i - 1, mod, true);
} else if (i < 9) {
matrix.set(8, 15 - i - 1 + 1, mod, true);
} else {
matrix.set(8, 15 - i - 1, mod, true);
}
}
matrix.set(size - 8, 8, 1, true);
}
function setupData(matrix, data) {
const size = matrix.size;
let inc = -1;
let row = size - 1;
let bitIndex = 7;
let byteIndex = 0;
for (let col = size - 1; col > 0; col -= 2) {
if (col === 6) col--;
while (true) {
for (let c = 0; c < 2; c++) {
if (!matrix.isReserved(row, col - c)) {
let dark = false;
if (byteIndex < data.length) {
dark = (data[byteIndex] >>> bitIndex & 1) === 1;
}
matrix.set(row, col - c, dark);
bitIndex--;
if (bitIndex === -1) {
byteIndex++;
bitIndex = 7;
}
}
}
row += inc;
if (row < 0 || size <= row) {
row -= inc;
inc = -inc;
break;
}
}
}
}
function createData(version2, errorCorrectionLevel2, segments2) {
const buffer = new BitBuffer();
segments2.forEach(function(data) {
buffer.put(data.mode.bit, 4);
buffer.put(data.getLength(), Mode.getCharCountIndicator(data.mode, version2));
data.write(buffer);
});
const totalCodewords = Utils$1.getSymbolTotalCodewords(version2);
const ecTotalCodewords = ECCode.getTotalCodewordsCount(version2, errorCorrectionLevel2);
const dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8;
if (buffer.getLengthInBits() + 4 <= dataTotalCodewordsBits) {
buffer.put(0, 4);
}
while (buffer.getLengthInBits() % 8 !== 0) {
buffer.putBit(0);
}
const remainingByte = (dataTotalCodewordsBits - buffer.getLengthInBits()) / 8;
for (let i = 0; i < remainingByte; i++) {
buffer.put(i % 2 ? 17 : 236, 8);
}
return createCodewords(buffer, version2, errorCorrectionLevel2);
}
function createCodewords(bitBuffer2, version2, errorCorrectionLevel2) {
const totalCodewords = Utils$1.getSymbolTotalCodewords(version2);
const ecTotalCodewords = ECCode.getTotalCodewordsCount(version2, errorCorrectionLevel2);
const dataTotalCodewords = totalCodewords - ecTotalCodewords;
const ecTotalBlocks = ECCode.getBlocksCount(version2, errorCorrectionLevel2);
const blocksInGroup2 = totalCodewords % ecTotalBlocks;
const blocksInGroup1 = ecTotalBlocks - blocksInGroup2;
const totalCodewordsInGroup1 = Math.floor(totalCodewords / ecTotalBlocks);
const dataCodewordsInGroup1 = Math.floor(dataTotalCodewords