@ozdao/prometheus-framework 0.2.198 → 0.2.200

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

@@ -1,24 +1,27 @@
-import { __exports as u } from "../../../../_virtual/regex.js";
-const r = "[0-9]+", E = "[A-Z $%*+\\-./:]+";
-let t = "(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+";
-t = t.replace(/u/g, "\\u");
-const s = "(?:(?![A-Z0-9 $%*+\\-./:]|" + t + `)(?:.|[\r
-]))+`;
-u.KANJI = new RegExp(t, "g");
-u.BYTE_KANJI = new RegExp("[^A-Z0-9 $%*+\\-./:]+", "g");
-u.BYTE = new RegExp(s, "g");
-u.NUMERIC = new RegExp(r, "g");
-u.ALPHANUMERIC = new RegExp(E, "g");
-const A = new RegExp("^" + t + "$"), c = new RegExp("^" + r + "$"), g = new RegExp("^[A-Z0-9 $%*+\\-./:]+$");
-u.testKanji = function(e) {
-  return A.test(e);
+import { __exports as regex } from "../../../../_virtual/regex.js";
+const numeric = "[0-9]+";
+const alphanumeric = "[A-Z $%*+\\-./:]+";
+let kanji = "(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+";
+kanji = kanji.replace(/u/g, "\\u");
+const byte = "(?:(?![A-Z0-9 $%*+\\-./:]|" + kanji + ")(?:.|[\r\n]))+";
+regex.KANJI = new RegExp(kanji, "g");
+regex.BYTE_KANJI = new RegExp("[^A-Z0-9 $%*+\\-./:]+", "g");
+regex.BYTE = new RegExp(byte, "g");
+regex.NUMERIC = new RegExp(numeric, "g");
+regex.ALPHANUMERIC = new RegExp(alphanumeric, "g");
+const TEST_KANJI = new RegExp("^" + kanji + "$");
+const TEST_NUMERIC = new RegExp("^" + numeric + "$");
+const TEST_ALPHANUMERIC = new RegExp("^[A-Z0-9 $%*+\\-./:]+$");
+regex.testKanji = function testKanji(str) {
+  return TEST_KANJI.test(str);
 };
-u.testNumeric = function(e) {
-  return c.test(e);
+regex.testNumeric = function testNumeric(str) {
+  return TEST_NUMERIC.test(str);
 };
-u.testAlphanumeric = function(e) {
-  return g.test(e);
+regex.testAlphanumeric = function testAlphanumeric(str) {
+  return TEST_ALPHANUMERIC.test(str);
 };
 export {
-  u as default
+  regex as default
 };
+//# sourceMappingURL=regex.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"regex.js","sources":["../../../../../../node_modules/qrcode/lib/core/regex.js"],"sourcesContent":["const numeric = '[0-9]+'\nconst alphanumeric = '[A-Z $%*+\\\\-./:]+'\nlet kanji = '(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|' +\n  '[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|' +\n  '[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|' +\n  '[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+'\nkanji = kanji.replace(/u/g, '\\\\u')\n\nconst byte = '(?:(?![A-Z0-9 $%*+\\\\-./:]|' + kanji + ')(?:.|[\\r\\n]))+'\n\nexports.KANJI = new RegExp(kanji, 'g')\nexports.BYTE_KANJI = new RegExp('[^A-Z0-9 $%*+\\\\-./:]+', 'g')\nexports.BYTE = new RegExp(byte, 'g')\nexports.NUMERIC = new RegExp(numeric, 'g')\nexports.ALPHANUMERIC = new RegExp(alphanumeric, 'g')\n\nconst TEST_KANJI = new RegExp('^' + kanji + '$')\nconst TEST_NUMERIC = new RegExp('^' + numeric + '$')\nconst TEST_ALPHANUMERIC = new RegExp('^[A-Z0-9 $%*+\\\\-./:]+$')\n\nexports.testKanji = function testKanji (str) {\n  return TEST_KANJI.test(str)\n}\n\nexports.testNumeric = function testNumeric (str) {\n  return TEST_NUMERIC.test(str)\n}\n\nexports.testAlphanumeric = function testAlphanumeric (str) {\n  return TEST_ALPHANUMERIC.test(str)\n}\n"],"names":[],"mappings":";AAAA,MAAM,UAAU;AAChB,MAAM,eAAe;AACrB,IAAI,QAAQ;AAIZ,QAAQ,MAAM,QAAQ,MAAM,KAAK;AAEjC,MAAM,OAAO,+BAA+B,QAAQ;AAEpD,MAAA,QAAgB,IAAI,OAAO,OAAO,GAAG;AACrC,MAAA,aAAqB,IAAI,OAAO,yBAAyB,GAAG;AAC5D,MAAA,OAAe,IAAI,OAAO,MAAM,GAAG;AACnC,MAAA,UAAkB,IAAI,OAAO,SAAS,GAAG;AACzC,MAAA,eAAuB,IAAI,OAAO,cAAc,GAAG;AAEnD,MAAM,aAAa,IAAI,OAAO,MAAM,QAAQ,GAAG;AAC/C,MAAM,eAAe,IAAI,OAAO,MAAM,UAAU,GAAG;AACnD,MAAM,oBAAoB,IAAI,OAAO,wBAAwB;AAE7D,MAAA,YAAoB,SAAS,UAAW,KAAK;AAC3C,SAAO,WAAW,KAAK,GAAG;AAC5B;AAEA,MAAA,cAAsB,SAAS,YAAa,KAAK;AAC/C,SAAO,aAAa,KAAK,GAAG;AAC9B;AAEA,MAAA,mBAA2B,SAAS,iBAAkB,KAAK;AACzD,SAAO,kBAAkB,KAAK,GAAG;AACnC;","x_google_ignoreList":[0]}

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

@@ -1,2 +1,196 @@
-"use strict";const U=require("../../../../_virtual/segments.cjs");require("./mode.cjs");const Y=require("./numeric-data.cjs"),q=require("./alphanumeric-data.cjs"),K=require("./byte-data.cjs"),L=require("./kanji-data.cjs");require("./regex.cjs");require("./utils.cjs");const y=require("../../../dijkstrajs/dijkstra.cjs"),j=require("../../../../_virtual/utils.cjs"),k=require("../../../../_virtual/mode.cjs"),_=require("../../../../_virtual/regex.cjs");(function(g){const r=k.__exports,N=Y.numericData,I=q.alphanumericData,B=K.byteData,C=L.kanjiData,h=_.__exports,p=j.__exports,w=y.dijkstraExports;function b(n){return unescape(encodeURIComponent(n)).length}function m(n,o,t){const e=[];let s;for(;(s=n.exec(t))!==null;)e.push({data:s[0],index:s.index,mode:o,length:s[0].length});return e}function M(n){const o=m(h.NUMERIC,r.NUMERIC,n),t=m(h.ALPHANUMERIC,r.ALPHANUMERIC,n);let e,s;return p.isKanjiModeEnabled()?(e=m(h.BYTE,r.BYTE,n),s=m(h.KANJI,r.KANJI,n)):(e=m(h.BYTE_KANJI,r.BYTE,n),s=[]),o.concat(t,e,s).sort(function(i,c){return i.index-c.index}).map(function(i){return{data:i.data,mode:i.mode,length:i.length}})}function E(n,o){switch(o){case r.NUMERIC:return N.getBitsLength(n);case r.ALPHANUMERIC:return I.getBitsLength(n);case r.KANJI:return C.getBitsLength(n);case r.BYTE:return B.getBitsLength(n)}}function D(n){return n.reduce(function(o,t){const e=o.length-1>=0?o[o.length-1]:null;return e&&e.mode===t.mode?(o[o.length-1].data+=t.data,o):(o.push(t),o)},[])}function R(n){const o=[];for(let t=0;t<n.length;t++){const e=n[t];switch(e.mode){case r.NUMERIC:o.push([e,{data:e.data,mode:r.ALPHANUMERIC,length:e.length},{data:e.data,mode:r.BYTE,length:e.length}]);break;case r.ALPHANUMERIC:o.push([e,{data:e.data,mode:r.BYTE,length:e.length}]);break;case r.KANJI:o.push([e,{data:e.data,mode:r.BYTE,length:b(e.data)}]);break;case r.BYTE:o.push([{data:e.data,mode:r.BYTE,length:b(e.data)}])}}return o}function T(n,o){const t={},e={start:{}};let s=["start"];for(let a=0;a<n.length;a++){const i=n[a],c=[];for(let l=0;l<i.length;l++){const u=i[l],f=""+a+l;c.push(f),t[f]={node:u,lastCount:0},e[f]={};for(let A=0;A<s.length;A++){const d=s[A];t[d]&&t[d].node.mode===u.mode?(e[d][f]=E(t[d].lastCount+u.length,u.mode)-E(t[d].lastCount,u.mode),t[d].lastCount+=u.length):(t[d]&&(t[d].lastCount=u.length),e[d][f]=E(u.length,u.mode)+4+r.getCharCountIndicator(u.mode,o))}}s=c}for(let a=0;a<s.length;a++)e[s[a]].end=0;return{map:e,table:t}}function S(n,o){let t;const e=r.getBestModeForData(n);if(t=r.from(o,e),t!==r.BYTE&&t.bit<e.bit)throw new Error('"'+n+'" cannot be encoded with mode '+r.toString(t)+`.
- Suggested mode is: `+r.toString(e));switch(t===r.KANJI&&!p.isKanjiModeEnabled()&&(t=r.BYTE),t){case r.NUMERIC:return new N(n);case r.ALPHANUMERIC:return new I(n);case r.KANJI:return new C(n);case r.BYTE:return new B(n)}}g.fromArray=function(o){return o.reduce(function(t,e){return typeof e=="string"?t.push(S(e,null)):e.data&&t.push(S(e.data,e.mode)),t},[])},g.fromString=function(o,t){const e=M(o,p.isKanjiModeEnabled()),s=R(e),a=T(s,t),i=w.find_path(a.map,"start","end"),c=[];for(let l=1;l<i.length-1;l++)c.push(a.table[i[l]].node);return g.fromArray(D(c))},g.rawSplit=function(o){return g.fromArray(M(o,p.isKanjiModeEnabled()))}})(U.__exports);
+"use strict";
+const segments = require("../../../../_virtual/segments.cjs");
+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 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 = [];
+    }
+    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 mergeSegments(segs) {
+    return segs.reduce(function(acc, curr) {
+      const prevSeg = acc.length - 1 >= 0 ? acc[acc.length - 1] : null;
+      if (prevSeg && prevSeg.mode === curr.mode) {
+        acc[acc.length - 1].data += curr.data;
+        return acc;
+      }
+      acc.push(curr);
+      return acc;
+    }, []);
+  }
+  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;
+  }
+  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 };
+  }
+  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);
+    }
+  }
+  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);
+//# sourceMappingURL=segments.cjs.map

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

