@ozdao/prometheus-framework 0.2.330 → 0.2.331

package/dist/node_modules/qrcode/lib/core/qrcode.js

@@ -1,283 +1,279 @@
 import { __exports as qrcode } from "../../../../_virtual/qrcode.js";
-import "./utils.js";
-import "./error-correction-level.js";
-import { b as bitBuffer } from "./bit-buffer.js";
-import { b as bitMatrix } from "./bit-matrix.js";
-import "./alignment-pattern.js";
-import "./finder-pattern.js";
-import "./mask-pattern.js";
-import "./error-correction-code.js";
-import { r as reedSolomonEncoder } from "./reed-solomon-encoder.js";
-import "./version.js";
-import "./format-info.js";
-import "./mode.js";
-import "./segments.js";
-import { __exports as utils } from "../../../../_virtual/utils.js";
-import { __exports as errorCorrectionLevel } from "../../../../_virtual/error-correction-level.js";
-import { __exports as maskPattern } from "../../../../_virtual/mask-pattern.js";
-import { __exports as version } from "../../../../_virtual/version.js";
-import { __exports as segments } from "../../../../_virtual/segments.js";
-import { __exports as alignmentPattern } from "../../../../_virtual/alignment-pattern.js";
-import { __exports as finderPattern } from "../../../../_virtual/finder-pattern.js";
-import { __exports as errorCorrectionCode } from "../../../../_virtual/error-correction-code.js";
-import { __exports as formatInfo } from "../../../../_virtual/format-info.js";
-import { __exports as mode } from "../../../../_virtual/mode.js";
-const Utils = utils;
-const ECLevel = errorCorrectionLevel;
-const BitBuffer = bitBuffer;
-const BitMatrix = bitMatrix;
-const AlignmentPattern = alignmentPattern;
-const FinderPattern = finderPattern;
-const MaskPattern = maskPattern;
-const ECCode = errorCorrectionCode;
-const ReedSolomonEncoder = reedSolomonEncoder;
-const Version = version;
-const FormatInfo = formatInfo;
-const Mode = mode;
-const Segments = segments;
-function setupFinderPattern(matrix, version2) {
-  const size = matrix.size;
-  const pos = FinderPattern.getPositions(version2);
-  for (let i = 0; i < pos.length; i++) {
-    const row = pos[i][0];
-    const col = pos[i][1];
-    for (let r = -1; r <= 7; r++) {
-      if (row + r <= -1 || size <= row + r) continue;
-      for (let c = -1; c <= 7; c++) {
-        if (col + c <= -1 || size <= col + c) continue;
-        if (r >= 0 && r <= 6 && (c === 0 || c === 6) || c >= 0 && c <= 6 && (r === 0 || r === 6) || r >= 2 && r <= 4 && c >= 2 && c <= 4) {
-          matrix.set(row + r, col + c, true, true);
-        } else {
-          matrix.set(row + r, col + c, false, true);
+import { __require as requireUtils } from "./utils.js";
+import { __require as requireErrorCorrectionLevel } from "./error-correction-level.js";
+import { __require as requireBitBuffer } from "./bit-buffer.js";
+import { __require as requireBitMatrix } from "./bit-matrix.js";
+import { __require as requireAlignmentPattern } from "./alignment-pattern.js";
+import { __require as requireFinderPattern } from "./finder-pattern.js";
+import { __require as requireMaskPattern } from "./mask-pattern.js";
+import { __require as requireErrorCorrectionCode } from "./error-correction-code.js";
+import { __require as requireReedSolomonEncoder } from "./reed-solomon-encoder.js";
+import { __require as requireVersion } from "./version.js";
+import { __require as requireFormatInfo } from "./format-info.js";
+import { __require as requireMode } from "./mode.js";
+import { __require as requireSegments } from "./segments.js";
+var hasRequiredQrcode;
+function requireQrcode() {
+  if (hasRequiredQrcode) return qrcode;
+  hasRequiredQrcode = 1;
+  const Utils = requireUtils();
+  const ECLevel = requireErrorCorrectionLevel();
+  const BitBuffer = requireBitBuffer();
+  const BitMatrix = requireBitMatrix();
+  const AlignmentPattern = requireAlignmentPattern();
+  const FinderPattern = requireFinderPattern();
+  const MaskPattern = requireMaskPattern();
+  const ECCode = requireErrorCorrectionCode();
+  const ReedSolomonEncoder = requireReedSolomonEncoder();
+  const Version = requireVersion();
+  const FormatInfo = requireFormatInfo();
+  const Mode = requireMode();
+  const Segments = requireSegments();
+  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);
+          }
         }
       }
     }
   }
