nuxi
Version:
Nuxt CLI
1,824 lines • 1.15 MB
JavaScript
import { i as __require, o as __toESM, t as __commonJSMin } from "./chunk-Vs_PY4HZ.mjs";
import { n as colors$2, r as getColor } from "./consola.DXBYu-KD-qSGefJ79.mjs";
import "./utils-MaFlCoS1.mjs";
import { r as f$1 } from "./dist-BkNIIgFa.mjs";
import { t as consola } from "./dist-Bvi-he5H.mjs";
import { i as supportsColor, r as init_supports_color } from "./logger-CtlB9piy.mjs";
import { t as defu } from "./defu-C23GdbdT.mjs";
import { t as overrideEnv } from "./env-DUdYa0ce.mjs";
import { a as join$1, c as resolve$2, i as isAbsolute$1, n as dirname$1, s as relative } from "./pathe.M-eThtNZ-BfnU2wdd.mjs";
import { a as stopCpuProfile, i as startCpuProfile, n as formatLockError, r as updateLock, t as acquireLock } from "./lockfile-Cj3CjE5w.mjs";
import { a as resolveModulePath, i as withNodePath, t as loadKit } from "./kit-Bx45zdA5.mjs";
import { n as joinURL } from "./dist-n2x8nSvK.mjs";
import { t as debounce } from "./dist-CE9BoWeK.mjs";
import { r as toNodeHandler } from "./node-2KsOo3qw.mjs";
import { n as showBanner } from "./banner-1xgvoFgm.mjs";
import { t as clearBuildDir } from "./fs-qJl3Qqxr.mjs";
import { a as writeNuxtManifest, i as resolveNuxtManifest, n as loadNuxtManifest } from "./nuxt-BFsY6rFZ.mjs";
import { builtinModules } from "node:module";
import path, { extname, join } from "node:path";
import process$1 from "node:process";
import { format, inspect, promisify } from "node:util";
import { fileURLToPath, pathToFileURL } from "node:url";
import fs, { accessSync, constants, existsSync, promises, readFileSync, readdirSync, realpathSync, statSync, watch } from "node:fs";
import { debuglog, inspect as inspect$1 } from "util";
import os, { networkInterfaces } from "node:os";
import EventEmitter from "node:events";
import { mkdir, readFile, stat } from "node:fs/promises";
import assert from "node:assert";
import v8 from "node:v8";
import { createServer } from "node:http";
import { createServer as createServer$1 } from "node:https";
import { createServer as createServer$2 } from "node:net";
import childProcess from "node:child_process";
import { fileURLToPath as fileURLToPath$1 } from "url";
import { readFile as readFile$1 } from "fs/promises";
//#region ../../node_modules/.pnpm/h3@1.15.11/node_modules/h3/dist/index.mjs
function hasProp$1(obj, prop) {
try {
return prop in obj;
} catch {
return false;
}
}
var H3Error = class extends Error {
static __h3_error__ = true;
statusCode = 500;
fatal = false;
unhandled = false;
statusMessage;
data;
cause;
constructor(message, opts = {}) {
super(message, opts);
if (opts.cause && !this.cause) this.cause = opts.cause;
}
toJSON() {
const obj = {
message: this.message,
statusCode: sanitizeStatusCode(this.statusCode, 500)
};
if (this.statusMessage) obj.statusMessage = sanitizeStatusMessage(this.statusMessage);
if (this.data !== void 0) obj.data = this.data;
return obj;
}
};
function createError$1(input) {
if (typeof input === "string") return new H3Error(input);
if (isError$1(input)) return input;
const err = new H3Error(input.message ?? input.statusMessage ?? "", { cause: input.cause || input });
if (hasProp$1(input, "stack")) try {
Object.defineProperty(err, "stack", { get() {
return input.stack;
} });
} catch {
try {
err.stack = input.stack;
} catch {}
}
if (input.data) err.data = input.data;
if (input.statusCode) err.statusCode = sanitizeStatusCode(input.statusCode, err.statusCode);
else if (input.status) err.statusCode = sanitizeStatusCode(input.status, err.statusCode);
if (input.statusMessage) err.statusMessage = input.statusMessage;
else if (input.statusText) err.statusMessage = input.statusText;
if (err.statusMessage) {
const originalMessage = err.statusMessage;
if (sanitizeStatusMessage(err.statusMessage) !== originalMessage) console.warn("[h3] Please prefer using `message` for longer error messages instead of `statusMessage`. In the future, `statusMessage` will be sanitized by default.");
}
if (input.fatal !== void 0) err.fatal = input.fatal;
if (input.unhandled !== void 0) err.unhandled = input.unhandled;
return err;
}
function sendError(event, error, debug) {
if (event.handled) return;
const h3Error = isError$1(error) ? error : createError$1(error);
const responseBody = {
statusCode: h3Error.statusCode,
statusMessage: h3Error.statusMessage,
stack: [],
data: h3Error.data
};
if (debug) responseBody.stack = (h3Error.stack || "").split("\n").map((l) => l.trim());
if (event.handled) return;
setResponseStatus(event, Number.parseInt(h3Error.statusCode), h3Error.statusMessage);
event.node.res.setHeader("content-type", MIMES.json);
event.node.res.end(JSON.stringify(responseBody, void 0, 2));
}
function isError$1(input) {
return input?.constructor?.__h3_error__ === true;
}
const MIMES = {
html: "text/html",
json: "application/json"
};
const DISALLOWED_STATUS_CHARS = /[^\u0009\u0020-\u007E]/g;
function sanitizeStatusMessage(statusMessage = "") {
return statusMessage.replace(DISALLOWED_STATUS_CHARS, "");
}
function sanitizeStatusCode(statusCode, defaultStatusCode = 200) {
if (!statusCode) return defaultStatusCode;
if (typeof statusCode === "string") statusCode = Number.parseInt(statusCode, 10);
if (statusCode < 100 || statusCode > 999) return defaultStatusCode;
return statusCode;
}
function splitCookiesString(cookiesString) {
if (Array.isArray(cookiesString)) return cookiesString.flatMap((c) => splitCookiesString(c));
if (typeof cookiesString !== "string") return [];
const cookiesStrings = [];
let pos = 0;
let start;
let ch;
let lastComma;
let nextStart;
let cookiesSeparatorFound;
const skipWhitespace = () => {
while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) pos += 1;
return pos < cookiesString.length;
};
const notSpecialChar = () => {
ch = cookiesString.charAt(pos);
return ch !== "=" && ch !== ";" && ch !== ",";
};
while (pos < cookiesString.length) {
start = pos;
cookiesSeparatorFound = false;
while (skipWhitespace()) {
ch = cookiesString.charAt(pos);
if (ch === ",") {
lastComma = pos;
pos += 1;
skipWhitespace();
nextStart = pos;
while (pos < cookiesString.length && notSpecialChar()) pos += 1;
if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
cookiesSeparatorFound = true;
pos = nextStart;
cookiesStrings.push(cookiesString.slice(start, lastComma));
start = pos;
} else pos = lastComma + 1;
} else pos += 1;
}
if (!cookiesSeparatorFound || pos >= cookiesString.length) cookiesStrings.push(cookiesString.slice(start));
}
return cookiesStrings;
}
function setResponseStatus(event, code, text) {
if (code) event.node.res.statusCode = sanitizeStatusCode(code, event.node.res.statusCode);
if (text) event.node.res.statusMessage = sanitizeStatusMessage(text);
}
function sendStream(event, stream) {
if (!stream || typeof stream !== "object") throw new Error("[h3] Invalid stream provided.");
event.node.res._data = stream;
if (!event.node.res.socket) {
event._handled = true;
return Promise.resolve();
}
if (hasProp$1(stream, "pipeTo") && typeof stream.pipeTo === "function") return stream.pipeTo(new WritableStream({ write(chunk) {
event.node.res.write(chunk);
} })).then(() => {
event.node.res.end();
});
if (hasProp$1(stream, "pipe") && typeof stream.pipe === "function") return new Promise((resolve, reject) => {
stream.pipe(event.node.res);
if (stream.on) {
stream.on("end", () => {
event.node.res.end();
resolve();
});
stream.on("error", (error) => {
reject(error);
});
}
event.node.res.on("close", () => {
if (stream.abort) stream.abort();
});
});
throw new Error("[h3] Invalid or incompatible stream provided.");
}
function sendWebResponse(event, response) {
for (const [key, value] of response.headers) if (key === "set-cookie") event.node.res.appendHeader(key, splitCookiesString(value));
else event.node.res.setHeader(key, value);
if (response.status) event.node.res.statusCode = sanitizeStatusCode(response.status, event.node.res.statusCode);
if (response.statusText) event.node.res.statusMessage = sanitizeStatusMessage(response.statusText);
if (response.redirected) event.node.res.setHeader("location", response.url);
if (!response.body) {
event.node.res.end();
return;
}
return sendStream(event, response.body);
}
var H3Event = class {
"__is_event__" = true;
node;
web;
context = {};
_method;
_path;
_headers;
_requestBody;
_handled = false;
_onBeforeResponseCalled;
_onAfterResponseCalled;
constructor(req, res) {
this.node = {
req,
res
};
}
get method() {
if (!this._method) this._method = (this.node.req.method || "GET").toUpperCase();
return this._method;
}
get path() {
return this._path || this.node.req.url || "/";
}
get headers() {
if (!this._headers) this._headers = _normalizeNodeHeaders(this.node.req.headers);
return this._headers;
}
get handled() {
return this._handled || this.node.res.writableEnded || this.node.res.headersSent;
}
respondWith(response) {
return Promise.resolve(response).then((_response) => sendWebResponse(this, _response));
}
toString() {
return `[${this.method}] ${this.path}`;
}
toJSON() {
return this.toString();
}
/** @deprecated Please use `event.node.req` instead. */
get req() {
return this.node.req;
}
/** @deprecated Please use `event.node.res` instead. */
get res() {
return this.node.res;
}
};
function createEvent(req, res) {
return new H3Event(req, res);
}
function _normalizeNodeHeaders(nodeHeaders) {
const headers = new Headers();
for (const [name, value] of Object.entries(nodeHeaders)) if (Array.isArray(value)) for (const item of value) headers.append(name, item);
else if (value) headers.set(name, value);
return headers;
}
globalThis.Headers;
globalThis.Response;
function toNodeListener(app) {
const toNodeHandle = async function(req, res) {
const event = createEvent(req, res);
try {
await app.handler(event);
} catch (_error) {
const error = createError$1(_error);
if (!isError$1(_error)) error.unhandled = true;
setResponseStatus(event, error.statusCode, error.statusMessage);
if (app.options.onError) await app.options.onError(error, event);
if (event.handled) return;
if (error.unhandled || error.fatal) console.error("[h3]", error.fatal ? "[fatal]" : "[unhandled]", error);
if (app.options.onBeforeResponse && !event._onBeforeResponseCalled) await app.options.onBeforeResponse(event, { body: error });
await sendError(event, error, !!app.options.debug);
if (app.options.onAfterResponse && !event._onAfterResponseCalled) await app.options.onAfterResponse(event, { body: error });
}
};
return toNodeHandle;
}
//#endregion
//#region ../../node_modules/.pnpm/get-port-please@3.2.0/node_modules/get-port-please/dist/index.mjs
const unsafePorts = /* @__PURE__ */ new Set([
1,
7,
9,
11,
13,
15,
17,
19,
20,
21,
22,
23,
25,
37,
42,
43,
53,
69,
77,
79,
87,
95,
101,
102,
103,
104,
109,
110,
111,
113,
115,
117,
119,
123,
135,
137,
139,
143,
161,
179,
389,
427,
465,
512,
513,
514,
515,
526,
530,
531,
532,
540,
548,
554,
556,
563,
587,
601,
636,
989,
990,
993,
995,
1719,
1720,
1723,
2049,
3659,
4045,
5060,
5061,
6e3,
6566,
6665,
6666,
6667,
6668,
6669,
6697,
10080
]);
function isUnsafePort(port) {
return unsafePorts.has(port);
}
function isSafePort(port) {
return !isUnsafePort(port);
}
var GetPortError = class extends Error {
constructor(message, opts) {
super(message, opts);
this.message = message;
}
name = "GetPortError";
};
function _log(verbose, message) {
if (verbose) console.log(`[get-port] ${message}`);
}
function _generateRange(from, to) {
if (to < from) return [];
const r = [];
for (let index = from; index <= to; index++) r.push(index);
return r;
}
function _tryPort(port, host) {
return new Promise((resolve) => {
const server = createServer$2();
server.unref();
server.on("error", () => {
resolve(false);
});
server.listen({
port,
host
}, () => {
const { port: port2 } = server.address();
server.close(() => {
resolve(isSafePort(port2) && port2);
});
});
});
}
function _getLocalHosts(additional) {
const hosts = new Set(additional);
for (const _interface of Object.values(networkInterfaces())) for (const config of _interface || []) if (config.address && !config.internal && !config.address.startsWith("fe80::") && !config.address.startsWith("169.254")) hosts.add(config.address);
return [...hosts];
}
async function _findPort(ports, host) {
for (const port of ports) {
const r = await _tryPort(port, host);
if (r) return r;
}
}
function _fmtOnHost(hostname) {
return hostname ? `on host ${JSON.stringify(hostname)}` : "on any host";
}
const HOSTNAME_RE$1 = /^(?!-)[\d.:A-Za-z-]{1,63}(?<!-)$/;
function _validateHostname(hostname, _public, verbose) {
if (hostname && !HOSTNAME_RE$1.test(hostname)) {
const fallbackHost = _public ? "0.0.0.0" : "127.0.0.1";
_log(verbose, `Invalid hostname: ${JSON.stringify(hostname)}. Using ${JSON.stringify(fallbackHost)} as fallback.`);
return fallbackHost;
}
return hostname;
}
async function getPort(_userOptions = {}) {
if (typeof _userOptions === "number" || typeof _userOptions === "string") _userOptions = { port: Number.parseInt(_userOptions + "") || 0 };
const _port = Number(_userOptions.port ?? process.env.PORT);
const _userSpecifiedAnyPort = Boolean(_userOptions.port || _userOptions.ports?.length || _userOptions.portRange?.length);
const options = {
random: _port === 0,
ports: [],
portRange: [],
alternativePortRange: _userSpecifiedAnyPort ? [] : [3e3, 3100],
verbose: false,
..._userOptions,
port: _port,
host: _validateHostname(_userOptions.host ?? process.env.HOST, _userOptions.public, _userOptions.verbose)
};
if (options.random && !_userSpecifiedAnyPort) return getRandomPort(options.host);
const portsToCheck = [
options.port,
...options.ports,
..._generateRange(...options.portRange)
].filter((port) => {
if (!port) return false;
if (!isSafePort(port)) {
_log(options.verbose, `Ignoring unsafe port: ${port}`);
return false;
}
return true;
});
if (portsToCheck.length === 0) portsToCheck.push(3e3);
let availablePort = await _findPort(portsToCheck, options.host);
if (!availablePort && options.alternativePortRange.length > 0) {
availablePort = await _findPort(_generateRange(...options.alternativePortRange), options.host);
if (portsToCheck.length > 0) {
let message = `Unable to find an available port (tried ${portsToCheck.join("-")} ${_fmtOnHost(options.host)}).`;
if (availablePort) message += ` Using alternative port ${availablePort}.`;
_log(options.verbose, message);
}
}
if (!availablePort && _userOptions.random !== false) {
availablePort = await getRandomPort(options.host);
if (availablePort) _log(options.verbose, `Using random port ${availablePort}`);
}
if (!availablePort) {
const triedRanges = [
options.port,
options.portRange.join("-"),
options.alternativePortRange.join("-")
].filter(Boolean).join(", ");
throw new GetPortError(`Unable to find an available port ${_fmtOnHost(options.host)} (tried ${triedRanges})`);
}
return availablePort;
}
async function getRandomPort(host) {
const port = await checkPort(0, host);
if (port === false) throw new GetPortError(`Unable to find a random port ${_fmtOnHost(host)}`);
return port;
}
async function checkPort(port, host = process.env.HOST, verbose) {
if (!host) host = _getLocalHosts([void 0, "0.0.0.0"]);
if (!Array.isArray(host)) return _tryPort(port, host);
for (const _host of host) {
const _port = await _tryPort(port, _host);
if (_port === false) {
if (port < 1024 && verbose) _log(verbose, `Unable to listen to the privileged port ${port} ${_fmtOnHost(_host)}`);
return false;
}
if (port === 0 && _port !== 0) port = _port;
}
return port;
}
//#endregion
//#region ../../node_modules/.pnpm/http-shutdown@1.2.2/node_modules/http-shutdown/index.js
var require_http_shutdown = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var http = __require("http");
var https = __require("https");
/**
* Expose `addShutdown`.
*/
exports = module.exports = addShutdown;
/**
* Adds shutdown functionaility to the `http.Server` object
* @param {http.Server} server The server to add shutdown functionaility to
*/
function addShutdown(server) {
var connections = {};
var isShuttingDown = false;
var connectionCounter = 0;
function destroy(socket, force) {
if (force || socket._isIdle && isShuttingDown) {
socket.destroy();
delete connections[socket._connectionId];
}
}
function onConnection(socket) {
var id = connectionCounter++;
socket._isIdle = true;
socket._connectionId = id;
connections[id] = socket;
socket.on("close", function() {
delete connections[id];
});
}
server.on("request", function(req, res) {
req.socket._isIdle = false;
res.on("finish", function() {
req.socket._isIdle = true;
destroy(req.socket);
});
});
server.on("connection", onConnection);
server.on("secureConnection", onConnection);
function shutdown(force, cb) {
isShuttingDown = true;
server.close(function(err) {
if (cb) process.nextTick(function() {
cb(err);
});
});
Object.keys(connections).forEach(function(key) {
destroy(connections[key], force);
});
}
server.shutdown = function(cb) {
shutdown(false, cb);
};
server.forceShutdown = function(cb) {
shutdown(true, cb);
};
return server;
}
/**
* Extends the {http.Server} object with shutdown functionaility.
* @return {http.Server} The decorated server object
*/
exports.extend = function() {
http.Server.prototype.withShutdown = function() {
return addShutdown(this);
};
https.Server.prototype.withShutdown = function() {
return addShutdown(this);
};
};
}));
//#endregion
//#region ../../node_modules/.pnpm/uqr@0.1.3/node_modules/uqr/dist/index.mjs
var import_http_shutdown = /* @__PURE__ */ __toESM(require_http_shutdown(), 1);
var QrCodeDataType = /* @__PURE__ */ ((QrCodeDataType2) => {
QrCodeDataType2[QrCodeDataType2["Border"] = -1] = "Border";
QrCodeDataType2[QrCodeDataType2["Data"] = 0] = "Data";
QrCodeDataType2[QrCodeDataType2["Function"] = 1] = "Function";
QrCodeDataType2[QrCodeDataType2["Position"] = 2] = "Position";
QrCodeDataType2[QrCodeDataType2["Timing"] = 3] = "Timing";
QrCodeDataType2[QrCodeDataType2["Alignment"] = 4] = "Alignment";
return QrCodeDataType2;
})(QrCodeDataType || {});
const LOW = [0, 1];
const MEDIUM = [1, 0];
const QUARTILE = [2, 3];
const HIGH = [3, 2];
const EccMap = {
L: LOW,
M: MEDIUM,
Q: QUARTILE,
H: HIGH
};
const NUMERIC_REGEX = /^\d*$/;
const ALPHANUMERIC_REGEX = /^[A-Z0-9 $%*+./:-]*$/;
const ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
const MIN_VERSION = 1;
const MAX_VERSION = 40;
const PENALTY_N1 = 3;
const PENALTY_N2 = 3;
const PENALTY_N3 = 40;
const PENALTY_N4 = 10;
const ECC_CODEWORDS_PER_BLOCK = [
[
-1,
7,
10,
15,
20,
26,
18,
20,
24,
30,
18,
20,
24,
26,
30,
22,
24,
28,
30,
28,
28,
28,
28,
30,
30,
26,
28,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30
],
[
-1,
10,
16,
26,
18,
24,
16,
18,
22,
22,
26,
30,
22,
22,
24,
24,
28,
28,
26,
26,
26,
26,
28,
28,
28,
28,
28,
28,
28,
28,
28,
28,
28,
28,
28,
28,
28,
28,
28,
28,
28
],
[
-1,
13,
22,
18,
26,
18,
24,
18,
22,
20,
24,
28,
26,
24,
20,
30,
24,
28,
28,
26,
30,
28,
30,
30,
30,
30,
28,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30
],
[
-1,
17,
28,
22,
16,
22,
28,
26,
26,
24,
28,
24,
28,
22,
24,
24,
30,
28,
28,
26,
28,
30,
24,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30,
30
]
];
const NUM_ERROR_CORRECTION_BLOCKS = [
[
-1,
1,
1,
1,
1,
1,
2,
2,
2,
2,
4,
4,
4,
4,
4,
6,
6,
6,
6,
7,
8,
8,
9,
9,
10,
12,
12,
12,
13,
14,
15,
16,
17,
18,
19,
19,
20,
21,
22,
24,
25
],
[
-1,
1,
1,
1,
2,
2,
4,
4,
4,
5,
5,
5,
8,
9,
9,
10,
10,
11,
13,
14,
16,
17,
17,
18,
20,
21,
23,
25,
26,
28,
29,
31,
33,
35,
37,
38,
40,
43,
45,
47,
49
],
[
-1,
1,
1,
2,
2,
4,
4,
6,
6,
8,
8,
8,
10,
12,
16,
12,
17,
16,
18,
21,
20,
23,
23,
25,
27,
29,
34,
34,
35,
38,
40,
43,
45,
48,
51,
53,
56,
59,
62,
65,
68
],
[
-1,
1,
1,
2,
4,
4,
4,
5,
6,
8,
8,
11,
11,
16,
16,
18,
16,
19,
21,
25,
25,
25,
34,
30,
32,
35,
37,
40,
42,
45,
48,
51,
54,
57,
60,
63,
66,
70,
74,
77,
81
]
];
var QrCode = class {
constructor(version, ecc, dataCodewords, msk) {
this.version = version;
this.ecc = ecc;
if (version < MIN_VERSION || version > MAX_VERSION) throw new RangeError("Version value out of range");
if (msk < -1 || msk > 7) throw new RangeError("Mask value out of range");
this.size = version * 4 + 17;
const row = Array.from({ length: this.size }).fill(false);
for (let i = 0; i < this.size; i++) {
this.modules.push(row.slice());
this.types.push(row.map(() => 0));
}
this.drawFunctionPatterns();
const allCodewords = this.addEccAndInterleave(dataCodewords);
this.drawCodewords(allCodewords);
if (msk === -1) {
let minPenalty = 1e9;
for (let i = 0; i < 8; i++) {
this.applyMask(i);
this.drawFormatBits(i);
const penalty = this.getPenaltyScore();
if (penalty < minPenalty) {
msk = i;
minPenalty = penalty;
}
this.applyMask(i);
}
}
this.mask = msk;
this.applyMask(msk);
this.drawFormatBits(msk);
}
size;
mask;
modules = [];
types = [];
getModule(x, y) {
return x >= 0 && x < this.size && y >= 0 && y < this.size && this.modules[y][x];
}
drawFunctionPatterns() {
for (let i = 0; i < this.size; i++) {
this.setFunctionModule(6, i, i % 2 === 0, QrCodeDataType.Timing);
this.setFunctionModule(i, 6, i % 2 === 0, QrCodeDataType.Timing);
}
this.drawFinderPattern(3, 3);
this.drawFinderPattern(this.size - 4, 3);
this.drawFinderPattern(3, this.size - 4);
const alignPatPos = this.getAlignmentPatternPositions();
const numAlign = alignPatPos.length;
for (let i = 0; i < numAlign; i++) for (let j = 0; j < numAlign; j++) if (!(i === 0 && j === 0 || i === 0 && j === numAlign - 1 || i === numAlign - 1 && j === 0)) this.drawAlignmentPattern(alignPatPos[i], alignPatPos[j]);
this.drawFormatBits(0);
this.drawVersion();
}
drawFormatBits(mask) {
const data = this.ecc[1] << 3 | mask;
let rem = data;
for (let i = 0; i < 10; i++) rem = rem << 1 ^ (rem >>> 9) * 1335;
const bits = (data << 10 | rem) ^ 21522;
for (let i = 0; i <= 5; i++) this.setFunctionModule(8, i, getBit(bits, i));
this.setFunctionModule(8, 7, getBit(bits, 6));
this.setFunctionModule(8, 8, getBit(bits, 7));
this.setFunctionModule(7, 8, getBit(bits, 8));
for (let i = 9; i < 15; i++) this.setFunctionModule(14 - i, 8, getBit(bits, i));
for (let i = 0; i < 8; i++) this.setFunctionModule(this.size - 1 - i, 8, getBit(bits, i));
for (let i = 8; i < 15; i++) this.setFunctionModule(8, this.size - 15 + i, getBit(bits, i));
this.setFunctionModule(8, this.size - 8, true);
}
drawVersion() {
if (this.version < 7) return;
let rem = this.version;
for (let i = 0; i < 12; i++) rem = rem << 1 ^ (rem >>> 11) * 7973;
const bits = this.version << 12 | rem;
for (let i = 0; i < 18; i++) {
const color = getBit(bits, i);
const a = this.size - 11 + i % 3;
const b = Math.floor(i / 3);
this.setFunctionModule(a, b, color);
this.setFunctionModule(b, a, color);
}
}
drawFinderPattern(x, y) {
for (let dy = -4; dy <= 4; dy++) for (let dx = -4; dx <= 4; dx++) {
const dist = Math.max(Math.abs(dx), Math.abs(dy));
const xx = x + dx;
const yy = y + dy;
if (xx >= 0 && xx < this.size && yy >= 0 && yy < this.size) this.setFunctionModule(xx, yy, dist !== 2 && dist !== 4, QrCodeDataType.Position);
}
}
drawAlignmentPattern(x, y) {
for (let dy = -2; dy <= 2; dy++) for (let dx = -2; dx <= 2; dx++) this.setFunctionModule(x + dx, y + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1, QrCodeDataType.Alignment);
}
setFunctionModule(x, y, isDark, type = QrCodeDataType.Function) {
this.modules[y][x] = isDark;
this.types[y][x] = type;
}
addEccAndInterleave(data) {
const ver = this.version;
const ecl = this.ecc;
if (data.length !== getNumDataCodewords(ver, ecl)) throw new RangeError("Invalid argument");
const numBlocks = NUM_ERROR_CORRECTION_BLOCKS[ecl[0]][ver];
const blockEccLen = ECC_CODEWORDS_PER_BLOCK[ecl[0]][ver];
const rawCodewords = Math.floor(getNumRawDataModules(ver) / 8);
const numShortBlocks = numBlocks - rawCodewords % numBlocks;
const shortBlockLen = Math.floor(rawCodewords / numBlocks);
const blocks = [];
const rsDiv = reedSolomonComputeDivisor(blockEccLen);
for (let i = 0, k = 0; i < numBlocks; i++) {
const dat = data.slice(k, k + shortBlockLen - blockEccLen + (i < numShortBlocks ? 0 : 1));
k += dat.length;
const ecc = reedSolomonComputeRemainder(dat, rsDiv);
if (i < numShortBlocks) dat.push(0);
blocks.push(dat.concat(ecc));
}
const result = [];
for (let i = 0; i < blocks[0].length; i++) blocks.forEach((block, j) => {
if (i !== shortBlockLen - blockEccLen || j >= numShortBlocks) result.push(block[i]);
});
return result;
}
drawCodewords(data) {
if (data.length !== Math.floor(getNumRawDataModules(this.version) / 8)) throw new RangeError("Invalid argument");
let i = 0;
for (let right = this.size - 1; right >= 1; right -= 2) {
if (right === 6) right = 5;
for (let vert = 0; vert < this.size; vert++) for (let j = 0; j < 2; j++) {
const x = right - j;
const y = (right + 1 & 2) === 0 ? this.size - 1 - vert : vert;
if (!this.types[y][x] && i < data.length * 8) {
this.modules[y][x] = getBit(data[i >>> 3], 7 - (i & 7));
i++;
}
}
}
}
applyMask(mask) {
if (mask < 0 || mask > 7) throw new RangeError("Mask value out of range");
for (let y = 0; y < this.size; y++) for (let x = 0; x < this.size; x++) {
let invert;
switch (mask) {
case 0:
invert = (x + y) % 2 === 0;
break;
case 1:
invert = y % 2 === 0;
break;
case 2:
invert = x % 3 === 0;
break;
case 3:
invert = (x + y) % 3 === 0;
break;
case 4:
invert = (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0;
break;
case 5:
invert = x * y % 2 + x * y % 3 === 0;
break;
case 6:
invert = (x * y % 2 + x * y % 3) % 2 === 0;
break;
case 7:
invert = ((x + y) % 2 + x * y % 3) % 2 === 0;
break;
default: throw new Error("Unreachable");
}
if (!this.types[y][x] && invert) this.modules[y][x] = !this.modules[y][x];
}
}
getPenaltyScore() {
let result = 0;
for (let y = 0; y < this.size; y++) {
let runColor = false;
let runX = 0;
const runHistory = [
0,
0,
0,
0,
0,
0,
0
];
for (let x = 0; x < this.size; x++) if (this.modules[y][x] === runColor) {
runX++;
if (runX === 5) result += PENALTY_N1;
else if (runX > 5) result++;
} else {
this.finderPenaltyAddHistory(runX, runHistory);
if (!runColor) result += this.finderPenaltyCountPatterns(runHistory) * PENALTY_N3;
runColor = this.modules[y][x];
runX = 1;
}
result += this.finderPenaltyTerminateAndCount(runColor, runX, runHistory) * PENALTY_N3;
}
for (let x = 0; x < this.size; x++) {
let runColor = false;
let runY = 0;
const runHistory = [
0,
0,
0,
0,
0,
0,
0
];
for (let y = 0; y < this.size; y++) if (this.modules[y][x] === runColor) {
runY++;
if (runY === 5) result += PENALTY_N1;
else if (runY > 5) result++;
} else {
this.finderPenaltyAddHistory(runY, runHistory);
if (!runColor) result += this.finderPenaltyCountPatterns(runHistory) * PENALTY_N3;
runColor = this.modules[y][x];
runY = 1;
}
result += this.finderPenaltyTerminateAndCount(runColor, runY, runHistory) * PENALTY_N3;
}
for (let y = 0; y < this.size - 1; y++) for (let x = 0; x < this.size - 1; x++) {
const color = this.modules[y][x];
if (color === this.modules[y][x + 1] && color === this.modules[y + 1][x] && color === this.modules[y + 1][x + 1]) result += PENALTY_N2;
}
let dark = 0;
for (const row of this.modules) dark = row.reduce((sum, color) => sum + (color ? 1 : 0), dark);
const total = this.size * this.size;
const k = Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1;
result += k * PENALTY_N4;
return result;
}
getAlignmentPatternPositions() {
if (this.version === 1) return [];
else {
const numAlign = Math.floor(this.version / 7) + 2;
const step = this.version === 32 ? 26 : Math.ceil((this.version * 4 + 4) / (numAlign * 2 - 2)) * 2;
const result = [6];
for (let pos = this.size - 7; result.length < numAlign; pos -= step) result.splice(1, 0, pos);
return result;
}
}
finderPenaltyCountPatterns(runHistory) {
const n = runHistory[1];
const core = n > 0 && runHistory[2] === n && runHistory[3] === n * 3 && runHistory[4] === n && runHistory[5] === n;
return (core && runHistory[0] >= n * 4 && runHistory[6] >= n ? 1 : 0) + (core && runHistory[6] >= n * 4 && runHistory[0] >= n ? 1 : 0);
}
finderPenaltyTerminateAndCount(currentRunColor, currentRunLength, runHistory) {
if (currentRunColor) {
this.finderPenaltyAddHistory(currentRunLength, runHistory);
currentRunLength = 0;
}
currentRunLength += this.size;
this.finderPenaltyAddHistory(currentRunLength, runHistory);
return this.finderPenaltyCountPatterns(runHistory);
}
finderPenaltyAddHistory(currentRunLength, runHistory) {
if (runHistory[0] === 0) currentRunLength += this.size;
runHistory.pop();
runHistory.unshift(currentRunLength);
}
};
function appendBits(val, len, bb) {
if (len < 0 || len > 31 || val >>> len !== 0) throw new RangeError("Value out of range");
for (let i = len - 1; i >= 0; i--) bb.push(val >>> i & 1);
}
function getBit(x, i) {
return (x >>> i & 1) !== 0;
}
var QrSegment = class {
constructor(mode, numChars, bitData) {
this.mode = mode;
this.numChars = numChars;
this.bitData = bitData;
if (numChars < 0) throw new RangeError("Invalid argument");
this.bitData = bitData.slice();
}
getData() {
return this.bitData.slice();
}
};
const MODE_NUMERIC = [
1,
10,
12,
14
];
const MODE_ALPHANUMERIC = [
2,
9,
11,
13
];
const MODE_BYTE = [
4,
8,
16,
16
];
function numCharCountBits(mode, ver) {
return mode[Math.floor((ver + 7) / 17) + 1];
}
function makeBytes(data) {
const bb = [];
for (const b of data) appendBits(b, 8, bb);
return new QrSegment(MODE_BYTE, data.length, bb);
}
function makeNumeric(digits) {
if (!isNumeric(digits)) throw new RangeError("String contains non-numeric characters");
const bb = [];
for (let i = 0; i < digits.length;) {
const n = Math.min(digits.length - i, 3);
appendBits(Number.parseInt(digits.substring(i, i + n), 10), n * 3 + 1, bb);
i += n;
}
return new QrSegment(MODE_NUMERIC, digits.length, bb);
}
function makeAlphanumeric(text) {
if (!isAlphanumeric(text)) throw new RangeError("String contains unencodable characters in alphanumeric mode");
const bb = [];
let i;
for (i = 0; i + 2 <= text.length; i += 2) {
let temp = ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)) * 45;
temp += ALPHANUMERIC_CHARSET.indexOf(text.charAt(i + 1));
appendBits(temp, 11, bb);
}
if (i < text.length) appendBits(ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)), 6, bb);
return new QrSegment(MODE_ALPHANUMERIC, text.length, bb);
}
function makeSegments(text) {
if (text === "") return [];
else if (isNumeric(text)) return [makeNumeric(text)];
else if (isAlphanumeric(text)) return [makeAlphanumeric(text)];
else return [makeBytes(toUtf8ByteArray(text))];
}
function isNumeric(text) {
return NUMERIC_REGEX.test(text);
}
function isAlphanumeric(text) {
return ALPHANUMERIC_REGEX.test(text);
}
function getTotalBits(segs, version) {
let result = 0;
for (const seg of segs) {
const ccbits = numCharCountBits(seg.mode, version);
if (seg.numChars >= 1 << ccbits) return Number.POSITIVE_INFINITY;
result += 4 + ccbits + seg.bitData.length;
}
return result;
}
function toUtf8ByteArray(str) {
str = encodeURI(str);
const result = [];
for (let i = 0; i < str.length; i++) if (str.charAt(i) !== "%") result.push(str.charCodeAt(i));
else {
result.push(Number.parseInt(str.substring(i + 1, i + 3), 16));
i += 2;
}
return result;
}
function getNumRawDataModules(ver) {
if (ver < MIN_VERSION || ver > MAX_VERSION) throw new RangeError("Version number out of range");
let result = (16 * ver + 128) * ver + 64;
if (ver >= 2) {
const numAlign = Math.floor(ver / 7) + 2;
result -= (25 * numAlign - 10) * numAlign - 55;
if (ver >= 7) result -= 36;
}
return result;
}
function getNumDataCodewords(ver, ecl) {
return Math.floor(getNumRawDataModules(ver) / 8) - ECC_CODEWORDS_PER_BLOCK[ecl[0]][ver] * NUM_ERROR_CORRECTION_BLOCKS[ecl[0]][ver];
}
function reedSolomonComputeDivisor(degree) {
if (degree < 1 || degree > 255) throw new RangeError("Degree out of range");
const result = [];
for (let i = 0; i < degree - 1; i++) result.push(0);
result.push(1);
let root = 1;
for (let i = 0; i < degree; i++) {
for (let j = 0; j < result.length; j++) {
result[j] = reedSolomonMultiply(result[j], root);
if (j + 1 < result.length) result[j] ^= result[j + 1];
}
root = reedSolomonMultiply(root, 2);
}
return result;
}
function reedSolomonComputeRemainder(data, divisor) {
const result = divisor.map((_) => 0);
for (const b of data) {
const factor = b ^ result.shift();
result.push(0);
divisor.forEach((coef, i) => result[i] ^= reedSolomonMultiply(coef, factor));
}
return result;
}
function reedSolomonMultiply(x, y) {
if (x >>> 8 !== 0 || y >>> 8 !== 0) throw new RangeError("Byte out of range");
let z = 0;
for (let i = 7; i >= 0; i--) {
z = z << 1 ^ (z >>> 7) * 285;
z ^= (y >>> i & 1) * x;
}
return z;
}
function encodeSegments(segs, ecl, minVersion = 1, maxVersion = 40, mask = -1, boostEcl = true) {
if (!(MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= MAX_VERSION) || mask < -1 || mask > 7) throw new RangeError("Invalid value");
let version;
let dataUsedBits;
for (version = minVersion;; version++) {
const dataCapacityBits2 = getNumDataCodewords(version, ecl) * 8;
const usedBits = getTotalBits(segs, version);
if (usedBits <= dataCapacityBits2) {
dataUsedBits = usedBits;
break;
}
if (version >= maxVersion) throw new RangeError("Data too long");
}
for (const newEcl of [
MEDIUM,
QUARTILE,
HIGH
]) if (boostEcl && dataUsedBits <= getNumDataCodewords(version, newEcl) * 8) ecl = newEcl;
const bb = [];
for (const seg of segs) {
appendBits(seg.mode[0], 4, bb);
appendBits(seg.numChars, numCharCountBits(seg.mode, version), bb);
for (const b of seg.getData()) bb.push(b);
}
const dataCapacityBits = getNumDataCodewords(version, ecl) * 8;
appendBits(0, Math.min(4, dataCapacityBits - bb.length), bb);
appendBits(0, (8 - bb.length % 8) % 8, bb);
for (let padByte = 236; bb.length < dataCapacityBits; padByte ^= 253) appendBits(padByte, 8, bb);
const dataCodewords = Array.from({ length: Math.ceil(bb.length / 8) }, () => 0);
bb.forEach((b, i) => dataCodewords[i >>> 3] |= b << 7 - (i & 7));
return new QrCode(version, ecl, dataCodewords, mask);
}
function encode(data, options) {
const { ecc = "L", boostEcc = false, minVersion = 1, maxVersion = 40, maskPattern = -1, border = 1 } = options || {};
const segment = typeof data === "string" ? makeSegments(data) : Array.isArray(data) ? [makeBytes(data)] : void 0;
if (!segment) throw new Error(`uqr only supports encoding string and binary data, but got: ${typeof data}`);
const qr = encodeSegments(segment, EccMap[ecc], minVersion, maxVersion, maskPattern, boostEcc);
const result = addBorder({
version: qr.version,
maskPattern: qr.mask,
size: qr.size,
data: qr.modules,
types: qr.types
}, border);
if (options?.invert) result.data = result.data.map((row) => row.map((mod) => !mod));
options?.onEncoded?.(result);
return result;
}
function addBorder(input, border = 1) {
if (!border) return input;
const { size } = input;
const newSize = size + border * 2;
input.size = newSize;
input.data.forEach((row) => {
for (let i = 0; i < border; i++) {
row.unshift(false);
row.push(false);
}
});
for (let i = 0; i < border; i++) {
input.data.unshift(Array.from({ length: newSize }, (_) => false));
input.data.push(Array.from({ length: newSize }, (_) => false));
}
const b = QrCodeDataType.Border;
input.types.forEach((row) => {
for (let i = 0; i < border; i++) {
row.unshift(b);
row.push(b);
}
});
for (let i = 0; i < border; i++) {
input.types.unshift(Array.from({ length: newSize }, (_) => b));
input.types.push(Array.from({ length: newSize }, (_) => b));
}
return input;
}
function getDataAt(data, x, y, defaults = false) {
if (x < 0 || y < 0 || x >= data.length || y >= data.length) return defaults;
return data[y][x];
}
function renderUnicodeCompact(data, options = {}) {
const palette = {
WHITE_ALL: "█",
WHITE_BLACK: "▀",
BLACK_WHITE: "▄",
BLACK_ALL: " "
};
const result = encode(data, options);
const WHITE = false;
const BLACK = true;
const at = (x, y) => getDataAt(result.data, x, y, true);
const lines = [];
let line = "";
for (let row = 0; row < result.size; row += 2) {
for (let col = 0; col < result.size; col++) if (at(col, row) === WHITE && at(col, row + 1) === WHITE) line += palette.WHITE_ALL;
else if (at(col, row) === WHITE && at(col, row + 1) === BLACK) line += palette.WHITE_BLACK;
else if (at(col, row) === BLACK && at(col, row + 1) === WHITE) line += palette.BLACK_WHITE;
else line += palette.BLACK_ALL;
lines.push(line);
line = "";
}
return lines.join("\n");
}
//#endregion
//#region ../../node_modules/.pnpm/node-forge@1.4.0/node_modules/node-forge/lib/forge.js
var require_forge = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/**
* Node.js module for Forge.
*
* @author Dave Longley
*
* Copyright 2011-2016 Digital Bazaar, Inc.
*/
module.exports = { options: { usePureJavaScript: false } };
}));
//#endregion
//#region ../../node_modules/.pnpm/node-forge@1.4.0/node_modules/node-forge/lib/baseN.js
var require_baseN = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/**
* Base-N/Base-X encoding/decoding functions.
*
* Original implementation from base-x:
* https://github.com/cryptocoinjs/base-x
*
* Which is MIT licensed:
*
* The MIT License (MIT)
*
* Copyright base-x contributors (c) 2016
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
var api = {};
module.exports = api;
var _reverseAlphabets = {};
/**
* BaseN-encodes a Uint8Array using the given alphabet.
*
* @param input the Uint8Array to encode.
* @param maxline the maximum number of encoded characters per line to use,
* defaults to none.
*
* @return the baseN-encoded output string.
*/
api.encode = function(input, alphabet, maxline) {
if (typeof alphabet !== "string") throw new TypeError("\"alphabet\" must be a string.");
if (maxline !== void 0 && typeof maxline !== "number") throw new TypeError("\"maxline\" must be a number.");
var output = "";
if (!(input instanceof Uint8Array)) output = _encodeWithByteBuffer(input, alphabet);
else {
var i = 0;
var base = alphabet.length;
var first = alphabet.charAt(0);
var digits = [0];
for (i = 0; i < input.length; ++i) {
for (var j = 0, carry = input[i]; j < digits.length; ++j) {
carry += digits[j] << 8;
digits[j] = carry % base;
carry = carry / base | 0;
}
while (carry > 0) {
digits.push(carry % base);
carry = carry / base | 0;
}
}
for (i = 0; input[i] === 0 && i < input.length - 1; ++i) output += first;
for (i = digits.length - 1; i >= 0; --i) output += alphabet[digits[i]];
}
if (maxline) {
var regex = new RegExp(".{1," + maxline + "}", "g");
output = output.match(regex).join("\r\n");
}
return output;
};
/**
* Decodes a baseN-encoded (using the given alphabet) string to a
* Uint8Array.
*
* @param input the baseN-encoded input string.
*
* @return the Uint8Array.
*/
api.decode = function(input, alphabet) {
if (typeof input !== "string") throw new TypeError("\"input\" must be a string.");
if (typeof alphabet !== "string") throw new TypeError("\"alphabet\" must be a string.");
var table = _reverseAlphabets[alphabet];
if (!table) {
table = _reverseAlphabets[alphabet] = [];
for (var i = 0; i < alphabet.length; ++i) table[alphabet.charCodeAt(i)] = i;
}
input = input.replace(/\s/g, "");
var base = alphabet.length;
var first = alphabet.charAt(0);
var bytes = [0];
for (var i = 0; i < input.length; i++) {
var value = table[input.charCodeAt(i)];
if (value === void 0) return;
for (var j = 0, carry = value; j < bytes.length; ++j) {
carry += bytes[j] * base;
bytes[j] = carry & 255;
carry >>= 8;
}
while (carry > 0) {
bytes.push(carry & 255);
carry >>= 8;
}
}
for (var k = 0; input[k] === first && k < input.length - 1; ++k) bytes.push(0);
if (typeof Buffer !== "undefined") return Buffer.from(bytes.reverse());
return new Uint8Array(bytes.reverse());
};
function _encodeWithByteBuffer(input, alphabet) {
var i = 0;
var base = alphabet.length;
var first = alphabet.charAt(0);
var digits = [0];
for (i = 0; i < input.length(); ++i) {
for (var j = 0, carry = input.at(i); j < digits.length; ++j) {
carry += digits[j] << 8;
digits[j] = carry % base;
carry = carry / base | 0;
}
while (carry > 0) {
digits.push(carry % base);
carry = carry / base | 0;
}
}
var output = "";
for (i = 0; input.at(i) === 0 && i < input.length() - 1; ++i) output += first;
for (i = digits.length - 1; i >= 0; --i) output += alphabet[digits[i]];
return output;
}
}));
//#endregion
//#region ../../node_modules/.pnpm/node-forge@1.4.0/node_modules/node-forge/lib/util.js
var require_util = /* @__PURE__ */ __commonJSMin(((exports, module) => {
/**
* Utility functions for web applications.
*
* @author Dave Longley
*
* Copyright (c) 2010-2018 Digital Bazaar, Inc.
*/
var forge = require_forge();
var baseN = require_baseN();
var util = module.exports = forge.util = forge.util || {};
(function() {
if (typeof process !== "undefined" && process.nextTick && !process.browser) {
util.nextTick = process.nextTick;
if (typeof setImmediate === "function") util.setImmediate = setImmediate;
else util.setImmediate = util.nextTick;
return;
}
if (typeof setImmediate === "function") {
util.setImmediate = function() {
return setImmediate.apply(void 0, arguments);
};
util.nextTick = function(callback) {
return setImmediate(callback);
};
return;
}
util.setImmediate = function(callback) {
setTimeout(callback, 0);
};
if (typeof window !== "undefined" && typeof window.postMessage === "function") {
var msg = "forge.setImmediate";
var callbacks = [];
util.setImmediate = function(callback) {
callbacks.push(callback);
if (callbacks.length === 1) window.postMessage(msg, "*");
};
function handler(event) {
if (event.source === window && event.data === msg) {
event.stopPropagation();
var copy = callbacks.slice();
callbacks.length = 0;
copy.forEach(function(callback) {
callback();
});
}
}
window.addEventListener("message", handler, true);
}
if (typeof MutationObserver !== "undefined") {
var now = Date.now();
var attr = true;
var div = document.createElement("div");
var callbacks = [];
new MutationObserver(function() {
var copy = callbacks.slice();
callbacks.length = 0;
copy.forEach(function(callback) {
callback();
});
}).observe(div, { attributes: true });
var oldSetImmediate = util.setImmediate;
util.setImmediate = function(callback) {
if (Date.now() - now > 15) {
now = Date.now();
oldSetImmediate(callback);
} else {
callbacks.push(callback);
if (callbacks.length === 1) div.setAttribute("a", attr = !attr);
}
};
}
util.nextTick = util.setImmediate;
})();
util.isNodejs = typeof process !== "undefined" && process.versions && process.versions.node;
util.globalScope = (function() {
if (util.isNodejs) return global;
return typeof self === "undefined" ? window : self;
})();
util.isArray = Array.isArray || function(x) {
return Object.prototype.toString.call(x) === "[object Array]";
};
util.isArrayBuffer = function(x) {
return typeof ArrayBuffer !== "undefined" && x instanceof ArrayBuffer;
};
util.isArrayBufferView = function(x) {
return x && util.isArrayBuffer(x.buffer) && x.byteLength !== void 0;
};
/**
* Ensure a bits param is 8, 16, 24, or 32. Used to validate input for
* algorithms where bit manipulation, JavaScript limitations, and/or algorithm
* design only allow for byte operations of a limited size.
*
* @param n number of bits.
*
* Throw Error if n invalid.
*/
function _checkBitsParam(n) {
if (!(n === 8 || n === 16 || n === 24 || n === 32)) throw new Error("Only 8, 16, 24, or 32 bits supported: " + n);
}
util.ByteBuffer = ByteStringBuffer;
/** Buffer w/BinaryString backing */
/**
* Constructor for a binary string backed byte buffer.
*
* @param [b] the bytes to wrap (either encoded as string, one byte per
* character, or as an ArrayBuffer or Typed Array).
*/
function ByteStringBuffer(b) {
this.data = "";
this.read = 0;
if (typeof b === "string") this.data = b;
else if (util.isArrayBuffer(b) || util.isArrayBufferView(b)) if (typeof Buffer !== "undefined" && b instanceof Buffer) this.data = b.toString("binary");
else {
var arr = new Uint8Array(b);
try {
this.data = String.fromCharCode.apply(null, arr);
} catch (e) {
for (var i = 0; i < arr.length; ++i) this.putByte(arr[i]);
}
}
else if (b instanceof ByteStringBuffer || typeof b === "object" && typeof b.data === "string" && typeof b.read === "number") {
this.data = b.data;
this.read = b.read;
}
this._constructedStringLength = 0;
}
util.ByteStringBuffer = ByteStringBuffer;
var _MAX_CONSTRUCTED_STRING_LENGTH = 4096;
util.ByteStringBuffer.prototype._optimizeConstructedString = function(x) {
this._constructedStringLength += x;
if (this._constructedStringLength > _MAX_CONSTRUCTED_STRING_LENGTH) {
this.data.substr(0, 1);
this._constructedStringLength = 0;
}
};
/**
* Gets the number of bytes in this buffer.
*
* @return the number of bytes in this buffer.
*/
util.ByteStringBuffer.prototype.length = function() {
return this.data.length - this.read;
};
/**
* Gets whether or not this buffer is empty.
*
* @return true if this buffer is empty, false if not.
*/
util.ByteStringBuffer.prototype.isEmpty = function() {
return this.length() <= 0;
};
/**
* Puts a byte in this buffer.
*
* @param b the byte to put.
*
* @return this buffer.
*/
util.ByteStringBuffer.prototype.putByte = function(b) {
return this.putBytes(String.fromCharCode(b));
};
/**
* Puts a byte in this buffer N times.
*
* @param b the byte to put.
* @param n the number of bytes of value b to put.
*
* @return this buffer.
*/
util.ByteStringBuffer.prototype.fillWithByte = function(b, n) {
b = String.fromCharCode(b);
var d = this.data;
while (n > 0) {
if (n & 1) d += b;
n >>>= 1;
if (n > 0) b += b;
}
this.data = d;
this._optimizeConstructedString(n);
return this;
};
/**
* Puts bytes in this buffer.
*
* @param bytes the bytes (as a binary encoded string) to put.
*
* @return this buffer.
*/
util.ByteStringBuffer.prototype.putBytes = function(bytes) {
this.data += bytes;
this._optimizeConstructedString(bytes.length);
return this;
};
/**
* Puts a UTF-16 encoded string into this buffer.
*
* @param str the string to put.
*
* @return this buffer.
*/
util.ByteStringBuffer.prototype.putString = function(str) {
return this.putBytes(util.encodeUtf8(str));
};
/**
* Puts a 16-bit integer in this buffer in big-endian order.
*
* @param i the 16-bit integer.
*
* @return this buffer.
*/
util.ByteStringBuffer.prototype.putInt16 = function(i) {
return this.putBytes(String.fromCharCode(i >> 8 & 255) + String.fromCharC