tpa_web_component
Version:
TPA Web Components Library
1,762 lines (1,494 loc) • 2.08 MB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory(require("vue"));
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["tpa_web_component"] = factory(require("vue"));
else
root["tpa_web_component"] = factory(root["Vue"]);
})((typeof self !== 'undefined' ? self : this), function(__WEBPACK_EXTERNAL_MODULE__9274__) {
return /******/ (function() { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ 1:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
__webpack_require__(9577);
const Mode = __webpack_require__(1125);
function ByteData(data) {
this.mode = Mode.BYTE;
if (typeof data === 'string') {
this.data = new TextEncoder().encode(data);
} else {
this.data = new Uint8Array(data);
}
}
ByteData.getBitsLength = function getBitsLength(length) {
return length * 8;
};
ByteData.prototype.getLength = function getLength() {
return this.data.length;
};
ByteData.prototype.getBitsLength = function getBitsLength() {
return ByteData.getBitsLength(this.data.length);
};
ByteData.prototype.write = function (bitBuffer) {
for (let i = 0, l = this.data.length; i < l; i++) {
bitBuffer.put(this.data[i], 8);
}
};
module.exports = ByteData;
/***/ }),
/***/ 34:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var isCallable = __webpack_require__(4901);
module.exports = function (it) {
return typeof it == 'object' ? it !== null : isCallable(it);
};
/***/ }),
/***/ 81:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var call = __webpack_require__(9565);
var aCallable = __webpack_require__(9306);
var anObject = __webpack_require__(8551);
var tryToString = __webpack_require__(6823);
var getIteratorMethod = __webpack_require__(851);
var $TypeError = TypeError;
module.exports = function (argument, usingIterator) {
var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));
throw new $TypeError(tryToString(argument) + ' is not iterable');
};
/***/ }),
/***/ 116:
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(6518);
var call = __webpack_require__(9565);
var iterate = __webpack_require__(2652);
var aCallable = __webpack_require__(9306);
var anObject = __webpack_require__(8551);
var getIteratorDirect = __webpack_require__(1767);
var iteratorClose = __webpack_require__(9539);
var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(4549);
var findWithoutClosingOnEarlyError = iteratorHelperWithoutClosingOnEarlyError('find', TypeError);
// `Iterator.prototype.find` method
// https://tc39.es/ecma262/#sec-iterator.prototype.find
$({ target: 'Iterator', proto: true, real: true, forced: findWithoutClosingOnEarlyError }, {
find: function find(predicate) {
anObject(this);
try {
aCallable(predicate);
} catch (error) {
iteratorClose(this, 'throw', error);
}
if (findWithoutClosingOnEarlyError) return call(findWithoutClosingOnEarlyError, this, predicate);
var record = getIteratorDirect(this);
var counter = 0;
return iterate(record, function (value, stop) {
if (predicate(value, counter++)) return stop(value);
}, { IS_RECORD: true, INTERRUPTED: true }).result;
}
});
/***/ }),
/***/ 283:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var uncurryThis = __webpack_require__(9504);
var fails = __webpack_require__(9039);
var isCallable = __webpack_require__(4901);
var hasOwn = __webpack_require__(9297);
var DESCRIPTORS = __webpack_require__(3724);
var CONFIGURABLE_FUNCTION_NAME = (__webpack_require__(350).CONFIGURABLE);
var inspectSource = __webpack_require__(3706);
var InternalStateModule = __webpack_require__(1181);
var enforceInternalState = InternalStateModule.enforce;
var getInternalState = InternalStateModule.get;
var $String = String;
// eslint-disable-next-line es/no-object-defineproperty -- safe
var defineProperty = Object.defineProperty;
var stringSlice = uncurryThis(''.slice);
var replace = uncurryThis(''.replace);
var join = uncurryThis([].join);
var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
});
var TEMPLATE = String(String).split('String');
var makeBuiltIn = module.exports = function (value, name, options) {
if (stringSlice($String(name), 0, 7) === 'Symbol(') {
name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
}
if (options && options.getter) name = 'get ' + name;
if (options && options.setter) name = 'set ' + name;
if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });
else value.name = name;
}
if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
defineProperty(value, 'length', { value: options.arity });
}
try {
if (options && hasOwn(options, 'constructor') && options.constructor) {
if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });
// in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
} else if (value.prototype) value.prototype = undefined;
} catch (error) { /* empty */ }
var state = enforceInternalState(value);
if (!hasOwn(state, 'source')) {
state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
} return value;
};
// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
// eslint-disable-next-line no-extend-native -- required
Function.prototype.toString = makeBuiltIn(function toString() {
return isCallable(this) && getInternalState(this).source || inspectSource(this);
}, 'toString');
/***/ }),
/***/ 350:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var DESCRIPTORS = __webpack_require__(3724);
var hasOwn = __webpack_require__(9297);
var FunctionPrototype = Function.prototype;
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
var EXISTS = hasOwn(FunctionPrototype, 'name');
// additional protection from minified / mangled / dropped function names
var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
module.exports = {
EXISTS: EXISTS,
PROPER: PROPER,
CONFIGURABLE: CONFIGURABLE
};
/***/ }),
/***/ 397:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var getBuiltIn = __webpack_require__(7751);
module.exports = getBuiltIn('document', 'documentElement');
/***/ }),
/***/ 421:
/***/ (function(module) {
"use strict";
module.exports = {};
/***/ }),
/***/ 507:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var call = __webpack_require__(9565);
module.exports = function (record, fn, ITERATOR_INSTEAD_OF_RECORD) {
var iterator = ITERATOR_INSTEAD_OF_RECORD ? record : record.iterator;
var next = record.next;
var step, result;
while (!(step = call(next, iterator)).done) {
result = fn(step.value);
if (result !== undefined) return result;
}
};
/***/ }),
/***/ 531:
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(6518);
var call = __webpack_require__(9565);
var aCallable = __webpack_require__(9306);
var anObject = __webpack_require__(8551);
var getIteratorDirect = __webpack_require__(1767);
var getIteratorFlattenable = __webpack_require__(8646);
var createIteratorProxy = __webpack_require__(9462);
var iteratorClose = __webpack_require__(9539);
var IS_PURE = __webpack_require__(6395);
var iteratorHelperThrowsOnInvalidIterator = __webpack_require__(684);
var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(4549);
var FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE
&& !iteratorHelperThrowsOnInvalidIterator('flatMap', function () { /* empty */ });
var flatMapWithoutClosingOnEarlyError = !IS_PURE && !FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR
&& iteratorHelperWithoutClosingOnEarlyError('flatMap', TypeError);
var FORCED = IS_PURE || FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR || flatMapWithoutClosingOnEarlyError;
var IteratorProxy = createIteratorProxy(function () {
var iterator = this.iterator;
var mapper = this.mapper;
var result, inner;
while (true) {
if (inner = this.inner) try {
result = anObject(call(inner.next, inner.iterator));
if (!result.done) return result.value;
this.inner = null;
} catch (error) { iteratorClose(iterator, 'throw', error); }
result = anObject(call(this.next, iterator));
if (this.done = !!result.done) return;
try {
this.inner = getIteratorFlattenable(mapper(result.value, this.counter++), false);
} catch (error) { iteratorClose(iterator, 'throw', error); }
}
});
// `Iterator.prototype.flatMap` method
// https://tc39.es/ecma262/#sec-iterator.prototype.flatmap
$({ target: 'Iterator', proto: true, real: true, forced: FORCED }, {
flatMap: function flatMap(mapper) {
anObject(this);
try {
aCallable(mapper);
} catch (error) {
iteratorClose(this, 'throw', error);
}
if (flatMapWithoutClosingOnEarlyError) return call(flatMapWithoutClosingOnEarlyError, this, mapper);
return new IteratorProxy(getIteratorDirect(this), {
mapper: mapper,
inner: null
});
}
});
/***/ }),
/***/ 616:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var fails = __webpack_require__(9039);
module.exports = !fails(function () {
// eslint-disable-next-line es/no-function-prototype-bind -- safe
var test = (function () { /* empty */ }).bind();
// eslint-disable-next-line no-prototype-builtins -- safe
return typeof test != 'function' || test.hasOwnProperty('prototype');
});
/***/ }),
/***/ 655:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var classof = __webpack_require__(6955);
var $String = String;
module.exports = function (argument) {
if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
return $String(argument);
};
/***/ }),
/***/ 679:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var isPrototypeOf = __webpack_require__(1625);
var $TypeError = TypeError;
module.exports = function (it, Prototype) {
if (isPrototypeOf(Prototype, it)) return it;
throw new $TypeError('Incorrect invocation');
};
/***/ }),
/***/ 684:
/***/ (function(module) {
"use strict";
// Should throw an error on invalid iterator
// https://issues.chromium.org/issues/336839115
module.exports = function (methodName, argument) {
// eslint-disable-next-line es/no-iterator -- required for testing
var method = typeof Iterator == 'function' && Iterator.prototype[methodName];
if (method) try {
method.call({ next: null }, argument).next();
} catch (error) {
return true;
}
};
/***/ }),
/***/ 741:
/***/ (function(module) {
"use strict";
var ceil = Math.ceil;
var floor = Math.floor;
// `Math.trunc` method
// https://tc39.es/ecma262/#sec-math.trunc
// eslint-disable-next-line es/no-math-trunc -- safe
module.exports = Math.trunc || function trunc(x) {
var n = +x;
return (n > 0 ? floor : ceil)(n);
};
/***/ }),
/***/ 757:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var getBuiltIn = __webpack_require__(7751);
var isCallable = __webpack_require__(4901);
var isPrototypeOf = __webpack_require__(1625);
var USE_SYMBOL_AS_UID = __webpack_require__(7040);
var $Object = Object;
module.exports = USE_SYMBOL_AS_UID ? function (it) {
return typeof it == 'symbol';
} : function (it) {
var $Symbol = getBuiltIn('Symbol');
return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
};
/***/ }),
/***/ 851:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var classof = __webpack_require__(6955);
var getMethod = __webpack_require__(5966);
var isNullOrUndefined = __webpack_require__(4117);
var Iterators = __webpack_require__(6269);
var wellKnownSymbol = __webpack_require__(8227);
var ITERATOR = wellKnownSymbol('iterator');
module.exports = function (it) {
if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
|| getMethod(it, '@@iterator')
|| Iterators[classof(it)];
};
/***/ }),
/***/ 1072:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var internalObjectKeys = __webpack_require__(1828);
var enumBugKeys = __webpack_require__(8727);
// `Object.keys` method
// https://tc39.es/ecma262/#sec-object.keys
// eslint-disable-next-line es/no-object-keys -- safe
module.exports = Object.keys || function keys(O) {
return internalObjectKeys(O, enumBugKeys);
};
/***/ }),
/***/ 1108:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var classof = __webpack_require__(6955);
module.exports = function (it) {
var klass = classof(it);
return klass === 'BigInt64Array' || klass === 'BigUint64Array';
};
/***/ }),
/***/ 1125:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
const VersionCheck = __webpack_require__(6257);
const Regex = __webpack_require__(3143);
/**
* Numeric mode encodes data from the decimal digit set (0 - 9)
* (byte values 30HEX to 39HEX).
* Normally, 3 data characters are represented by 10 bits.
*
* @type {Object}
*/
exports.NUMERIC = {
id: 'Numeric',
bit: 1 << 0,
ccBits: [10, 12, 14]
};
/**
* Alphanumeric mode encodes data from a set of 45 characters,
* i.e. 10 numeric digits (0 - 9),
* 26 alphabetic characters (A - Z),
* and 9 symbols (SP, $, %, *, +, -, ., /, :).
* Normally, two input characters are represented by 11 bits.
*
* @type {Object}
*/
exports.ALPHANUMERIC = {
id: 'Alphanumeric',
bit: 1 << 1,
ccBits: [9, 11, 13]
};
/**
* In byte mode, data is encoded at 8 bits per character.
*
* @type {Object}
*/
exports.BYTE = {
id: 'Byte',
bit: 1 << 2,
ccBits: [8, 16, 16]
};
/**
* The Kanji mode efficiently encodes Kanji characters in accordance with
* the Shift JIS system based on JIS X 0208.
* The Shift JIS values are shifted from the JIS X 0208 values.
* JIS X 0208 gives details of the shift coded representation.
* Each two-byte character value is compacted to a 13-bit binary codeword.
*
* @type {Object}
*/
exports.KANJI = {
id: 'Kanji',
bit: 1 << 3,
ccBits: [8, 10, 12]
};
/**
* Mixed mode will contain a sequences of data in a combination of any of
* the modes described above
*
* @type {Object}
*/
exports.MIXED = {
bit: -1
};
/**
* Returns the number of bits needed to store the data length
* according to QR Code specifications.
*
* @param {Mode} mode Data mode
* @param {Number} version QR Code version
* @return {Number} Number of bits
*/
exports.getCharCountIndicator = function getCharCountIndicator(mode, version) {
if (!mode.ccBits) throw new Error('Invalid mode: ' + mode);
if (!VersionCheck.isValid(version)) {
throw new Error('Invalid version: ' + version);
}
if (version >= 1 && version < 10) return mode.ccBits[0];else if (version < 27) return mode.ccBits[1];
return mode.ccBits[2];
};
/**
* Returns the most efficient mode to store the specified data
*
* @param {String} dataStr Input data string
* @return {Mode} Best mode
*/
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;
};
/**
* Return mode name as string
*
* @param {Mode} mode Mode object
* @returns {String} Mode name
*/
exports.toString = function toString(mode) {
if (mode && mode.id) return mode.id;
throw new Error('Invalid mode');
};
/**
* Check if input param is a valid mode object
*
* @param {Mode} mode Mode object
* @returns {Boolean} True if valid mode, false otherwise
*/
exports.isValid = function isValid(mode) {
return mode && mode.bit && mode.ccBits;
};
/**
* Get mode object from its name
*
* @param {String} string Mode name
* @returns {Mode} Mode object
*/
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);
}
}
/**
* Returns mode from a value.
* If value is not a valid mode, returns defaultValue
*
* @param {Mode|String} value Encoding mode
* @param {Mode} defaultValue Fallback value
* @return {Mode} Encoding mode
*/
exports.from = function from(value, defaultValue) {
if (exports.isValid(value)) {
return value;
}
try {
return fromString(value);
} catch (e) {
return defaultValue;
}
};
/***/ }),
/***/ 1148:
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(6518);
var call = __webpack_require__(9565);
var iterate = __webpack_require__(2652);
var aCallable = __webpack_require__(9306);
var anObject = __webpack_require__(8551);
var getIteratorDirect = __webpack_require__(1767);
var iteratorClose = __webpack_require__(9539);
var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(4549);
var everyWithoutClosingOnEarlyError = iteratorHelperWithoutClosingOnEarlyError('every', TypeError);
// `Iterator.prototype.every` method
// https://tc39.es/ecma262/#sec-iterator.prototype.every
$({ target: 'Iterator', proto: true, real: true, forced: everyWithoutClosingOnEarlyError }, {
every: function every(predicate) {
anObject(this);
try {
aCallable(predicate);
} catch (error) {
iteratorClose(this, 'throw', error);
}
if (everyWithoutClosingOnEarlyError) return call(everyWithoutClosingOnEarlyError, this, predicate);
var record = getIteratorDirect(this);
var counter = 0;
return !iterate(record, function (value, stop) {
if (!predicate(value, counter++)) return stop();
}, { IS_RECORD: true, INTERRUPTED: true }).stopped;
}
});
/***/ }),
/***/ 1181:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var NATIVE_WEAK_MAP = __webpack_require__(8622);
var globalThis = __webpack_require__(4576);
var isObject = __webpack_require__(34);
var createNonEnumerableProperty = __webpack_require__(6699);
var hasOwn = __webpack_require__(9297);
var shared = __webpack_require__(7629);
var sharedKey = __webpack_require__(6119);
var hiddenKeys = __webpack_require__(421);
var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
var TypeError = globalThis.TypeError;
var WeakMap = globalThis.WeakMap;
var set, get, has;
var enforce = function (it) {
return has(it) ? get(it) : set(it, {});
};
var getterFor = function (TYPE) {
return function (it) {
var state;
if (!isObject(it) || (state = get(it)).type !== TYPE) {
throw new TypeError('Incompatible receiver, ' + TYPE + ' required');
} return state;
};
};
if (NATIVE_WEAK_MAP || shared.state) {
var store = shared.state || (shared.state = new WeakMap());
/* eslint-disable no-self-assign -- prototype methods protection */
store.get = store.get;
store.has = store.has;
store.set = store.set;
/* eslint-enable no-self-assign -- prototype methods protection */
set = function (it, metadata) {
if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
metadata.facade = it;
store.set(it, metadata);
return metadata;
};
get = function (it) {
return store.get(it) || {};
};
has = function (it) {
return store.has(it);
};
} else {
var STATE = sharedKey('state');
hiddenKeys[STATE] = true;
set = function (it, metadata) {
if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
metadata.facade = it;
createNonEnumerableProperty(it, STATE, metadata);
return metadata;
};
get = function (it) {
return hasOwn(it, STATE) ? it[STATE] : {};
};
has = function (it) {
return hasOwn(it, STATE);
};
}
module.exports = {
set: set,
get: get,
has: has,
enforce: enforce,
getterFor: getterFor
};
/***/ }),
/***/ 1286:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
const Utils = __webpack_require__(2681);
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.getBCHDigit(G15);
/**
* Returns format information with relative error correction bits
*
* The format information is a 15-bit sequence containing 5 data bits,
* with 10 error correction bits calculated using the (15, 5) BCH code.
*
* @param {Number} errorCorrectionLevel Error correction level
* @param {Number} mask Mask pattern
* @return {Number} Encoded format information bits
*/
exports.getEncodedBits = function getEncodedBits(errorCorrectionLevel, mask) {
const data = errorCorrectionLevel.bit << 3 | mask;
let d = data << 10;
while (Utils.getBCHDigit(d) - G15_BCH >= 0) {
d ^= G15 << Utils.getBCHDigit(d) - G15_BCH;
}
// xor final data with mask pattern in order to ensure that
// no combination of Error Correction Level and data mask pattern
// will result in an all-zero data string
return (data << 10 | d) ^ G15_MASK;
};
/***/ }),
/***/ 1291:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var trunc = __webpack_require__(741);
// `ToIntegerOrInfinity` abstract operation
// https://tc39.es/ecma262/#sec-tointegerorinfinity
module.exports = function (argument) {
var number = +argument;
// eslint-disable-next-line no-self-compare -- NaN check
return number !== number || number === 0 ? 0 : trunc(number);
};
/***/ }),
/***/ 1346:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
const canPromise = __webpack_require__(9324);
const QRCode = __webpack_require__(2044);
const CanvasRenderer = __webpack_require__(4014);
const SvgRenderer = __webpack_require__(4327);
function renderCanvas(renderFunc, canvas, text, opts, cb) {
const args = [].slice.call(arguments, 1);
const argsNum = args.length;
const isLastArgCb = typeof args[argsNum - 1] === 'function';
if (!isLastArgCb && !canPromise()) {
throw new Error('Callback required as last argument');
}
if (isLastArgCb) {
if (argsNum < 2) {
throw new Error('Too few arguments provided');
}
if (argsNum === 2) {
cb = text;
text = canvas;
canvas = opts = undefined;
} else if (argsNum === 3) {
if (canvas.getContext && typeof cb === 'undefined') {
cb = opts;
opts = undefined;
} else {
cb = opts;
opts = text;
text = canvas;
canvas = undefined;
}
}
} else {
if (argsNum < 1) {
throw new Error('Too few arguments provided');
}
if (argsNum === 1) {
text = canvas;
canvas = opts = undefined;
} else if (argsNum === 2 && !canvas.getContext) {
opts = text;
text = canvas;
canvas = undefined;
}
return new Promise(function (resolve, reject) {
try {
const data = QRCode.create(text, opts);
resolve(renderFunc(data, canvas, opts));
} catch (e) {
reject(e);
}
});
}
try {
const data = QRCode.create(text, opts);
cb(null, renderFunc(data, canvas, opts));
} catch (e) {
cb(e);
}
}
exports.create = QRCode.create;
exports.toCanvas = renderCanvas.bind(null, CanvasRenderer.render);
exports.toDataURL = renderCanvas.bind(null, CanvasRenderer.renderToDataURL);
// only svg for now.
exports.toString = renderCanvas.bind(null, function (data, _, opts) {
return SvgRenderer.render(data, opts);
});
/***/ }),
/***/ 1385:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var iteratorClose = __webpack_require__(9539);
module.exports = function (iters, kind, value) {
for (var i = iters.length - 1; i >= 0; i--) {
if (iters[i] === undefined) continue;
try {
value = iteratorClose(iters[i].iterator, kind, value);
} catch (error) {
kind = 'throw';
value = error;
}
}
if (kind === 'throw') throw value;
return value;
};
/***/ }),
/***/ 1449:
/***/ (function(__unused_webpack_module, exports) {
/**
* Data mask pattern reference
* @type {Object}
*/
exports.Patterns = {
PATTERN000: 0,
PATTERN001: 1,
PATTERN010: 2,
PATTERN011: 3,
PATTERN100: 4,
PATTERN101: 5,
PATTERN110: 6,
PATTERN111: 7
};
/**
* Weighted penalty scores for the undesirable features
* @type {Object}
*/
const PenaltyScores = {
N1: 3,
N2: 3,
N3: 40,
N4: 10
};
/**
* Check if mask pattern value is valid
*
* @param {Number} mask Mask pattern
* @return {Boolean} true if valid, false otherwise
*/
exports.isValid = function isValid(mask) {
return mask != null && mask !== '' && !isNaN(mask) && mask >= 0 && mask <= 7;
};
/**
* Returns mask pattern from a value.
* If value is not valid, returns undefined
*
* @param {Number|String} value Mask pattern value
* @return {Number} Valid mask pattern or undefined
*/
exports.from = function from(value) {
return exports.isValid(value) ? parseInt(value, 10) : undefined;
};
/**
* Find adjacent modules in row/column with the same color
* and assign a penalty value.
*
* Points: N1 + i
* i is the amount by which the number of adjacent modules of the same color exceeds 5
*/
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;
};
/**
* Find 2x2 blocks with the same color and assign a penalty value
*
* Points: N2 * (m - 1) * (n - 1)
*/
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;
};
/**
* Find 1:1:3:1:1 ratio (dark:light:dark:light:dark) pattern in row/column,
* preceded or followed by light area 4 modules wide
*
* Points: N3 * number of pattern found
*/
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 & 0x7FF | data.get(row, col);
if (col >= 10 && (bitsCol === 0x5D0 || bitsCol === 0x05D)) points++;
bitsRow = bitsRow << 1 & 0x7FF | data.get(col, row);
if (col >= 10 && (bitsRow === 0x5D0 || bitsRow === 0x05D)) points++;
}
}
return points * PenaltyScores.N3;
};
/**
* Calculate proportion of dark modules in entire symbol
*
* Points: N4 * k
*
* k is the rating of the deviation of the proportion of dark modules
* in the symbol from 50% in steps of 5%
*/
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;
};
/**
* Return mask value at given position
*
* @param {Number} maskPattern Pattern reference value
* @param {Number} i Row
* @param {Number} j Column
* @return {Boolean} Mask value
*/
function getMaskAt(maskPattern, i, j) {
switch (maskPattern) {
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:' + maskPattern);
}
}
/**
* Apply a mask pattern to a BitMatrix
*
* @param {Number} pattern Pattern reference number
* @param {BitMatrix} data BitMatrix data
*/
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));
}
}
};
/**
* Returns the best mask pattern for data
*
* @param {BitMatrix} data
* @return {Number} Mask pattern reference number
*/
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);
// Calculate penalty
const penalty = exports.getPenaltyN1(data) + exports.getPenaltyN2(data) + exports.getPenaltyN3(data) + exports.getPenaltyN4(data);
// Undo previously applied mask
exports.applyMask(p, data);
if (penalty < lowerPenalty) {
lowerPenalty = penalty;
bestPattern = p;
}
}
return bestPattern;
};
/***/ }),
/***/ 1564:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
__webpack_require__(4114);
__webpack_require__(8111);
__webpack_require__(1701);
__webpack_require__(8237);
const Mode = __webpack_require__(1125);
const NumericData = __webpack_require__(3948);
const AlphanumericData = __webpack_require__(6322);
const ByteData = __webpack_require__(1);
const KanjiData = __webpack_require__(8264);
const Regex = __webpack_require__(3143);
const Utils = __webpack_require__(2681);
const dijkstra = __webpack_require__(4475);
/**
* Returns UTF8 byte length
*
* @param {String} str Input string
* @return {Number} Number of byte
*/
function getStringByteLength(str) {
return unescape(encodeURIComponent(str)).length;
}
/**
* Get a list of segments of the specified mode
* from a string
*
* @param {Mode} mode Segment mode
* @param {String} str String to process
* @return {Array} Array of object with segments data
*/
function getSegments(regex, mode, str) {
const segments = [];
let result;
while ((result = regex.exec(str)) !== null) {
segments.push({
data: result[0],
index: result.index,
mode: mode,
length: result[0].length
});
}
return segments;
}
/**
* Extracts a series of segments with the appropriate
* modes from a string
*
* @param {String} dataStr Input string
* @return {Array} Array of object with segments data
*/
function getSegmentsFromString(dataStr) {
const numSegs = getSegments(Regex.NUMERIC, Mode.NUMERIC, dataStr);
const alphaNumSegs = getSegments(Regex.ALPHANUMERIC, Mode.ALPHANUMERIC, dataStr);
let byteSegs;
let kanjiSegs;
if (Utils.isKanjiModeEnabled()) {
byteSegs = getSegments(Regex.BYTE, Mode.BYTE, dataStr);
kanjiSegs = getSegments(Regex.KANJI, Mode.KANJI, dataStr);
} else {
byteSegs = getSegments(Regex.BYTE_KANJI, Mode.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
};
});
}
/**
* Returns how many bits are needed to encode a string of
* specified length with the specified mode
*
* @param {Number} length String length
* @param {Mode} mode Segment mode
* @return {Number} Bit length
*/
function getSegmentBitsLength(length, mode) {
switch (mode) {
case Mode.NUMERIC:
return NumericData.getBitsLength(length);
case Mode.ALPHANUMERIC:
return AlphanumericData.getBitsLength(length);
case Mode.KANJI:
return KanjiData.getBitsLength(length);
case Mode.BYTE:
return ByteData.getBitsLength(length);
}
}
/**
* Merges adjacent segments which have the same mode
*
* @param {Array} segs Array of object with segments data
* @return {Array} Array of object with segments data
*/
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;
}, []);
}
/**
* Generates a list of all possible nodes combination which
* will be used to build a segments graph.
*
* Nodes are divided by groups. Each group will contain a list of all the modes
* in which is possible to encode the given text.
*
* For example the text '12345' can be encoded as Numeric, Alphanumeric or Byte.
* The group for '12345' will contain then 3 objects, one for each
* possible encoding mode.
*
* Each node represents a possible segment.
*
* @param {Array} segs Array of object with segments data
* @return {Array} Array of object with segments data
*/
function buildNodes(segs) {
const nodes = [];
for (let i = 0; i < segs.length; i++) {
const seg = segs[i];
switch (seg.mode) {
case Mode.NUMERIC:
nodes.push([seg, {
data: seg.data,
mode: Mode.ALPHANUMERIC,
length: seg.length
}, {
data: seg.data,
mode: Mode.BYTE,
length: seg.length
}]);
break;
case Mode.ALPHANUMERIC:
nodes.push([seg, {
data: seg.data,
mode: Mode.BYTE,
length: seg.length
}]);
break;
case Mode.KANJI:
nodes.push([seg, {
data: seg.data,
mode: Mode.BYTE,
length: getStringByteLength(seg.data)
}]);
break;
case Mode.BYTE:
nodes.push([{
data: seg.data,
mode: Mode.BYTE,
length: getStringByteLength(seg.data)
}]);
}
}
return nodes;
}
/**
* Builds a graph from a list of nodes.
* All segments in each node group will be connected with all the segments of
* the next group and so on.
*
* At each connection will be assigned a weight depending on the
* segment's byte length.
*
* @param {Array} nodes Array of object with segments data
* @param {Number} version QR Code version
* @return {Object} Graph of all possible segments
*/
function buildGraph(nodes, version) {
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: 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 + Mode.getCharCountIndicator(node.mode, version); // switch cost
}
}
}
prevNodeIds = currentNodeIds;
}
for (let n = 0; n < prevNodeIds.length; n++) {
graph[prevNodeIds[n]].end = 0;
}
return {
map: graph,
table: table
};
}
/**
* Builds a segment from a specified data and mode.
* If a mode is not specified, the more suitable will be used.
*
* @param {String} data Input data
* @param {Mode | String} modesHint Data mode
* @return {Segment} Segment
*/
function buildSingleSegment(data, modesHint) {
let mode;
const bestMode = Mode.getBestModeForData(data);
mode = Mode.from(modesHint, bestMode);
// Make sure data can be encoded
if (mode !== Mode.BYTE && mode.bit < bestMode.bit) {
throw new Error('"' + data + '"' + ' cannot be encoded with mode ' + Mode.toString(mode) + '.\n Suggested mode is: ' + Mode.toString(bestMode));
}
// Use Mode.BYTE if Kanji support is disabled
if (mode === Mode.KANJI && !Utils.isKanjiModeEnabled()) {
mode = Mode.BYTE;
}
switch (mode) {
case Mode.NUMERIC:
return new NumericData(data);
case Mode.ALPHANUMERIC:
return new AlphanumericData(data);
case Mode.KANJI:
return new KanjiData(data);
case Mode.BYTE:
return new ByteData(data);
}
}
/**
* Builds a list of segments from an array.
* Array can contain Strings or Objects with segment's info.
*
* For each item which is a string, will be generated a segment with the given
* string and the more appropriate encoding mode.
*
* For each item which is an object, will be generated a segment with the given
* data and mode.
* Objects must contain at least the property "data".
* If property "mode" is not present, the more suitable mode will be used.
*
* @param {Array} array Array of objects with segments data
* @return {Array} Array of Segments
*/
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;
}, []);
};
/**
* Builds an optimized sequence of segments from a string,
* which will produce the shortest possible bitstream.
*
* @param {String} data Input string
* @param {Number} version QR Code version
* @return {Array} Array of segments
*/
exports.fromString = function fromString(data, version) {
const segs = getSegmentsFromString(data, Utils.isKanjiModeEnabled());
const nodes = buildNodes(segs);
const graph = buildGraph(nodes, version);
const path = dijkstra.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));
};
/**
* Splits a string in various segments with the modes which
* best represent their content.
* The produced segments are far from being optimized.
* The output of this function is only used to estimate a QR Code version
* which may contain the data.
*
* @param {string} data Input string
* @return {Array} Array of segments
*/
exports.rawSplit = function rawSplit(data) {
return exports.fromArray(getSegmentsFromString(data, Utils.isKanjiModeEnabled()));
};
/***/ }),
/***/ 1625:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var uncurryThis = __webpack_require__(9504);
module.exports = uncurryThis({}.isPrototypeOf);
/***/ }),
/***/ 1698:
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(6518);
var union = __webpack_require__(4204);
var setMethodGetKeysBeforeCloning = __webpack_require__(9835);
var setMethodAcceptSetLike = __webpack_require__(4916);
var FORCED = !setMethodAcceptSetLike('union') || !setMethodGetKeysBeforeCloning('union');
// `Set.prototype.union` method
// https://tc39.es/ecma262/#sec-set.prototype.union
$({ target: 'Set', proto: true, real: true, forced: FORCED }, {
union: union
});
/***/ }),
/***/ 1701:
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(6518);
var call = __webpack_require__(9565);
var aCallable = __webpack_require__(9306);
var anObject = __webpack_require__(8551);
var getIteratorDirect = __webpack_require__(1767);
var createIteratorProxy = __webpack_require__(9462);
var callWithSafeIterationClosing = __webpack_require__(6319);
var iteratorClose = __webpack_require__(9539);
var iteratorHelperThrowsOnInvalidIterator = __webpack_require__(684);
var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(4549);
var IS_PURE = __webpack_require__(6395);
var MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE && !iteratorHelperThrowsOnInvalidIterator('map', function () { /* empty */ });
var mapWithoutClosingOnEarlyError = !IS_PURE && !MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR
&& iteratorHelperWithoutClosingOnEarlyError('map', TypeError);
var FORCED = IS_PURE || MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR || mapWithoutClosingOnEarlyError;
var IteratorProxy = createIteratorProxy(function () {
var iterator = this.iterator;
var result = anObject(call(this.next, iterator));
var done = this.done = !!result.done;
if (!done) return callWithSafeIterationClosing(iterator, this.mapper, [result.value, this.counter++], true);
});
// `Iterator.prototype.map` method
// https://tc39.es/ecma262/#sec-iterator.prototype.map
$({ target: 'Iterator', proto: true, real: true, forced: FORCED }, {
map: function map(mapper) {
anObject(this);
try {
aCallable(mapper);
} catch (error) {
iteratorClose(this, 'throw', error);
}
if (mapWithoutClosingOnEarlyError) return call(mapWithoutClosingOnEarlyError, this, mapper);
return new IteratorProxy(getIteratorDirect(this), {
mapper: mapper
});
}
});
/***/ }),
/***/ 1767:
/***/ (function(module) {
"use strict";
// `GetIteratorDirect(obj)` abstract operation
// https://tc39.es/proposal-iterator-helpers/#sec-getiteratordirect
module.exports = function (obj) {
return {
iterator: obj,
next: obj.next,
done: false
};
};
/***/ }),
/***/ 1806:
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(6518);
var anObject = __webpack_require__(8551);
var iterate = __webpack_require__(2652);
var getIteratorDirect = __webpack_require__(1767);
var push = [].push;
// `Iterator.prototype.toArray` method
// https://tc39.es/ecma262/#sec-iterator.prototype.toarray
$({ target: 'Iterator', proto: true, real: true }, {
toArray: function toArray() {
var result = [];
iterate(getIteratorDirect(anObject(this)), push, { that: result, IS_RECORD: true });
return result;
}
});
/***/ }),
/***/ 1828:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var uncurryThis = __webpack_require__(9504);
var hasOwn = __webpack_require__(9297);
var toIndexedObject = __webpack_require__(5397);
var indexOf = (__webpack_require__(9617).indexOf);
var hiddenKeys = __webpack_require__(421);
var push = uncurryThis([].push);
module.exports = function (object, names) {
var O = toIndexedObject(object);
var i = 0;
var result = [];
var key;
for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
// Don't enum bug & hidden keys
while (names.length > i) if (hasOwn(O, key = names[i++])) {
~indexOf(result, key) || push(result, key);
}
return result;
};
/***/ }),
/***/ 2044:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
__webpack_require__(8111);
__webpack_require__(7588);
__webpack_require__(9577);
const Utils = __webpack_require__(2681);
const ECLevel = __webpack_require__(8984);
const BitBuffer = __webpack_require__(4766);
const BitMatrix = __webpack_require__(2685);
const AlignmentPattern = __webpack_require__(5246);
const FinderPattern = __webpack_require__(7845);
const MaskPattern = __webpack_require__(1449);
const ECCode = __webpack_require__(2677);
const ReedSolomonEncoder = __webpack_require__(7353);
const Version = __webpack_require__(9663);
const FormatInfo = __webpack_require__(1286);
const Mode = __webpack_require__(1125);
const Segments = __webpack_require__(1564);
/**
* QRCode for JavaScript
*
* modified by Ryan Day for nodejs support
* Copyright (c) 2011 Ryan Day
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/mit-license.php
*
//---------------------------------------------------------------------
// QRCode for JavaScript
//
// Copyright (c) 2009 Kazuhiko Arase
//
// URL: http://www.d-project.com/
//
// Licensed under the MIT license:
// http://www.opensource.org/licenses/mit-license.php
//
// The word "QR Code" is registered trademark of
// DENSO WAVE INCORPORATED
// http://www.denso-wave.com/qrcode/faqpatent-e.html
//
//---------------------------------------------------------------------
*/
/**
* Add finder patterns bits to matrix
*
* @param {BitMatrix} matrix Modules matrix
* @param {Number} version QR Code version
*/
function setupFinderPattern(matrix, version) {
const size = matrix.size;
const pos = FinderPattern.getPositions(version);
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);
}
}
}
}
}
/**
* Add timing pattern bits to matrix
*
* Note: this function must be called before {@link setupAlignmentPattern}
*
* @param {BitMatrix} matrix Modules matrix
*/
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);
}
}
/**
* Add alignment patterns bits to matrix
*
* Note: this function must be called after {@link setupTimingPattern}
*
* @param {BitMatrix} matrix Modules matrix
* @param {Number} version QR Code version
*/
function setupAlignmentPattern(matrix, version) {
const pos = AlignmentPattern.getPositions(version);
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);
}
}
}
}
}
/**
* Add version info bits to matrix
*
* @param {BitMatrix} matrix Modules matrix
* @param {Number} version QR Code version
*/
function setupVersionInfo(matrix, version) {
const size = matrix.size;
const bits = Version.getEncodedBits(version);
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);
}
}
/**
* Add format info bits to matrix
*
* @param {BitMatrix} matrix Modules matrix
* @param {ErrorCorrectionLevel} errorCorrectionLevel Error correction level
* @param {Number} maskPattern Mask pattern reference value
*/
function setupFormatInfo(matrix, errorCorrectionLevel, maskPattern) {
const size = matrix.size;
const bits = FormatInfo.getEncodedBits(errorCorrectionLevel, ma