-}
-function setupTimingPattern(matrix) {
-  const size = matrix.size;
-  for (let r = 8; r < size - 8; r++) {
-    const value = r % 2 === 0;
-    matrix.set(r, 6, value, true);
-    matrix.set(6, r, value, true);
+  function setupTimingPattern(matrix) {
+    const size = matrix.size;
+    for (let r = 8; r < size - 8; r++) {
+      const value = r % 2 === 0;
+      matrix.set(r, 6, value, true);
+      matrix.set(6, r, value, true);
+    }
   }
-}
-function setupAlignmentPattern(matrix, version2) {
-  const pos = AlignmentPattern.getPositions(version2);
-  for (let i = 0; i < pos.length; i++) {
-    const row = pos[i][0];
-    const col = pos[i][1];
-    for (let r = -2; r <= 2; r++) {
-      for (let c = -2; c <= 2; c++) {
-        if (r === -2 || r === 2 || c === -2 || c === 2 || r === 0 && c === 0) {
-          matrix.set(row + r, col + c, true, true);
-        } else {
-          matrix.set(row + r, col + c, false, true);
+  function 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);
+          }
         }
       }
     }
   }
-}
-function setupVersionInfo(matrix, version2) {
-  const size = matrix.size;
-  const bits = Version.getEncodedBits(version2);
-  let row, col, mod;
-  for (let i = 0; i < 18; i++) {
-    row = Math.floor(i / 3);
-    col = i % 3 + size - 8 - 3;
-    mod = (bits >> i & 1) === 1;
-    matrix.set(row, col, mod, true);
-    matrix.set(col, row, mod, true);
-  }
-}
-function setupFormatInfo(matrix, errorCorrectionLevel2, maskPattern2) {
-  const size = matrix.size;
-  const bits = FormatInfo.getEncodedBits(errorCorrectionLevel2, maskPattern2);
-  let i, mod;
-  for (i = 0; i < 15; i++) {
-    mod = (bits >> i & 1) === 1;
-    if (i < 6) {
-      matrix.set(i, 8, mod, true);
-    } else if (i < 8) {
-      matrix.set(i + 1, 8, mod, true);
-    } else {
-      matrix.set(size - 15 + i, 8, mod, true);
+  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);
     }
-    if (i < 8) {
-      matrix.set(8, size - i - 1, mod, true);
-    } else if (i < 9) {
-      matrix.set(8, 15 - i - 1 + 1, mod, true);
-    } else {
-      matrix.set(8, 15 - i - 1, mod, true);
+  }
+  function setupFormatInfo(matrix, errorCorrectionLevel, maskPattern) {
+    const size = matrix.size;
+    const bits = FormatInfo.getEncodedBits(errorCorrectionLevel, maskPattern);
+    let i, mod;
+    for (i = 0; i < 15; i++) {
+      mod = (bits >> i & 1) === 1;
+      if (i < 6) {
+        matrix.set(i, 8, mod, true);
+      } else if (i < 8) {
+        matrix.set(i + 1, 8, mod, true);
+      } else {
+        matrix.set(size - 15 + i, 8, mod, true);
+      }
+      if (i < 8) {
+        matrix.set(8, size - i - 1, mod, true);
+      } else if (i < 9) {
+        matrix.set(8, 15 - i - 1 + 1, mod, true);
+      } else {
+        matrix.set(8, 15 - i - 1, mod, true);
+      }
     }
+    matrix.set(size - 8, 8, 1, true);
   }
-  matrix.set(size - 8, 8, 1, true);
-}
-function setupData(matrix, data) {
-  const size = matrix.size;
-  let inc = -1;
-  let row = size - 1;
-  let bitIndex = 7;
-  let byteIndex = 0;
-  for (let col = size - 1; col > 0; col -= 2) {
-    if (col === 6) col--;
-    while (true) {
-      for (let c = 0; c < 2; c++) {
-        if (!matrix.isReserved(row, col - c)) {
-          let dark = false;
-          if (byteIndex < data.length) {
-            dark = (data[byteIndex] >>> bitIndex & 1) === 1;
-          }
-          matrix.set(row, col - c, dark);
-          bitIndex--;
-          if (bitIndex === -1) {
-            byteIndex++;
-            bitIndex = 7;
+  function setupData(matrix, data) {
+    const size = matrix.size;
+    let inc = -1;
+    let row = size - 1;
+    let bitIndex = 7;
+    let byteIndex = 0;
+    for (let col = size - 1; col > 0; col -= 2) {
+      if (col === 6) col--;
+      while (true) {
+        for (let c = 0; c < 2; c++) {
+          if (!matrix.isReserved(row, col - c)) {
+            let dark = false;
+            if (byteIndex < data.length) {
+              dark = (data[byteIndex] >>> bitIndex & 1) === 1;
+            }
+            matrix.set(row, col - c, dark);
+            bitIndex--;
+            if (bitIndex === -1) {
+              byteIndex++;
+              bitIndex = 7;
+            }
           }
         }
-      }
-      row += inc;
-      if (row < 0 || size <= row) {
-        row -= inc;
-        inc = -inc;
-        break;
+        row += inc;
+        if (row < 0 || size <= row) {
+          row -= inc;
+          inc = -inc;
+          break;
+        }
       }
     }
   }
-}
-function createData(version2, errorCorrectionLevel2, segments2) {
-  const buffer = new BitBuffer();
-  segments2.forEach(function(data) {
-    buffer.put(data.mode.bit, 4);
-    buffer.put(data.getLength(), Mode.getCharCountIndicator(data.mode, version2));
-    data.write(buffer);
-  });
-  const totalCodewords = Utils.getSymbolTotalCodewords(version2);
-  const ecTotalCodewords = ECCode.getTotalCodewordsCount(version2, errorCorrectionLevel2);
-  const dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8;
-  if (buffer.getLengthInBits() + 4 <= dataTotalCodewordsBits) {
-    buffer.put(0, 4);
-  }
-  while (buffer.getLengthInBits() % 8 !== 0) {
-    buffer.putBit(0);
-  }
-  const remainingByte = (dataTotalCodewordsBits - buffer.getLengthInBits()) / 8;
-  for (let i = 0; i < remainingByte; i++) {
-    buffer.put(i % 2 ? 17 : 236, 8);
-  }
-  return createCodewords(buffer, version2, errorCorrectionLevel2);
-}
-function createCodewords(bitBuffer2, version2, errorCorrectionLevel2) {
-  const totalCodewords = Utils.getSymbolTotalCodewords(version2);
-  const ecTotalCodewords = ECCode.getTotalCodewordsCount(version2, errorCorrectionLevel2);
-  const dataTotalCodewords = totalCodewords - ecTotalCodewords;
-  const ecTotalBlocks = ECCode.getBlocksCount(version2, errorCorrectionLevel2);
-  const blocksInGroup2 = totalCodewords % ecTotalBlocks;
-  const blocksInGroup1 = ecTotalBlocks - blocksInGroup2;
-  const totalCodewordsInGroup1 = Math.floor(totalCodewords / ecTotalBlocks);
-  const dataCodewordsInGroup1 = Math.floor(dataTotalCodewords / ecTotalBlocks);
-  const dataCodewordsInGroup2 = dataCodewordsInGroup1 + 1;
-  const ecCount = totalCodewordsInGroup1 - dataCodewordsInGroup1;
-  const rs = new ReedSolomonEncoder(ecCount);
-  let offset = 0;
-  const dcData = new Array(ecTotalBlocks);
-  const ecData = new Array(ecTotalBlocks);
-  let maxDataSize = 0;
-  const buffer = new Uint8Array(bitBuffer2.buffer);
-  for (let b = 0; b < ecTotalBlocks; b++) {
-    const dataSize = b < blocksInGroup1 ? dataCodewordsInGroup1 : dataCodewordsInGroup2;
-    dcData[b] = buffer.slice(offset, offset + dataSize);
-    ecData[b] = rs.encode(dcData[b]);
-    offset += dataSize;
-    maxDataSize = Math.max(maxDataSize, dataSize);
+  function createData(version, errorCorrectionLevel, segments) {
+    const buffer = new BitBuffer();
+    segments.forEach(function(data) {
+      buffer.put(data.mode.bit, 4);
+      buffer.put(data.getLength(), Mode.getCharCountIndicator(data.mode, version));
+      data.write(buffer);
+    });
+    const totalCodewords = Utils.getSymbolTotalCodewords(version);
+    const ecTotalCodewords = ECCode.getTotalCodewordsCount(version, errorCorrectionLevel);
+    const dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8;
+    if (buffer.getLengthInBits() + 4 <= dataTotalCodewordsBits) {
+      buffer.put(0, 4);
+    }
+    while (buffer.getLengthInBits() % 8 !== 0) {
+      buffer.putBit(0);
+    }
+    const remainingByte = (dataTotalCodewordsBits - buffer.getLengthInBits()) / 8;
+    for (let i = 0; i < remainingByte; i++) {
+      buffer.put(i % 2 ? 17 : 236, 8);
+    }
+    return createCodewords(buffer, version, errorCorrectionLevel);
   }
-  const data = new Uint8Array(totalCodewords);
-  let index = 0;
-  let i, r;
-  for (i = 0; i < maxDataSize; i++) {
-    for (r = 0; r < ecTotalBlocks; r++) {
-      if (i < dcData[r].length) {
-        data[index++] = dcData[r][i];
+  function createCodewords(bitBuffer, version, errorCorrectionLevel) {
+    const totalCodewords = Utils.getSymbolTotalCodewords(version);
+    const ecTotalCodewords = ECCode.getTotalCodewordsCount(version, errorCorrectionLevel);
+    const dataTotalCodewords = totalCodewords - ecTotalCodewords;
+    const ecTotalBlocks = ECCode.getBlocksCount(version, errorCorrectionLevel);
+    const blocksInGroup2 = totalCodewords % ecTotalBlocks;
+    const blocksInGroup1 = ecTotalBlocks - blocksInGroup2;
+    const totalCodewordsInGroup1 = Math.floor(totalCodewords / ecTotalBlocks);
+    const dataCodewordsInGroup1 = Math.floor(dataTotalCodewords / ecTotalBlocks);
+    const dataCodewordsInGroup2 = dataCodewordsInGroup1 + 1;
+    const ecCount = totalCodewordsInGroup1 - dataCodewordsInGroup1;
+    const rs = new ReedSolomonEncoder(ecCount);
+    let offset = 0;
+    const dcData = new Array(ecTotalBlocks);
+    const ecData = new Array(ecTotalBlocks);
+    let maxDataSize = 0;
+    const buffer = new Uint8Array(bitBuffer.buffer);
+    for (let b = 0; b < ecTotalBlocks; b++) {
+      const dataSize = b < blocksInGroup1 ? dataCodewordsInGroup1 : dataCodewordsInGroup2;
+      dcData[b] = buffer.slice(offset, offset + dataSize);
+      ecData[b] = rs.encode(dcData[b]);
+      offset += dataSize;
+      maxDataSize = Math.max(maxDataSize, dataSize);
+    }
+    const data = new Uint8Array(totalCodewords);
+    let index = 0;
+    let i, r;
+    for (i = 0; i < maxDataSize; i++) {
+      for (r = 0; r < ecTotalBlocks; r++) {
+        if (i < dcData[r].length) {
+          data[index++] = dcData[r][i];
+        }
       }
     }
-  }
-  for (i = 0; i < ecCount; i++) {
-    for (r = 0; r < ecTotalBlocks; r++) {
-      data[index++] = ecData[r][i];
+    for (i = 0; i < ecCount; i++) {
+      for (r = 0; r < ecTotalBlocks; r++) {
+        data[index++] = ecData[r][i];
+      }
     }
+    return data;
   }
-  return data;
-}
-function createSymbol(data, version2, errorCorrectionLevel2, maskPattern2) {
-  let segments2;
-  if (Array.isArray(data)) {
-    segments2 = Segments.fromArray(data);
-  } else if (typeof data === "string") {
-    let estimatedVersion = version2;
-    if (!estimatedVersion) {
-      const rawSegments = Segments.rawSplit(data);
-      estimatedVersion = Version.getBestVersionForData(rawSegments, errorCorrectionLevel2);
+  function createSymbol(data, version, errorCorrectionLevel, maskPattern) {
+    let segments;
+    if (Array.isArray(data)) {
+      segments = Segments.fromArray(data);
+    } else if (typeof data === "string") {
+      let estimatedVersion = version;
+      if (!estimatedVersion) {
+        const rawSegments = Segments.rawSplit(data);
+        estimatedVersion = Version.getBestVersionForData(rawSegments, errorCorrectionLevel);
+      }
+      segments = Segments.fromString(data, estimatedVersion || 40);
+    } else {
+      throw new Error("Invalid data");
     }
-    segments2 = Segments.fromString(data, estimatedVersion || 40);
-  } else {
-    throw new Error("Invalid data");
-  }
-  const bestVersion = Version.getBestVersionForData(segments2, errorCorrectionLevel2);
-  if (!bestVersion) {
-    throw new Error("The amount of data is too big to be stored in a QR Code");
-  }
-  if (!version2) {
-    version2 = bestVersion;
-  } else if (version2 < bestVersion) {
-    throw new Error(
-      "\nThe chosen QR Code version cannot contain this amount of data.\nMinimum version required to store current data is: " + bestVersion + ".\n"
-    );
-  }
-  const dataBits = createData(version2, errorCorrectionLevel2, segments2);
-  const moduleCount = Utils.getSymbolSize(version2);
-  const modules = new BitMatrix(moduleCount);
-  setupFinderPattern(modules, version2);
-  setupTimingPattern(modules);
-  setupAlignmentPattern(modules, version2);
-  setupFormatInfo(modules, errorCorrectionLevel2, 0);
-  if (version2 >= 7) {
-    setupVersionInfo(modules, version2);
-  }
-  setupData(modules, dataBits);
-  if (isNaN(maskPattern2)) {
-    maskPattern2 = MaskPattern.getBestMask(
+    const bestVersion = Version.getBestVersionForData(segments, errorCorrectionLevel);
+    if (!bestVersion) {
+      throw new Error("The amount of data is too big to be stored in a QR Code");
+    }
+    if (!version) {
+      version = bestVersion;
+    } else if (version < bestVersion) {
+      throw new Error(
+        "\nThe chosen QR Code version cannot contain this amount of data.\nMinimum version required to store current data is: " + bestVersion + ".\n"
+      );
+    }
+    const dataBits = createData(version, errorCorrectionLevel, segments);
+    const moduleCount = Utils.getSymbolSize(version);
+    const modules = new BitMatrix(moduleCount);
+    setupFinderPattern(modules, version);
+    setupTimingPattern(modules);
+    setupAlignmentPattern(modules, version);
+    setupFormatInfo(modules, errorCorrectionLevel, 0);
+    if (version >= 7) {
+      setupVersionInfo(modules, version);
+    }
+    setupData(modules, dataBits);
+    if (isNaN(maskPattern)) {
+      maskPattern = MaskPattern.getBestMask(
+        modules,
+        setupFormatInfo.bind(null, modules, errorCorrectionLevel)
+      );
+    }
+    MaskPattern.applyMask(maskPattern, modules);
+    setupFormatInfo(modules, errorCorrectionLevel, maskPattern);
+    return {
       modules,
-      setupFormatInfo.bind(null, modules, errorCorrectionLevel2)
-    );
+      version,
+      errorCorrectionLevel,
+      maskPattern,
+      segments
+    };
   }
-  MaskPattern.applyMask(maskPattern2, modules);
-  setupFormatInfo(modules, errorCorrectionLevel2, maskPattern2);
-  return {
-    modules,
-    version: version2,
-    errorCorrectionLevel: errorCorrectionLevel2,
-    maskPattern: maskPattern2,
-    segments: segments2
+  qrcode.create = function create(data, options) {
+    if (typeof data === "undefined" || data === "") {
+      throw new Error("No input text");
+    }
+    let errorCorrectionLevel = ECLevel.M;
+    let version;
+    let mask;
+    if (typeof options !== "undefined") {
+      errorCorrectionLevel = ECLevel.from(options.errorCorrectionLevel, ECLevel.M);
+      version = Version.from(options.version);
+      mask = MaskPattern.from(options.maskPattern);
+      if (options.toSJISFunc) {
+        Utils.setToSJISFunction(options.toSJISFunc);
+      }
+    }
+    return createSymbol(data, version, errorCorrectionLevel, mask);
   };
+  return qrcode;
 }
-qrcode.create = function create(data, options) {
-  if (typeof data === "undefined" || data === "") {
-    throw new Error("No input text");
-  }
-  let errorCorrectionLevel2 = ECLevel.M;
-  let version2;
-  let mask;
-  if (typeof options !== "undefined") {
-    errorCorrectionLevel2 = ECLevel.from(options.errorCorrectionLevel, ECLevel.M);
-    version2 = Version.from(options.version);
-    mask = MaskPattern.from(options.maskPattern);
-    if (options.toSJISFunc) {
-      Utils.setToSJISFunction(options.toSJISFunc);
-    }
-  }
-  return createSymbol(data, version2, errorCorrectionLevel2, mask);
-};
 export {
-  qrcode as default
+  requireQrcode as __require
 };
 //# sourceMappingURL=qrcode.js.map