@ozdao/prometheus-framework 0.2.330 → 0.2.331

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

@@ -1,195 +1,201 @@
 import { __exports as segments } from "../../../../_virtual/segments.js";
-import "./mode.js";
-import { n as numericData } from "./numeric-data.js";
-import { a as alphanumericData } from "./alphanumeric-data.js";
-import { b as byteData } from "./byte-data.js";
-import { k as kanjiData } from "./kanji-data.js";
-import "./regex.js";
-import "./utils.js";
-import { d as dijkstraExports } from "../../../dijkstrajs/dijkstra.js";
-import { __exports as utils } from "../../../../_virtual/utils.js";
-import { __exports as mode } from "../../../../_virtual/mode.js";
-import { __exports as regex } from "../../../../_virtual/regex.js";
-(function(exports) {
-  const Mode = mode;
-  const NumericData = numericData;
-  const AlphanumericData = alphanumericData;
-  const ByteData = byteData;
-  const KanjiData = kanjiData;
-  const Regex = regex;
-  const Utils = utils;
-  const dijkstra = dijkstraExports;
-  function getStringByteLength(str) {
-    return unescape(encodeURIComponent(str)).length;
-  }
-  function getSegments(regex2, mode2, str) {
-    const segments2 = [];
-    let result;
-    while ((result = regex2.exec(str)) !== null) {
-      segments2.push({
-        data: result[0],
-        index: result.index,
-        mode: mode2,
-        length: result[0].length
-      });
-    }
-    return segments2;
-  }
-  function getSegmentsFromString(dataStr) {
-    const numSegs = getSegments(Regex.NUMERIC, 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 = [];
+import { __require as requireMode } from "./mode.js";
+import { __require as requireNumericData } from "./numeric-data.js";
+import { __require as requireAlphanumericData } from "./alphanumeric-data.js";
+import { __require as requireByteData } from "./byte-data.js";
+import { __require as requireKanjiData } from "./kanji-data.js";
+import { __require as requireRegex } from "./regex.js";
+import { __require as requireUtils } from "./utils.js";
+import { __require as requireDijkstra } from "../../../dijkstrajs/dijkstra.js";
+var hasRequiredSegments;
+function requireSegments() {
+  if (hasRequiredSegments) return segments;
+  hasRequiredSegments = 1;
+  (function(exports) {
+    const Mode = requireMode();
+    const NumericData = requireNumericData();
+    const AlphanumericData = requireAlphanumericData();
+    const ByteData = requireByteData();
+    const KanjiData = requireKanjiData();
+    const Regex = requireRegex();
+    const Utils = requireUtils();
+    const dijkstra = requireDijkstra();
+    function getStringByteLength(str) {
+      return unescape(encodeURIComponent(str)).length;
     }
-    const segs = numSegs.concat(alphaNumSegs, byteSegs, kanjiSegs);
-    return segs.sort(function(s1, s2) {
-      return s1.index - s2.index;
-    }).map(function(obj) {
-      return {
-        data: obj.data,
-        mode: obj.mode,
-        length: obj.length
-      };
-    });
-  }
-  function getSegmentBitsLength(length, mode2) {
-    switch (mode2) {
-      case 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);
+    function getSegments(regex, mode, str) {
+      const segments2 = [];
+      let result;
+      while ((result = regex.exec(str)) !== null) {
+        segments2.push({
+          data: result[0],
+          index: result.index,
+          mode,
+          length: result[0].length
+        });
+      }
+      return segments2;
     }
-  }
-  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;
+    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 = [];
       }
-      acc.push(curr);
-      return acc;
-    }, []);
-  }
-  function buildNodes(segs) {
-    const nodes = [];
-    for (let i = 0; i < segs.length; i++) {
-      const seg = segs[i];
-      switch (seg.mode) {
+      const segs = numSegs.concat(alphaNumSegs, byteSegs, kanjiSegs);
+      return segs.sort(function(s1, s2) {
+        return s1.index - s2.index;
+      }).map(function(obj) {
+        return {
+          data: obj.data,
+          mode: obj.mode,
+          length: obj.length
+        };
+      });
+    }
+    function getSegmentBitsLength(length, mode) {
+      switch (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;
+          return NumericData.getBitsLength(length);
         case Mode.ALPHANUMERIC:
-          nodes.push([
-            seg,
-            { data: seg.data, mode: Mode.BYTE, length: seg.length }
-          ]);
-          break;
+          return AlphanumericData.getBitsLength(length);
         case Mode.KANJI:
-          nodes.push([
-            seg,
-            { data: seg.data, mode: Mode.BYTE, length: getStringByteLength(seg.data) }
-          ]);
-          break;
+          return KanjiData.getBitsLength(length);
         case Mode.BYTE:
-          nodes.push([
-            { data: seg.data, mode: Mode.BYTE, length: getStringByteLength(seg.data) }
-          ]);
+          return ByteData.getBitsLength(length);
       }
     }
-    return nodes;
-  }
-  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, 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);
-          }
+    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;
         }
