@ozdao/prometheus-framework 0.2.330 → 0.2.332

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

@@ -1,196 +1,201 @@
 "use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const segments = require("../../../../_virtual/segments.cjs");
-require("./mode.cjs");
+const mode = require("./mode.cjs");
 const numericData = require("./numeric-data.cjs");
 const alphanumericData = require("./alphanumeric-data.cjs");
 const byteData = require("./byte-data.cjs");
 const kanjiData = require("./kanji-data.cjs");
-require("./regex.cjs");
-require("./utils.cjs");
+const regex = require("./regex.cjs");
+const utils = require("./utils.cjs");
 const dijkstra = require("../../../dijkstrajs/dijkstra.cjs");
-const utils = require("../../../../_virtual/utils.cjs");
-const mode = require("../../../../_virtual/mode.cjs");
-const regex = require("../../../../_virtual/regex.cjs");
-(function(exports2) {
-  const Mode = mode.__exports;
-  const NumericData = numericData.numericData;
-  const AlphanumericData = alphanumericData.alphanumericData;
-  const ByteData = byteData.byteData;
-  const KanjiData = kanjiData.kanjiData;
-  const Regex = regex.__exports;
-  const Utils = utils.__exports;
-  const dijkstra$1 = 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 = [];
+var hasRequiredSegments;
+function requireSegments() {
+  if (hasRequiredSegments) return segments.__exports;
+  hasRequiredSegments = 1;
+  (function(exports2) {
+    const Mode = mode.__require();
+    const NumericData = numericData.__require();
+    const AlphanumericData = alphanumericData.__require();
+    const ByteData = byteData.__require();
+    const KanjiData = kanjiData.__require();
+    const Regex = regex.__require();
+    const Utils = utils.__require();
+    const dijkstra$1 = dijkstra.__require();
+    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(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 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, mode2) {
+      switch (mode2) {
         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 };
     }
-  }
-  exports2.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 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));
+      }
+      if (mode2 === Mode.KANJI && !Utils.isKanjiModeEnabled()) {
+        mode2 = Mode.BYTE;
+      }
+      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);
       }
-      return acc;
-    }, []);
-  };
-  exports2.fromString = function fromString(data, version) {
-    const segs = getSegmentsFromString(data, Utils.isKanjiModeEnabled());
-    const nodes = buildNodes(segs);
-    const graph = buildGraph(nodes, version);
-    const path = dijkstra$1.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 exports2.fromArray(mergeSegments(optimizedSegs));
-  };
-  exports2.rawSplit = function rawSplit(data) {
-    return exports2.fromArray(
-      getSegmentsFromString(data, Utils.isKanjiModeEnabled())
-    );
-  };
-})(segments.__exports);
+    exports2.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;
+      }, []);
+    };
+    exports2.fromString = function fromString(data, version) {
+      const segs = getSegmentsFromString(data, Utils.isKanjiModeEnabled());
+      const nodes = buildNodes(segs);
+      const graph = buildGraph(nodes, version);
+      const path = dijkstra$1.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 exports2.fromArray(mergeSegments(optimizedSegs));
+    };
+    exports2.rawSplit = function rawSplit(data) {
+      return exports2.fromArray(
+        getSegmentsFromString(data, Utils.isKanjiModeEnabled())
+      );
+    };
+  })(segments.__exports);
+  return segments.__exports;
+}
+exports.__require = requireSegments;
 //# sourceMappingURL=segments.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"segments.cjs","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","dijkstra","require$$7","regex","mode","segments","exports"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"segments.cjs","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","dijkstra","require$$7","regex","mode","segments","exports"],"mappings":"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","x_google_ignoreList":[0]}