@@ -0,0 +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]}

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

@@ -1,143 +1,195 @@
-import { __exports as Y } from "../../../../_virtual/segments.js";
+import { __exports as segments } from "../../../../_virtual/segments.js";
 import "./mode.js";
-import { n as K } from "./numeric-data.js";
-import { a as L } from "./alphanumeric-data.js";
-import { b as y } from "./byte-data.js";
-import { k as _ } from "./kanji-data.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 k } from "../../../dijkstrajs/dijkstra.js";
-import { __exports as D } from "../../../../_virtual/utils.js";
-import { __exports as j } from "../../../../_virtual/mode.js";
-import { __exports as x } from "../../../../_virtual/regex.js";
-(function(g) {
-  const o = j, N = K, I = L, B = y, C = _, c = x, p = D, w = k;
-  function b(n) {
-    return unescape(encodeURIComponent(n)).length;
+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 h(n, r, e) {
-    const t = [];
-    let s;
-    for (; (s = n.exec(e)) !== null; )
-      t.push({
-        data: s[0],
-        index: s.index,
-        mode: r,
-        length: s[0].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 t;
+    }
+    return segments2;
   }
-  function M(n) {
-    const r = h(c.NUMERIC, o.NUMERIC, n), e = h(c.ALPHANUMERIC, o.ALPHANUMERIC, n);
-    let t, s;
-    return p.isKanjiModeEnabled() ? (t = h(c.BYTE, o.BYTE, n), s = h(c.KANJI, o.KANJI, n)) : (t = h(c.BYTE_KANJI, o.BYTE, n), s = []), r.concat(e, t, s).sort(function(i, l) {
-      return i.index - l.index;
-    }).map(function(i) {
+  function getSegmentsFromString(dataStr) {
+    const numSegs = getSegments(Regex.NUMERIC, Mode.NUMERIC, dataStr);
+    const alphaNumSegs = getSegments(Regex.ALPHANUMERIC, Mode.ALPHANUMERIC, dataStr);
+    let byteSegs;
+    let kanjiSegs;
+    if (Utils.isKanjiModeEnabled()) {
+      byteSegs = getSegments(Regex.BYTE, Mode.BYTE, dataStr);
+      kanjiSegs = getSegments(Regex.KANJI, Mode.KANJI, dataStr);
+    } else {
+      byteSegs = getSegments(Regex.BYTE_KANJI, Mode.BYTE, dataStr);
+      kanjiSegs = [];
+    }
+    const segs = numSegs.concat(alphaNumSegs, byteSegs, kanjiSegs);
+    return segs.sort(function(s1, s2) {
+      return s1.index - s2.index;
+    }).map(function(obj) {
       return {
-        data: i.data,
-        mode: i.mode,
-        length: i.length
+        data: obj.data,
+        mode: obj.mode,
+        length: obj.length
       };
     });
   }
-  function E(n, r) {
-    switch (r) {
-      case o.NUMERIC:
-        return N.getBitsLength(n);
-      case o.ALPHANUMERIC:
-        return I.getBitsLength(n);
-      case o.KANJI:
-        return C.getBitsLength(n);
-      case o.BYTE:
-        return B.getBitsLength(n);
+  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 R(n) {
-    return n.reduce(function(r, e) {
-      const t = r.length - 1 >= 0 ? r[r.length - 1] : null;
-      return t && t.mode === e.mode ? (r[r.length - 1].data += e.data, r) : (r.push(e), r);
+  function mergeSegments(segs) {
+    return segs.reduce(function(acc, curr) {
+      const prevSeg = acc.length - 1 >= 0 ? acc[acc.length - 1] : null;
+      if (prevSeg && prevSeg.mode === curr.mode) {
+        acc[acc.length - 1].data += curr.data;
+        return acc;
+      }
+      acc.push(curr);
+      return acc;
     }, []);
   }
-  function T(n) {
-    const r = [];
-    for (let e = 0; e < n.length; e++) {
-      const t = n[e];
-      switch (t.mode) {
-        case o.NUMERIC:
-          r.push([
-            t,
-            { data: t.data, mode: o.ALPHANUMERIC, length: t.length },
-            { data: t.data, mode: o.BYTE, length: t.length }
+  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 o.ALPHANUMERIC:
-          r.push([
-            t,
-            { data: t.data, mode: o.BYTE, length: t.length }
+        case Mode.ALPHANUMERIC:
+          nodes.push([
+            seg,
+            { data: seg.data, mode: Mode.BYTE, length: seg.length }
           ]);
           break;
-        case o.KANJI:
-          r.push([
-            t,
-            { data: t.data, mode: o.BYTE, length: b(t.data) }
+        case Mode.KANJI:
+          nodes.push([
+            seg,
+            { data: seg.data, mode: Mode.BYTE, length: getStringByteLength(seg.data) }
           ]);
           break;
-        case o.BYTE:
-          r.push([
-            { data: t.data, mode: o.BYTE, length: b(t.data) }
+        case Mode.BYTE:
+          nodes.push([
+            { data: seg.data, mode: Mode.BYTE, length: getStringByteLength(seg.data) }
           ]);
       }
     }
-    return r;
+    return nodes;
   }
-  function U(n, r) {
-    const e = {}, t = { start: {} };
-    let s = ["start"];
-    for (let a = 0; a < n.length; a++) {
-      const i = n[a], l = [];
-      for (let m = 0; m < i.length; m++) {
-        const d = i[m], f = "" + a + m;
-        l.push(f), e[f] = { node: d, lastCount: 0 }, t[f] = {};
-        for (let A = 0; A < s.length; A++) {
-          const u = s[A];
-          e[u] && e[u].node.mode === d.mode ? (t[u][f] = E(e[u].lastCount + d.length, d.mode) - E(e[u].lastCount, d.mode), e[u].lastCount += d.length) : (e[u] && (e[u].lastCount = d.length), t[u][f] = E(d.length, d.mode) + 4 + o.getCharCountIndicator(d.mode, r));
+  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);
+          }
         }
       }
-      s = l;
+      prevNodeIds = currentNodeIds;
     }
-    for (let a = 0; a < s.length; a++)
-      t[s[a]].end = 0;
-    return { map: t, table: e };
+    for (let n = 0; n < prevNodeIds.length; n++) {
+      graph[prevNodeIds[n]].end = 0;
+    }
+    return { map: graph, table };
   }
-  function S(n, r) {
-    let e;
-    const t = o.getBestModeForData(n);
-    if (e = o.from(r, t), e !== o.BYTE && e.bit < t.bit)
-      throw new Error('"' + n + '" cannot be encoded with mode ' + o.toString(e) + `.
- Suggested mode is: ` + o.toString(t));
-    switch (e === o.KANJI && !p.isKanjiModeEnabled() && (e = o.BYTE), e) {
-      case o.NUMERIC:
-        return new N(n);
-      case o.ALPHANUMERIC:
-        return new I(n);
-      case o.KANJI:
-        return new C(n);
-      case o.BYTE:
-        return new B(n);
+  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);
     }
   }
-  g.fromArray = function(r) {
-    return r.reduce(function(e, t) {
-      return typeof t == "string" ? e.push(S(t, null)) : t.data && e.push(S(t.data, t.mode)), e;
+  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;
     }, []);
-  }, g.fromString = function(r, e) {
-    const t = M(r, p.isKanjiModeEnabled()), s = T(t), a = U(s, e), i = w.find_path(a.map, "start", "end"), l = [];
-    for (let m = 1; m < i.length - 1; m++)
-      l.push(a.table[i[m]].node);
-    return g.fromArray(R(l));
-  }, g.rawSplit = function(r) {
-    return g.fromArray(
-      M(r, p.isKanjiModeEnabled())
+  };
+  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())
     );
   };
-})(Y);
+})(segments);
+//# sourceMappingURL=segments.js.map

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

@@ -0,0 +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]}