-      }
-      prevNodeIds = currentNodeIds;
-    }
-    for (let n = 0; n < prevNodeIds.length; n++) {
-      graph[prevNodeIds[n]].end = 0;
-    }
-    return { map: graph, table };
-  }
-  function buildSingleSegment(data, modesHint) {
-    let mode2;
-    const bestMode = Mode.getBestModeForData(data);
-    mode2 = Mode.from(modesHint, bestMode);
-    if (mode2 !== Mode.BYTE && mode2.bit < bestMode.bit) {
-      throw new Error('"' + data + '" cannot be encoded with mode ' + Mode.toString(mode2) + ".\n Suggested mode is: " + Mode.toString(bestMode));
+        acc.push(curr);
+        return acc;
+      }, []);
     }
-    if (mode2 === Mode.KANJI && !Utils.isKanjiModeEnabled()) {
-      mode2 = Mode.BYTE;
+    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;
     }
-    switch (mode2) {
-      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);
+    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, 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);
+            }
+          }
+        }
+        prevNodeIds = currentNodeIds;
+      }
+      for (let n = 0; n < prevNodeIds.length; n++) {
+        graph[prevNodeIds[n]].end = 0;
+      }
+      return { map: graph, table };
     }
-  }
-  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));
+    function buildSingleSegment(data, modesHint) {
+      let mode;
+      const bestMode = Mode.getBestModeForData(data);
+      mode = Mode.from(modesHint, bestMode);
+      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));
+      }
+      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);
       }
