binary-collections 2.0.5 → 2.0.7

package/lib/ps/table-parser.cjs

@@ -0,0 +1,359 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+  }
+});
+
+// src/ps/connected-domain.js
+var require_connected_domain = __commonJS({
+  "src/ps/connected-domain.js"(exports2, module2) {
+    init_cjs_shims();
+    module2.exports = function(tdArray, indicator, hardlink) {
+      hardlink = hardlink || false;
+      if (!tdArray) {
+        throw new Error("tdArray must be provided");
+      }
+      if (!indicator) {
+        throw new Error("indicator must be provided");
+      }
+      tdArray = JSON.parse(JSON.stringify(tdArray));
+      var domains = {};
+      var domainUUID = 0;
+      var pointsHash = {};
+      tdArray.forEach(function(row, y) {
+        row.forEach(function(colItem, x) {
+          var identifier2 = indicator(colItem, x, y);
+          var neighbours = [];
+          if (tdArray[y - 1] && tdArray[y - 1][x] !== void 0) {
+            neighbours.push(pointsHash[x + "_" + (y - 1)]);
+          }
+          if (row[x - 1] !== void 0) {
+            neighbours.push(pointsHash[x - 1 + "_" + y]);
+          }
+          if (!hardlink) {
+            if (tdArray[y - 1] && tdArray[y - 1][x - 1] !== void 0) {
+              neighbours.push(pointsHash[x - 1 + "_" + (y - 1)]);
+            }
+            if (tdArray[y - 1] && tdArray[y - 1][x + 1] !== void 0) {
+              neighbours.push(pointsHash[x + 1 + "_" + (y - 1)]);
+            }
+          }
+          if (neighbours.length) {
+            var matched = false;
+            neighbours.forEach(function(neighbour) {
+              if (neighbour.identifier == identifier2) {
+                if (!matched) {
+                  addPointToDomain(colItem, x, y, neighbour.domainId);
+                  matched = true;
+                } else {
+                  var colItemPoint = pointsHash[x + "_" + y];
+                  if (neighbour.domainId != colItemPoint.domainId) {
+                    mergeDomains(neighbour.domainId, colItemPoint.domainId);
+                  }
+                }
+              }
+            });
+            if (!matched) {
+              addNewDomain(colItem, x, y, identifier2);
+            }
+          } else {
+            addNewDomain(colItem, x, y, identifier2);
+          }
+        });
+      });
+      var result = {
+        domains: [],
+        totalDomains: 0,
+        groupByIdentifier: {},
+        totalIdentifiers: 0
+      };
+      var domainId = null;
+      var identifier = null;
+      var domain = null;
+      for (domainId in domains) {
+        domain = domains[domainId];
+        domain.bounding = calculateBounding(domain.points);
+        identifier = domain.identifier;
+        result.domains.push(domain);
+        result.totalDomains++;
+        if (!(identifier in result.groupByIdentifier)) {
+          result.groupByIdentifier[identifier] = [];
+          result.totalIdentifiers++;
+        }
+        result.groupByIdentifier[identifier].push(domain);
+      }
+      function calculateBounding(points) {
+        var minX = null;
+        var minY = null;
+        var maxX = null;
+        var maxY = null;
+        points.forEach(function(point) {
+          if (minX === null || point.x < minX) {
+            minX = point.x;
+          }
+          if (minY === null || point.y < minY) {
+            minY = point.y;
+          }
+          if (maxX === null || point.x > maxX) {
+            maxX = point.x;
+          }
+          if (maxY === null || point.y > maxY) {
+            maxY = point.y;
+          }
+        });
+        var w = maxX - minX;
+        var h = maxY - minY;
+        return {
+          x: minX,
+          y: minY,
+          w,
+          h
+        };
+      }
+      function addNewDomain(point, x, y, identifier2) {
+        var newDomain = {
+          identifier: identifier2,
+          domainId: ++domainUUID,
+          bounding: {},
+          points: []
+        };
+        var newPoint = {
+          value: point,
+          x,
+          y,
+          identifier: identifier2,
+          domainId: newDomain.domainId
+        };
+        pointsHash[x + "_" + y] = {
+          value: point,
+          identifier: identifier2,
+          domainId: newDomain.domainId
+        };
+        newDomain.points.push(newPoint);
+        domains[newDomain.domainId] = newDomain;
+      }
+      function addPointToDomain(point, x, y, domainId2) {
+        var domain2 = domains[domainId2];
+        var newPoint = {
+          value: point,
+          x,
+          y,
+          identifier: domain2.identifier,
+          domainId: domainId2
+        };
+        pointsHash[x + "_" + y] = {
+          value: point,
+          identifier: domain2.identifier,
+          domainId: domainId2
+        };
+        domain2.points.push(newPoint);
+      }
+      function mergeDomains(domainAId, domainBId) {
+        var domainA = domains[domainAId];
+        var domainB = domains[domainBId];
+        if (domainA.identifier == domainB.identifier) {
+          domainB.domainId = domainA.domainId;
+          domainB.points.forEach(function(point) {
+            point.domainId = domainA.domainId;
+            pointsHash[point.x + "_" + point.y].domainId = domainA.domainId;
+          });
+          domainA.points = domainA.points.concat(domainB.points);
+          delete domains[domainBId];
+        }
+      }
+      return result;
+    };
+  }
+});
+
+// src/ps/table-parser.js
+init_cjs_shims();
+var ConnectedDomain = require_connected_domain();
+var EMPTY_EX = /\s/;
+module.exports.parse = function(output) {
+  var linesTmp = output.split(/(\r\n)|(\n\r)|\n|\r/);
+  var lines = [];
+  var titleInfo = {};
+  var twoDimArray = [];
+  linesTmp.forEach(function(line) {
+    if (line && line.trim()) {
+      lines.push(line);
+    }
+  });
+  lines.forEach(function(line, index) {
+    if (index == 0) {
+      var fields = line.split(/\s+/);
+      var currentIndex = 0;
+      fields.forEach(function(field, idx) {
+        if (field) {
+          var info = titleInfo[field] = {};
+          var indexBegin = line.indexOf(field, currentIndex);
+          var indexEnd = currentIndex = indexBegin + field.length;
+          if (idx == 0) {
+            info.titleBegin = 0;
+          } else {
+            info.titleBegin = indexBegin;
+          }
+          if (idx == fields.length - 1) {
+            info.titleEnd = line.length - 1;
+          } else {
+            info.titleEnd = indexEnd;
+          }
+        }
+      });
+    } else {
+      twoDimArray[index - 1] = line.split("");
+    }
+  });
+  var connectedDomains = ConnectedDomain(
+    twoDimArray,
+    function(value) {
+      if (EMPTY_EX.test(value)) {
+        return -1;
+      } else {
+        return 1;
+      }
+    },
+    true
+  );
+  var valuesDomainsVerticalGroups = [];
+  connectedDomains.domains.sort(function(a, b) {
+    return a.bounding.x - b.bounding.x;
+  });
+  connectedDomains.domains.forEach(function(domain) {
+    if (domain.identifier === 1) {
+      var overlapped = false;
+      valuesDomainsVerticalGroups.forEach(function(group) {
+        var bounding = domain.bounding;
+        var left = bounding.x;
+        var right = bounding.x + bounding.w;
+        if (overlap(left, right, group.begin, group.end)) {
+          overlapped = true;
+          group.domains.push(domain);
+          group.begin = group.begin > left ? left : group.begin;
+          group.end = group.end < right ? right : group.end;
+        }
+      });
+      if (!overlapped) {
+        valuesDomainsVerticalGroups.push({
+          begin: domain.bounding.x,
+          end: domain.bounding.x + domain.bounding.w,
+          domains: [domain]
+        });
+      }
+    }
+  });
+  valuesDomainsVerticalGroups.forEach(function(group) {
+    var title = null;
+    var info = null;
+    var overlapped = false;
+    var minimunLeftDistance = null;
+    var nearestLeftTitle = null;
+    var distance = null;
+    for (title in titleInfo) {
+      info = titleInfo[title];
+      if (group.begin > info.titleBegin) {
+        distance = group.begin - info.titleBegin;
+        if (!nearestLeftTitle || distance < minimunLeftDistance) {
+          nearestLeftTitle = title;
+          minimunLeftDistance = distance;
+        }
+      }
+      if (overlap(group.begin, group.end, info.titleBegin, info.titleEnd)) {
+        overlapped = true;
+        info.titleBegin = info.titleBegin > group.begin ? group.begin : info.titleBegin;
+        info.titleEnd = info.titleEnd < group.end ? group.end : info.titleEnd;
+      }
+    }
+    if (!overlapped && nearestLeftTitle) {
+      var nearestTitleField = titleInfo[nearestLeftTitle];
+      nearestTitleField.titleBegin = nearestTitleField.titleBegin > group.begin ? group.begin : nearestTitleField.titleBegin;
+      nearestTitleField.titleEnd = nearestTitleField.titleEnd < group.end ? group.end : nearestTitleField.titleEnd;
+    }
+  });
+  var result = [];
+  lines.forEach(function(line, index) {
+    if (index > 0) {
+      var lineItem = {};
+      var title = null;
+      var info = null;
+      var value = null;
+      for (title in titleInfo) {
+        info = titleInfo[title];
+        value = line.substring(info.titleBegin, info.titleEnd + 1);
+        lineItem[title] = splitValue(value.trim());
+      }
+      result.push(lineItem);
+    }
+  });
+  return result;
+};
+function overlap(begin1, end1, begin2, end2) {
+  return begin1 > begin2 && begin1 < end2 || // 2--1--2--1 or 2--1--1--2
+  end1 > begin2 && end1 < end2 || // 1--2--1--2 or 2--1--1--2
+  begin1 <= begin2 && end1 >= end2;
+}
+function splitValue(value) {
+  var match = value.match(/"/g);
+  if (!match || match.length == 1) {
+    return value.split(/\s+/);
+  } else {
+    var result = [];
+    var chunk = null;
+    var ifInWrappedChunk = false;
+    var ifInPureWrappedChunk = false;
+    var quotaCount = 0;
+    var maxQuotaCount = match.length % 2 == 0 ? match.length : match.length - 1;
+    var previousItem = null;
+    var values = value.split("");
+    values.forEach(function(item, index) {
+      if (item !== " ") {
+        if (item === '"') {
+          if (ifInWrappedChunk === false && quotaCount <= maxQuotaCount) {
+            ifInWrappedChunk = true;
+            quotaCount++;
+            if (previousItem === " " || previousItem === null) {
+              ifInPureWrappedChunk = true;
+              chunk = "";
+            } else {
+              chunk += item;
+            }
+          } else if (ifInWrappedChunk === true) {
+            ifInWrappedChunk = false;
+            quotaCount++;
+            if (ifInPureWrappedChunk === true) {
+              ifInPureWrappedChunk = false;
+              result.push(chunk);
+              chunk = null;
+            } else {
+              chunk += item;
+            }
+          }
+        } else if (ifInWrappedChunk === false && (previousItem === " " || previousItem === null)) {
+          chunk = item;
+        } else {
+          chunk += item;
+        }
+      } else if (ifInWrappedChunk) {
+        chunk += item;
+      } else if (chunk !== null) {
+        result.push(chunk);
+        chunk = null;
+      }
+      previousItem = item;
+      if (index == values.length - 1 && chunk !== null) {
+        result.push(chunk);
+        chunk = null;
+      }
+    });
+    return result;
+  }
+}

package/lib/ps/table-parser.d.mts

@@ -0,0 +1,3 @@
+declare function parse(output: any): any[];
+
+export { parse };

package/lib/ps/table-parser.d.ts

@@ -0,0 +1 @@
+export function parse(output: any): any[];

package/lib/ps/table-parser.js

@@ -0,0 +1,268 @@
+/**
+ *
+ * 1, define the edge ( begin and end ) of every title field
+ * 2, parse all the lines except the title line, get all the connected-domains
+ * 3, group all the connected-domains vertically overlapped.
+ * 4, a domain group belongs to a title field if they vertically overlapped
+ * 5, calculate all the edge info through the group domain and title field relations.
+ */
+var ConnectedDomain = require("./connected-domain");
+var EMPTY_EX = /\s/;
+/**
+ * The output sting of cmd to parse
+ * @param output
+ * @returns {Array}
+ */
+module.exports.parse = function (output) {
+    // Split into lines
+    // Basically, the EOL should be:
+    // - windows: \r\n
+    // - *nix: \n
+    // But i'm trying to get every possibilities covered.
+    var linesTmp = output.split(/(\r\n)|(\n\r)|\n|\r/);
+    // valid lines
+    var lines = [];
+    // title field info, mapped with filed name.
+    var titleInfo = {};
+    // the two dimensional array of the lines
+    var twoDimArray = [];
+    // get rid of all the empty lines.
+    linesTmp.forEach(function (line) {
+        if (line && line.trim()) {
+            lines.push(line);
+        }
+    });
+    // build title fields edge info
+    // build two dimensional array for Connected-Domain to parse.
+    lines.forEach(function (line, index) {
+        // Treat the first line as the title fields line
+        if (index == 0) {
+            var fields = line.split(/\s+/);
+            var currentIndex = 0;
+            // record the beginning and ending for each field
+            fields.forEach(function (field, idx) {
+                if (field) {
+                    var info = (titleInfo[field] = {});
+                    var indexBegin = line.indexOf(field, currentIndex);
+                    var indexEnd = (currentIndex = indexBegin + field.length);
+                    if (idx == 0) {
+                        info.titleBegin = 0;
+                    }
+                    else {
+                        info.titleBegin = indexBegin;
+                    }
+                    if (idx == fields.length - 1) {
+                        info.titleEnd = line.length - 1;
+                    }
+                    else {
+                        info.titleEnd = indexEnd;
+                    }
+                }
+            });
+        }
+        else {
+            twoDimArray[index - 1] = line.split("");
+        }
+    });
+    // In the connected-domain aspect of view, all the blanks are connected, and all the non-blanks are connected.
+    var connectedDomains = ConnectedDomain(twoDimArray, function (value) {
+        if (EMPTY_EX.test(value)) {
+            return -1;
+        }
+        else {
+            return 1;
+        }
+    }, true);
+    // all the connected domains grouped if they are vertically overlapped.
+    var valuesDomainsVerticalGroups = [];
+    // sore the domain list make 'x' in ascending order, it will prevent the situation that:
+    // 1, two domains are not overlapped, so two groups are created for them at first
+    // 2, another domain is found overlapped with both of the domains at the first step.
+    // 3, In this situation the three groups have to be merged, which is complicated to implement.
+    //
+    // If the list is sorted in this order, this situation can't happen, because:
+    // - 1, If two non-overlapped domains A, B ( the "x" value of A less than B ) are found first.
+    // - 2, Since the list is in 'x' ascending order, the 'x' values of the following domains must larger or equal to the "x" of B, which means they will never overlapped with domain A.
+    // - 3, So this situation can't happen.
+    connectedDomains.domains.sort(function (a, b) {
+        return a.bounding.x - b.bounding.x;
+    });
+    // Group domains vertically overlapped.
+    connectedDomains.domains.forEach(function (domain) {
+        // only handle un-empty domain
+        if (domain.identifier === 1) {
+            var overlapped = false;
+            // If overlapped
+            valuesDomainsVerticalGroups.forEach(function (group) {
+                var bounding = domain.bounding;
+                var left = bounding.x;
+                var right = bounding.x + bounding.w;
+                if (overlap(left, right, group.begin, group.end)) {
+                    overlapped = true;
+                    group.domains.push(domain);
+                    group.begin = group.begin > left ? left : group.begin;
+                    group.end = group.end < right ? right : group.end;
+                }
+            });
+            // If not overlapped with any group, then create a new group
+            if (!overlapped) {
+                valuesDomainsVerticalGroups.push({
+                    begin: domain.bounding.x,
+                    end: domain.bounding.x + domain.bounding.w,
+                    domains: [domain]
+                });
+            }
+        }
+    });
+    // connect all the groups to the title fields
+    valuesDomainsVerticalGroups.forEach(function (group) {
+        var title = null;
+        var info = null;
+        var overlapped = false;
+        var minimunLeftDistance = null;
+        var nearestLeftTitle = null;
+        var distance = null;
+        for (title in titleInfo) {
+            info = titleInfo[title];
+            /**
+             * The calculation below is to find the nearest left title field to the group, in case no overlapped title field found.
+             */
+            if (group.begin > info.titleBegin) {
+                distance = group.begin - info.titleBegin;
+                if (!nearestLeftTitle || distance < minimunLeftDistance) {
+                    nearestLeftTitle = title;
+                    minimunLeftDistance = distance;
+                }
+            }
+            if (overlap(group.begin, group.end, info.titleBegin, info.titleEnd)) {
+                overlapped = true;
+                info.titleBegin = info.titleBegin > group.begin ? group.begin : info.titleBegin;
+                info.titleEnd = info.titleEnd < group.end ? group.end : info.titleEnd;
+            }
+        }
+        // Groups not match any title field belongs to the nearest left title field
+        if (!overlapped && nearestLeftTitle) {
+            var nearestTitleField = titleInfo[nearestLeftTitle];
+            nearestTitleField.titleBegin =
+                nearestTitleField.titleBegin > group.begin ? group.begin : nearestTitleField.titleBegin;
+            nearestTitleField.titleEnd = nearestTitleField.titleEnd < group.end ? group.end : nearestTitleField.titleEnd;
+        }
+    });
+    // The final result
+    var result = [];
+    // Since we have got all the title bounding edges, we can split all the lines into values now
+    lines.forEach(function (line, index) {
+        // skip the first line
+        if (index > 0) {
+            var lineItem = {};
+            var title = null;
+            var info = null;
+            var value = null;
+            for (title in titleInfo) {
+                info = titleInfo[title];
+                value = line.substring(info.titleBegin, info.titleEnd + 1);
+                lineItem[title] = splitValue(value.trim());
+            }
+            result.push(lineItem);
+        }
+    });
+    return result;
+};
+/**
+ * Test if two bounding overlapped vertically
+ * @param begin1
+ * @param end1
+ * @param begin2
+ * @param end2
+ * @returns {boolean}
+ */
+function overlap(begin1, end1, begin2, end2) {
+    return ((begin1 > begin2 && begin1 < end2) || // 2--1--2--1 or 2--1--1--2
+        (end1 > begin2 && end1 < end2) || // 1--2--1--2 or 2--1--1--2
+        (begin1 <= begin2 && end1 >= end2)); // 21--12 or 1--2--2--1
+}
+/**
+ * transform a string value into array. It's not just split(), but also to consider some chunk that wrapped with `"`, like below:
+ *      "C:\Program Files\Google\Chrome\Application\chrome.exe" --type=renderer --lang=zh-CN, `C:\Program Files\Google\Chrome\Application\chrome.exe` should be treated as a whole,
+ *      also, be careful don't be mislead by format like `--name="neekey"`, even more complicated: `--name="Neekey Ni"`
+ * so, `"C:\Program Files\Internet Explorer\iexplore.exe" --name="Jack Neekey"` should split into:
+ *  - C:\Program Files\Internet Explorer\iexplore.exe  // without `"`
+ *  - --name="Jack Neekey"                             // with `"`
+ */
+function splitValue(value) {
+    var match = value.match(/"/g);
+    // If only one " found, then just ignore it
+    if (!match || match.length == 1) {
+        return value.split(/\s+/);
+    }
+    else {
+        var result = [];
+        var chunk = null;
+        var ifInWrappedChunk = false;
+        var ifInPureWrappedChunk = false;
+        var quotaCount = 0;
+        // If the match length is a even, than nothing special, if a odd, ignore the last one.
+        var maxQuotaCount = match.length % 2 == 0 ? match.length : match.length - 1;
+        var previousItem = null;
+        var values = value.split("");
+        values.forEach(function (item, index) {
+            if (item !== " ") {
+                if (item === '"') {
+                    // quota chunk begin
+                    if (ifInWrappedChunk === false && quotaCount <= maxQuotaCount) {
+                        ifInWrappedChunk = true;
+                        quotaCount++;
+                        // pure quota chunk begin
+                        if (previousItem === " " || previousItem === null) {
+                            ifInPureWrappedChunk = true;
+                            chunk = "";
+                        }
+                        // normal continue
+                        else {
+                            chunk += item;
+                        }
+                    }
+                    // quota chunk end
+                    else if (ifInWrappedChunk === true) {
+                        ifInWrappedChunk = false;
+                        quotaCount++;
+                        // pure quota chunk end
+                        if (ifInPureWrappedChunk === true) {
+                            ifInPureWrappedChunk = false;
+                            result.push(chunk);
+                            chunk = null;
+                        }
+                        // normal continue
+                        else {
+                            chunk += item;
+                        }
+                    }
+                }
+                // normal begin
+                else if (ifInWrappedChunk === false && (previousItem === " " || previousItem === null)) {
+                    chunk = item;
+                }
+                // normal or quota chunk continue.
+                else {
+                    chunk += item;
+                }
+            }
+            // quota chunk continue, in quota chunk, blank is valid.
+            else if (ifInWrappedChunk) {
+                chunk += item;
+            }
+            // if not in quota chunk, them a blank means an end. But make sure chunk is exist, cause that could be blanks at the beginning.
+            else if (chunk !== null) {
+                result.push(chunk);
+                chunk = null;
+            }
+            previousItem = item;
+            // If this is the last one, but chunk is not end
+            if (index == values.length - 1 && chunk !== null) {
+                result.push(chunk);
+                chunk = null;
+            }
+        });
+        return result;
+    }
+}

package/lib/ps/table-parser.mjs

@@ -0,0 +1,8 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_table_parser
+} from "../chunk-3LOB2P54.mjs";
+import "../chunk-4LEXWIIF.mjs";
+import "../chunk-VXZQNLPU.mjs";
+import "../chunk-FB6YIQYR.mjs";
+export default require_table_parser();