-      return acc;
-    }, []);
-  };
-  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));
-  };
-  exports.rawSplit = function rawSplit(data) {
-    return exports.fromArray(
-      getSegmentsFromString(data, Utils.isKanjiModeEnabled())
-    );
-  };
-})(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;
+      }, []);
+    };
+    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));
+    };
+    exports.rawSplit = function rawSplit(data) {
+      return exports.fromArray(
+        getSegmentsFromString(data, Utils.isKanjiModeEnabled())
+      );
+    };
+  })(segments);
+  return segments;
+}
+export {
+  requireSegments as __require
+};
 //# sourceMappingURL=segments.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"segments.js","sources":["../../../../../../node_modules/qrcode/lib/core/segments.js"],"sourcesContent":["const Mode = require('./mode')\nconst NumericData = require('./numeric-data')\nconst AlphanumericData = require('./alphanumeric-data')\nconst ByteData = require('./byte-data')\nconst KanjiData = require('./kanji-data')\nconst Regex = require('./regex')\nconst Utils = require('./utils')\nconst dijkstra = require('dijkstrajs')\n\n/**\n * Returns UTF8 byte length\n *\n * @param  {String} str Input string\n * @return {Number}     Number of byte\n */\nfunction getStringByteLength (str) {\n  return unescape(encodeURIComponent(str)).length\n}\n\n/**\n * Get a list of segments of the specified mode\n * from a string\n *\n * @param  {Mode}   mode Segment mode\n * @param  {String} str  String to process\n * @return {Array}       Array of object with segments data\n */\nfunction getSegments (regex, mode, str) {\n  const segments = []\n  let result\n\n  while ((result = regex.exec(str)) !== null) {\n    segments.push({\n      data: result[0],\n      index: result.index,\n      mode: mode,\n      length: result[0].length\n    })\n  }\n\n  return segments\n}\n\n/**\n * Extracts a series of segments with the appropriate\n * modes from a string\n *\n * @param  {String} dataStr Input string\n * @return {Array}          Array of object with segments data\n */\nfunction getSegmentsFromString (dataStr) {\n  const numSegs = getSegments(Regex.NUMERIC, Mode.NUMERIC, dataStr)\n  const alphaNumSegs = getSegments(Regex.ALPHANUMERIC, Mode.ALPHANUMERIC, dataStr)\n  let byteSegs\n  let kanjiSegs\n\n  if (Utils.isKanjiModeEnabled()) {\n    byteSegs = getSegments(Regex.BYTE, Mode.BYTE, dataStr)\n    kanjiSegs = getSegments(Regex.KANJI, Mode.KANJI, dataStr)\n  } else {\n    byteSegs = getSegments(Regex.BYTE_KANJI, Mode.BYTE, dataStr)\n    kanjiSegs = []\n  }\n\n  const segs = numSegs.concat(alphaNumSegs, byteSegs, kanjiSegs)\n\n  return segs\n    .sort(function (s1, s2) {\n      return s1.index - s2.index\n    })\n    .map(function (obj) {\n      return {\n        data: obj.data,\n        mode: obj.mode,\n        length: obj.length\n      }\n    })\n}\n\n/**\n * Returns how many bits are needed to encode a string of\n * specified length with the specified mode\n *\n * @param  {Number} length String length\n * @param  {Mode} mode     Segment mode\n * @return {Number}        Bit length\n */\nfunction getSegmentBitsLength (length, mode) {\n  switch (mode) {\n    case Mode.NUMERIC:\n      return NumericData.getBitsLength(length)\n    case Mode.ALPHANUMERIC:\n      return AlphanumericData.getBitsLength(length)\n    case Mode.KANJI:\n      return KanjiData.getBitsLength(length)\n    case Mode.BYTE:\n      return ByteData.getBitsLength(length)\n  }\n}\n\n/**\n * Merges adjacent segments which have the same mode\n *\n * @param  {Array} segs Array of object with segments data\n * @return {Array}      Array of object with segments data\n */\nfunction mergeSegments (segs) {\n  return segs.reduce(function (acc, curr) {\n    const prevSeg = acc.length - 1 >= 0 ? acc[acc.length - 1] : null\n    if (prevSeg && prevSeg.mode === curr.mode) {\n      acc[acc.length - 1].data += curr.data\n      return acc\n    }\n\n    acc.push(curr)\n    return acc\n  }, [])\n}\n\n/**\n * Generates a list of all possible nodes combination which\n * will be used to build a segments graph.\n *\n * Nodes are divided by groups. Each group will contain a list of all the modes\n * in which is possible to encode the given text.\n *\n * For example the text '12345' can be encoded as Numeric, Alphanumeric or Byte.\n * The group for '12345' will contain then 3 objects, one for each\n * possible encoding mode.\n *\n * Each node represents a possible segment.\n *\n * @param  {Array} segs Array of object with segments data\n * @return {Array}      Array of object with segments data\n */\nfunction buildNodes (segs) {\n  const nodes = []\n  for (let i = 0; i < segs.length; i++) {\n    const seg = segs[i]\n\n    switch (seg.mode) {\n      case Mode.NUMERIC:\n        nodes.push([seg,\n          { data: seg.data, mode: Mode.ALPHANUMERIC, length: seg.length },\n          { data: seg.data, mode: Mode.BYTE, length: seg.length }\n        ])\n        break\n      case Mode.ALPHANUMERIC:\n        nodes.push([seg,\n          { data: seg.data, mode: Mode.BYTE, length: seg.length }\n        ])\n        break\n      case Mode.KANJI:\n        nodes.push([seg,\n          { data: seg.data, mode: Mode.BYTE, length: getStringByteLength(seg.data) }\n        ])\n        break\n      case Mode.BYTE:\n        nodes.push([\n          { data: seg.data, mode: Mode.BYTE, length: getStringByteLength(seg.data) }\n        ])\n    }\n  }\n\n  return nodes\n}\n\n/**\n * Builds a graph from a list of nodes.\n * All segments in each node group will be connected with all the segments of\n * the next group and so on.\n *\n * At each connection will be assigned a weight depending on the\n * segment's byte length.\n *\n * @param  {Array} nodes    Array of object with segments data\n * @param  {Number} version QR Code version\n * @return {Object}         Graph of all possible segments\n */\nfunction buildGraph (nodes, version) {\n  const table = {}\n  const graph = { start: {} }\n  let prevNodeIds = ['start']\n\n  for (let i = 0; i < nodes.length; i++) {\n    const nodeGroup = nodes[i]\n    const currentNodeIds = []\n\n    for (let j = 0; j < nodeGroup.length; j++) {\n      const node = nodeGroup[j]\n      const key = '' + i + j\n\n      currentNodeIds.push(key)\n      table[key] = { node: node, lastCount: 0 }\n      graph[key] = {}\n\n      for (let n = 0; n < prevNodeIds.length; n++) {\n        const prevNodeId = prevNodeIds[n]\n\n        if (table[prevNodeId] && table[prevNodeId].node.mode === node.mode) {\n          graph[prevNodeId][key] =\n            getSegmentBitsLength(table[prevNodeId].lastCount + node.length, node.mode) -\n            getSegmentBitsLength(table[prevNodeId].lastCount, node.mode)\n\n          table[prevNodeId].lastCount += node.length\n        } else {\n          if (table[prevNodeId]) table[prevNodeId].lastCount = node.length\n\n          graph[prevNodeId][key] = getSegmentBitsLength(node.length, node.mode) +\n            4 + Mode.getCharCountIndicator(node.mode, version) // switch cost\n        }\n      }\n    }\n\n    prevNodeIds = currentNodeIds\n  }\n\n  for (let n = 0; n < prevNodeIds.length; n++) {\n    graph[prevNodeIds[n]].end = 0\n  }\n\n  return { map: graph, table: table }\n}\n\n/**\n * Builds a segment from a specified data and mode.\n * If a mode is not specified, the more suitable will be used.\n *\n * @param  {String} data             Input data\n * @param  {Mode | String} modesHint Data mode\n * @return {Segment}                 Segment\n */\nfunction buildSingleSegment (data, modesHint) {\n  let mode\n  const bestMode = Mode.getBestModeForData(data)\n\n  mode = Mode.from(modesHint, bestMode)\n\n  // Make sure data can be encoded\n  if (mode !== Mode.BYTE && mode.bit < bestMode.bit) {\n    throw new Error('\"' + data + '\"' +\n      ' cannot be encoded with mode ' + Mode.toString(mode) +\n      '.\\n Suggested mode is: ' + Mode.toString(bestMode))\n  }\n\n  // Use Mode.BYTE if Kanji support is disabled\n  if (mode === Mode.KANJI && !Utils.isKanjiModeEnabled()) {\n    mode = Mode.BYTE\n  }\n\n  switch (mode) {\n    case Mode.NUMERIC:\n      return new NumericData(data)\n\n    case Mode.ALPHANUMERIC:\n      return new AlphanumericData(data)\n\n    case Mode.KANJI:\n      return new KanjiData(data)\n\n    case Mode.BYTE:\n      return new ByteData(data)\n  }\n}\n\n/**\n * Builds a list of segments from an array.\n * Array can contain Strings or Objects with segment's info.\n *\n * For each item which is a string, will be generated a segment with the given\n * string and the more appropriate encoding mode.\n *\n * For each item which is an object, will be generated a segment with the given\n * data and mode.\n * Objects must contain at least the property \"data\".\n * If property \"mode\" is not present, the more suitable mode will be used.\n *\n * @param  {Array} array Array of objects with segments data\n * @return {Array}       Array of Segments\n */\nexports.fromArray = function fromArray (array) {\n  return array.reduce(function (acc, seg) {\n    if (typeof seg === 'string') {\n      acc.push(buildSingleSegment(seg, null))\n    } else if (seg.data) {\n      acc.push(buildSingleSegment(seg.data, seg.mode))\n    }\n\n    return acc\n  }, [])\n}\n\n/**\n * Builds an optimized sequence of segments from a string,\n * which will produce the shortest possible bitstream.\n *\n * @param  {String} data    Input string\n * @param  {Number} version QR Code version\n * @return {Array}          Array of segments\n */\nexports.fromString = function fromString (data, version) {\n  const segs = getSegmentsFromString(data, Utils.isKanjiModeEnabled())\n\n  const nodes = buildNodes(segs)\n  const graph = buildGraph(nodes, version)\n  const path = dijkstra.find_path(graph.map, 'start', 'end')\n\n  const optimizedSegs = []\n  for (let i = 1; i < path.length - 1; i++) {\n    optimizedSegs.push(graph.table[path[i]].node)\n  }\n\n  return exports.fromArray(mergeSegments(optimizedSegs))\n}\n\n/**\n * Splits a string in various segments with the modes which\n * best represent their content.\n * The produced segments are far from being optimized.\n * The output of this function is only used to estimate a QR Code version\n * which may contain the data.\n *\n * @param  {string} data Input string\n * @return {Array}       Array of segments\n */\nexports.rawSplit = function rawSplit (data) {\n  return exports.fromArray(\n    getSegmentsFromString(data, Utils.isKanjiModeEnabled())\n  )\n}\n"],"names":["require$$0","require$$1","require$$2","require$$3","require$$4","require$$5","require$$6","require$$7","regex","mode","segments"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"segments.js","sources":["../../../../../../node_modules/qrcode/lib/core/segments.js"],"sourcesContent":["const Mode = require('./mode')\nconst NumericData = require('./numeric-data')\nconst AlphanumericData = require('./alphanumeric-data')\nconst ByteData = require('./byte-data')\nconst KanjiData = require('./kanji-data')\nconst Regex = require('./regex')\nconst Utils = require('./utils')\nconst dijkstra = require('dijkstrajs')\n\n/**\n * Returns UTF8 byte length\n *\n * @param  {String} str Input string\n * @return {Number}     Number of byte\n */\nfunction getStringByteLength (str) {\n  return unescape(encodeURIComponent(str)).length\n}\n\n/**\n * Get a list of segments of the specified mode\n * from a string\n *\n * @param  {Mode}   mode Segment mode\n * @param  {String} str  String to process\n * @return {Array}       Array of object with segments data\n */\nfunction getSegments (regex, mode, str) {\n  const segments = []\n  let result\n\n  while ((result = regex.exec(str)) !== null) {\n    segments.push({\n      data: result[0],\n      index: result.index,\n      mode: mode,\n      length: result[0].length\n    })\n  }\n\n  return segments\n}\n\n/**\n * Extracts a series of segments with the appropriate\n * modes from a string\n *\n * @param  {String} dataStr Input string\n * @return {Array}          Array of object with segments data\n */\nfunction getSegmentsFromString (dataStr) {\n  const numSegs = getSegments(Regex.NUMERIC, Mode.NUMERIC, dataStr)\n  const alphaNumSegs = getSegments(Regex.ALPHANUMERIC, Mode.ALPHANUMERIC, dataStr)\n  let byteSegs\n  let kanjiSegs\n\n  if (Utils.isKanjiModeEnabled()) {\n    byteSegs = getSegments(Regex.BYTE, Mode.BYTE, dataStr)\n    kanjiSegs = getSegments(Regex.KANJI, Mode.KANJI, dataStr)\n  } else {\n    byteSegs = getSegments(Regex.BYTE_KANJI, Mode.BYTE, dataStr)\n    kanjiSegs = []\n  }\n\n  const segs = numSegs.concat(alphaNumSegs, byteSegs, kanjiSegs)\n\n  return segs\n    .sort(function (s1, s2) {\n      return s1.index - s2.index\n    })\n    .map(function (obj) {\n      return {\n        data: obj.data,\n        mode: obj.mode,\n        length: obj.length\n      }\n    })\n}\n\n/**\n * Returns how many bits are needed to encode a string of\n * specified length with the specified mode\n *\n * @param  {Number} length String length\n * @param  {Mode} mode     Segment mode\n * @return {Number}        Bit length\n */\nfunction getSegmentBitsLength (length, mode) {\n  switch (mode) {\n    case Mode.NUMERIC:\n      return NumericData.getBitsLength(length)\n    case Mode.ALPHANUMERIC:\n      return AlphanumericData.getBitsLength(length)\n    case Mode.KANJI:\n      return KanjiData.getBitsLength(length)\n    case Mode.BYTE:\n      return ByteData.getBitsLength(length)\n  }\n}\n\n/**\n * Merges adjacent segments which have the same mode\n *\n * @param  {Array} segs Array of object with segments data\n * @return {Array}      Array of object with segments data\n */\nfunction mergeSegments (segs) {\n  return segs.reduce(function (acc, curr) {\n    const prevSeg = acc.length - 1 >= 0 ? acc[acc.length - 1] : null\n    if (prevSeg && prevSeg.mode === curr.mode) {\n      acc[acc.length - 1].data += curr.data\n      return acc\n    }\n\n    acc.push(curr)\n    return acc\n  }, [])\n}\n\n/**\n * Generates a list of all possible nodes combination which\n * will be used to build a segments graph.\n *\n * Nodes are divided by groups. Each group will contain a list of all the modes\n * in which is possible to encode the given text.\n *\n * For example the text '12345' can be encoded as Numeric, Alphanumeric or Byte.\n * The group for '12345' will contain then 3 objects, one for each\n * possible encoding mode.\n *\n * Each node represents a possible segment.\n *\n * @param  {Array} segs Array of object with segments data\n * @return {Array}      Array of object with segments data\n */\nfunction buildNodes (segs) {\n  const nodes = []\n  for (let i = 0; i < segs.length; i++) {\n    const seg = segs[i]\n\n    switch (seg.mode) {\n      case Mode.NUMERIC:\n        nodes.push([seg,\n          { data: seg.data, mode: Mode.ALPHANUMERIC, length: seg.length },\n          { data: seg.data, mode: Mode.BYTE, length: seg.length }\n        ])\n        break\n      case Mode.ALPHANUMERIC:\n        nodes.push([seg,\n          { data: seg.data, mode: Mode.BYTE, length: seg.length }\n        ])\n        break\n      case Mode.KANJI:\n        nodes.push([seg,\n          { data: seg.data, mode: Mode.BYTE, length: getStringByteLength(seg.data) }\n        ])\n        break\n      case Mode.BYTE:\n        nodes.push([\n          { data: seg.data, mode: Mode.BYTE, length: getStringByteLength(seg.data) }\n        ])\n    }\n  }\n\n  return nodes\n}\n\n/**\n * Builds a graph from a list of nodes.\n * All segments in each node group will be connected with all the segments of\n * the next group and so on.\n *\n * At each connection will be assigned a weight depending on the\n * segment's byte length.\n *\n * @param  {Array} nodes    Array of object with segments data\n * @param  {Number} version QR Code version\n * @return {Object}         Graph of all possible segments\n */\nfunction buildGraph (nodes, version) {\n  const table = {}\n  const graph = { start: {} }\n  let prevNodeIds = ['start']\n\n  for (let i = 0; i < nodes.length; i++) {\n    const nodeGroup = nodes[i]\n    const currentNodeIds = []\n\n    for (let j = 0; j < nodeGroup.length; j++) {\n      const node = nodeGroup[j]\n      const key = '' + i + j\n\n      currentNodeIds.push(key)\n      table[key] = { node: node, lastCount: 0 }\n      graph[key] = {}\n\n      for (let n = 0; n < prevNodeIds.length; n++) {\n        const prevNodeId = prevNodeIds[n]\n\n        if (table[prevNodeId] && table[prevNodeId].node.mode === node.mode) {\n          graph[prevNodeId][key] =\n            getSegmentBitsLength(table[prevNodeId].lastCount + node.length, node.mode) -\n            getSegmentBitsLength(table[prevNodeId].lastCount, node.mode)\n\n          table[prevNodeId].lastCount += node.length\n        } else {\n          if (table[prevNodeId]) table[prevNodeId].lastCount = node.length\n\n          graph[prevNodeId][key] = getSegmentBitsLength(node.length, node.mode) +\n            4 + Mode.getCharCountIndicator(node.mode, version) // switch cost\n        }\n      }\n    }\n\n    prevNodeIds = currentNodeIds\n  }\n\n  for (let n = 0; n < prevNodeIds.length; n++) {\n    graph[prevNodeIds[n]].end = 0\n  }\n\n  return { map: graph, table: table }\n}\n\n/**\n * Builds a segment from a specified data and mode.\n * If a mode is not specified, the more suitable will be used.\n *\n * @param  {String} data             Input data\n * @param  {Mode | String} modesHint Data mode\n * @return {Segment}                 Segment\n */\nfunction buildSingleSegment (data, modesHint) {\n  let mode\n  const bestMode = Mode.getBestModeForData(data)\n\n  mode = Mode.from(modesHint, bestMode)\n\n  // Make sure data can be encoded\n  if (mode !== Mode.BYTE && mode.bit < bestMode.bit) {\n    throw new Error('\"' + data + '\"' +\n      ' cannot be encoded with mode ' + Mode.toString(mode) +\n      '.\\n Suggested mode is: ' + Mode.toString(bestMode))\n  }\n\n  // Use Mode.BYTE if Kanji support is disabled\n  if (mode === Mode.KANJI && !Utils.isKanjiModeEnabled()) {\n    mode = Mode.BYTE\n  }\n\n  switch (mode) {\n    case Mode.NUMERIC:\n      return new NumericData(data)\n\n    case Mode.ALPHANUMERIC:\n      return new AlphanumericData(data)\n\n    case Mode.KANJI:\n      return new KanjiData(data)\n\n    case Mode.BYTE:\n      return new ByteData(data)\n  }\n}\n\n/**\n * Builds a list of segments from an array.\n * Array can contain Strings or Objects with segment's info.\n *\n * For each item which is a string, will be generated a segment with the given\n * string and the more appropriate encoding mode.\n *\n * For each item which is an object, will be generated a segment with the given\n * data and mode.\n * Objects must contain at least the property \"data\".\n * If property \"mode\" is not present, the more suitable mode will be used.\n *\n * @param  {Array} array Array of objects with segments data\n * @return {Array}       Array of Segments\n */\nexports.fromArray = function fromArray (array) {\n  return array.reduce(function (acc, seg) {\n    if (typeof seg === 'string') {\n      acc.push(buildSingleSegment(seg, null))\n    } else if (seg.data) {\n      acc.push(buildSingleSegment(seg.data, seg.mode))\n    }\n\n    return acc\n  }, [])\n}\n\n/**\n * Builds an optimized sequence of segments from a string,\n * which will produce the shortest possible bitstream.\n *\n * @param  {String} data    Input string\n * @param  {Number} version QR Code version\n * @return {Array}          Array of segments\n */\nexports.fromString = function fromString (data, version) {\n  const segs = getSegmentsFromString(data, Utils.isKanjiModeEnabled())\n\n  const nodes = buildNodes(segs)\n  const graph = buildGraph(nodes, version)\n  const path = dijkstra.find_path(graph.map, 'start', 'end')\n\n  const optimizedSegs = []\n  for (let i = 1; i < path.length - 1; i++) {\n    optimizedSegs.push(graph.table[path[i]].node)\n  }\n\n  return exports.fromArray(mergeSegments(optimizedSegs))\n}\n\n/**\n * Splits a string in various segments with the modes which\n * best represent their content.\n * The produced segments are far from being optimized.\n * The output of this function is only used to estimate a QR Code version\n * which may contain the data.\n *\n * @param  {string} data Input string\n * @return {Array}       Array of segments\n */\nexports.rawSplit = function rawSplit (data) {\n  return exports.fromArray(\n    getSegmentsFromString(data, Utils.isKanjiModeEnabled())\n  )\n}\n"],"names":["require$$0","require$$1","require$$2","require$$3","require$$4","require$$5","require$$6","require$$7","segments"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/qrcode/lib/core/utils.cjs

@@ -1,78 +1,84 @@
 "use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const utils = require("../../../../_virtual/utils.cjs");
-let toSJISFunction;
-const CODEWORDS_COUNT = [
-  0,
-  // Not used
-  26,
-  44,
-  70,
-  100,
-  134,
-  172,
-  196,
-  242,
-  292,
-  346,
-  404,
-  466,
-  532,
-  581,
-  655,
-  733,
-  815,
-  901,
-  991,
-  1085,
-  1156,
-  1258,
-  1364,
-  1474,
-  1588,
-  1706,
-  1828,
-  1921,
-  2051,
-  2185,
-  2323,
-  2465,
-  2611,
-  2761,
-  2876,
-  3034,
-  3196,
-  3362,
-  3532,
-  3706
-];
-utils.__exports.getSymbolSize = function getSymbolSize(version) {
-  if (!version) throw new Error('"version" cannot be null or undefined');
-  if (version < 1 || version > 40) throw new Error('"version" should be in range from 1 to 40');
-  return version * 4 + 17;
-};
-utils.__exports.getSymbolTotalCodewords = function getSymbolTotalCodewords(version) {
-  return CODEWORDS_COUNT[version];
-};
-utils.__exports.getBCHDigit = function(data) {
-  let digit = 0;
-  while (data !== 0) {
-    digit++;
-    data >>>= 1;
-  }
-  return digit;
-};
-utils.__exports.setToSJISFunction = function setToSJISFunction(f) {
-  if (typeof f !== "function") {
-    throw new Error('"toSJISFunc" is not a valid function.');
-  }
-  toSJISFunction = f;
-};
-utils.__exports.isKanjiModeEnabled = function() {
-  return typeof toSJISFunction !== "undefined";
-};
-utils.__exports.toSJIS = function toSJIS(kanji) {
-  return toSJISFunction(kanji);
-};
-exports.default = utils.__exports;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("../../../../_virtual/utils2.cjs");
+var hasRequiredUtils;
+function requireUtils() {
+  if (hasRequiredUtils) return utils.__exports;
+  hasRequiredUtils = 1;
+  let toSJISFunction;
+  const CODEWORDS_COUNT = [
+    0,
+    // Not used
+    26,
+    44,
+    70,
+    100,
+    134,
+    172,
+    196,
+    242,
+    292,
+    346,
+    404,
+    466,
+    532,
+    581,
+    655,
+    733,
+    815,
+    901,
+    991,
+    1085,
+    1156,
+    1258,
+    1364,
+    1474,
+    1588,
+    1706,
+    1828,
+    1921,
+    2051,
+    2185,
+    2323,
+    2465,
+    2611,
+    2761,
+    2876,
+    3034,
+    3196,
+    3362,
+    3532,
+    3706
+  ];
+  utils.__exports.getSymbolSize = function getSymbolSize(version) {
+    if (!version) throw new Error('"version" cannot be null or undefined');
+    if (version < 1 || version > 40) throw new Error('"version" should be in range from 1 to 40');
+    return version * 4 + 17;
+  };
+  utils.__exports.getSymbolTotalCodewords = function getSymbolTotalCodewords(version) {
+    return CODEWORDS_COUNT[version];
+  };
+  utils.__exports.getBCHDigit = function(data) {
+    let digit = 0;
+    while (data !== 0) {
+      digit++;
+      data >>>= 1;
+    }
+    return digit;
+  };
+  utils.__exports.setToSJISFunction = function setToSJISFunction(f) {
+    if (typeof f !== "function") {
+      throw new Error('"toSJISFunc" is not a valid function.');
+    }
+    toSJISFunction = f;
+  };
+  utils.__exports.isKanjiModeEnabled = function() {
+    return typeof toSJISFunction !== "undefined";
+  };
+  utils.__exports.toSJIS = function toSJIS(kanji) {
+    return toSJISFunction(kanji);
+  };
+  return utils.__exports;
+}
+exports.__require = requireUtils;
 //# sourceMappingURL=utils.cjs.map

package/dist/node_modules/qrcode/lib/core/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.cjs","sources":["../../../../../../node_modules/qrcode/lib/core/utils.js"],"sourcesContent":["let toSJISFunction\nconst CODEWORDS_COUNT = [\n  0, // Not used\n  26, 44, 70, 100, 134, 172, 196, 242, 292, 346,\n  404, 466, 532, 581, 655, 733, 815, 901, 991, 1085,\n  1156, 1258, 1364, 1474, 1588, 1706, 1828, 1921, 2051, 2185,\n  2323, 2465, 2611, 2761, 2876, 3034, 3196, 3362, 3532, 3706\n]\n\n/**\n * Returns the QR Code size for the specified version\n *\n * @param  {Number} version QR Code version\n * @return {Number}         size of QR code\n */\nexports.getSymbolSize = function getSymbolSize (version) {\n  if (!version) throw new Error('\"version\" cannot be null or undefined')\n  if (version < 1 || version > 40) throw new Error('\"version\" should be in range from 1 to 40')\n  return version * 4 + 17\n}\n\n/**\n * Returns the total number of codewords used to store data and EC information.\n *\n * @param  {Number} version QR Code version\n * @return {Number}         Data length in bits\n */\nexports.getSymbolTotalCodewords = function getSymbolTotalCodewords (version) {\n  return CODEWORDS_COUNT[version]\n}\n\n/**\n * Encode data with Bose-Chaudhuri-Hocquenghem\n *\n * @param  {Number} data Value to encode\n * @return {Number}      Encoded value\n */\nexports.getBCHDigit = function (data) {\n  let digit = 0\n\n  while (data !== 0) {\n    digit++\n    data >>>= 1\n  }\n\n  return digit\n}\n\nexports.setToSJISFunction = function setToSJISFunction (f) {\n  if (typeof f !== 'function') {\n    throw new Error('\"toSJISFunc\" is not a valid function.')\n  }\n\n  toSJISFunction = f\n}\n\nexports.isKanjiModeEnabled = function () {\n  return typeof toSJISFunction !== 'undefined'\n}\n\nexports.toSJIS = function toSJIS (kanji) {\n  return toSJISFunction(kanji)\n}\n"],"names":["utils"],"mappings":";;;AAAA,IAAI;AACJ,MAAM,kBAAkB;AAAA,EACtB;AAAA;AAAA,EACA;AAAA,EAAI;AAAA,EAAI;AAAA,EAAI;AAAA,EAAK;AAAA,EAAK;AAAA,EAAK;AAAA,EAAK;AAAA,EAAK;AAAA,EAAK;AAAA,EAC1C;AAAA,EAAK;AAAA,EAAK;AAAA,EAAK;AAAA,EAAK;AAAA,EAAK;AAAA,EAAK;AAAA,EAAK;AAAA,EAAK;AAAA,EAAK;AAAA,EAC7C;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EACtD;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AAAA,EAAM;AACxD;AAQAA,MAAAA,UAAA,gBAAwB,SAAS,cAAe,SAAS;AACvD,MAAI,CAAC,QAAS,OAAM,IAAI,MAAM,uCAAuC;AACrE,MAAI,UAAU,KAAK,UAAU,GAAI,OAAM,IAAI,MAAM,2CAA2C;AAC5F,SAAO,UAAU,IAAI;AACvB;AAQAA,MAAAA,UAAA,0BAAkC,SAAS,wBAAyB,SAAS;AAC3E,SAAO,gBAAgB,OAAO;AAChC;AAQmBA,MAAAA,UAAA,cAAG,SAAU,MAAM;AACpC,MAAI,QAAQ;AAEZ,SAAO,SAAS,GAAG;AACjB;AACA,cAAU;AAAA,EACX;AAED,SAAO;AACT;AAEAA,MAAAA,UAAA,oBAA4B,SAAS,kBAAmB,GAAG;AACzD,MAAI,OAAO,MAAM,YAAY;AAC3B,UAAM,IAAI,MAAM,uCAAuC;AAAA,EACxD;AAED,mBAAiB;AACnB;AAEAA,MAAA,UAAA,qBAA6B,WAAY;AACvC,SAAO,OAAO,mBAAmB;AACnC;AAEAA,MAAAA,UAAA,SAAiB,SAAS,OAAQ,OAAO;AACvC,SAAO,eAAe,KAAK;AAC7B;;","x_google_ignoreList":[0]}
+{"version":3,"file":"utils.cjs","sources":["../../../../../../node_modules/qrcode/lib/core/utils.js"],"sourcesContent":["let toSJISFunction\nconst CODEWORDS_COUNT = [\n  0, // Not used\n  26, 44, 70, 100, 134, 172, 196, 242, 292, 346,\n  404, 466, 532, 581, 655, 733, 815, 901, 991, 1085,\n  1156, 1258, 1364, 1474, 1588, 1706, 1828, 1921, 2051, 2185,\n  2323, 2465, 2611, 2761, 2876, 3034, 3196, 3362, 3532, 3706\n]\n\n/**\n * Returns the QR Code size for the specified version\n *\n * @param  {Number} version QR Code version\n * @return {Number}         size of QR code\n */\nexports.getSymbolSize = function getSymbolSize (version) {\n  if (!version) throw new Error('\"version\" cannot be null or undefined')\n  if (version < 1 || version > 40) throw new Error('\"version\" should be in range from 1 to 40')\n  return version * 4 + 17\n}\n\n/**\n * Returns the total number of codewords used to store data and EC information.\n *\n * @param  {Number} version QR Code version\n * @return {Number}         Data length in bits\n */\nexports.getSymbolTotalCodewords = function getSymbolTotalCodewords (version) {\n  return CODEWORDS_COUNT[version]\n}\n\n/**\n * Encode data with Bose-Chaudhuri-Hocquenghem\n *\n * @param  {Number} data Value to encode\n * @return {Number}      Encoded value\n */\nexports.getBCHDigit = function (data) {\n  let digit = 0\n\n  while (data !== 0) {\n    digit++\n    data >>>= 1\n  }\n\n  return digit\n}\n\nexports.setToSJISFunction = function setToSJISFunction (f) {\n  if (typeof f !== 'function') {\n    throw new Error('\"toSJISFunc\" is not a valid function.')\n  }\n\n  toSJISFunction = f\n}\n\nexports.isKanjiModeEnabled = function () {\n  return typeof toSJISFunction !== 'undefined'\n}\n\nexports.toSJIS = function toSJIS (kanji) {\n  return toSJISFunction(kanji)\n}\n"],"names":["utils"],"mappings":";;;;;;;AAAA,MAAI;AACJ,QAAM,kBAAkB;AAAA,IACtB;AAAA;AAAA,IACA;AAAA,IAAI;AAAA,IAAI;AAAA,IAAI;AAAA,IAAK;AAAA,IAAK;AAAA,IAAK;AAAA,IAAK;AAAA,IAAK;AAAA,IAAK;AAAA,IAC1C;AAAA,IAAK;AAAA,IAAK;AAAA,IAAK;AAAA,IAAK;AAAA,IAAK;AAAA,IAAK;AAAA,IAAK;AAAA,IAAK;AAAA,IAAK;AAAA,IAC7C;AAAA,IAAM;AAAA,IAAM;AAAA,IAAM;AAAA,IAAM;AAAA,IAAM;AAAA,IAAM;AAAA,IAAM;AAAA,IAAM;AAAA,IAAM;AAAA,IACtD;AAAA,IAAM;AAAA,IAAM;AAAA,IAAM;AAAA,IAAM;AAAA,IAAM;AAAA,IAAM;AAAA,IAAM;AAAA,IAAM;AAAA,IAAM;AAAA,EACxD;AAQAA,QAAAA,UAAA,gBAAwB,SAAS,cAAe,SAAS;AACvD,QAAI,CAAC,QAAS,OAAM,IAAI,MAAM,uCAAuC;AACrE,QAAI,UAAU,KAAK,UAAU,GAAI,OAAM,IAAI,MAAM,2CAA2C;AAC5F,WAAO,UAAU,IAAI;AAAA,EACvB;AAQAA,QAAAA,UAAA,0BAAkC,SAAS,wBAAyB,SAAS;AAC3E,WAAO,gBAAgB,OAAO;AAAA,EAChC;AAQmBA,kBAAA,cAAG,SAAU,MAAM;AACpC,QAAI,QAAQ;AAEZ,WAAO,SAAS,GAAG;AACjB;AACA,gBAAU;AAAA,IACd;AAEE,WAAO;AAAA,EACT;AAEAA,QAAAA,UAAA,oBAA4B,SAAS,kBAAmB,GAAG;AACzD,QAAI,OAAO,MAAM,YAAY;AAC3B,YAAM,IAAI,MAAM,uCAAuC;AAAA,IAC3D;AAEE,qBAAiB;AAAA,EACnB;AAEAA,QAAA,UAAA,qBAA6B,WAAY;AACvC,WAAO,OAAO,mBAAmB;AAAA,EACnC;AAEAA,QAAAA,UAAA,SAAiB,SAAS,OAAQ,OAAO;AACvC,WAAO,eAAe,KAAK;AAAA,EAC7B;;;;","x_google_ignoreList":[0]}