@softwarefactory-project/re-ansi 0.7.3 → 0.7.5

package/README.md

@@ -79,8 +79,23 @@ Then build and run tests with `yarn test`.
 
 Make sure to read about [React][reason-react] and [Reason][rescript-lang] too.
 
+To make a release:
+
+- Update the version number in packages.json
+- Run `npm run build && npm run bundle`
+- Then: `npm publish`
+- Tag and push the commit
+
 ## Changes
 
+### 0.7.5
+
+- Fix link parsing when escape sequences at end of URL.
+
+### 0.7.4
+
+- Add the missing `Ansi.res.js` to the release.
+
 ### 0.7.3
 
 - Better parse url.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softwarefactory-project/re-ansi",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "description": "ANSI code to HTML",
   "files": [
     "README.md",
@@ -15,7 +15,7 @@
   "homepage": "https://github.com/softwarefactory-project/re-ansi",
   "repository": {
     "type": "git",
-    "url": "git+https://softwarefactory-project.io/r/software-factory/re-ansi.git"
+    "url": "https://github.com/softwarefactory-project/re-ansi.git"
   },
   "scripts": {
     "build": "rescript",

package/src/Ansi.res

@@ -153,7 +153,7 @@ module AnsiCode = {
 
   // Link management
   module HttpLink = {
-    let linkRe = RegExp.fromString("^(http(s)?:\\/\\/[^\\)>\\s]+)");
+    let linkRe = RegExp.fromString("^(http(s)?:\\/\\/[^\\)>\\s\x1b]+)");
 
     let get = (txt: string): parser<code> =>
       linkRe

package/src/Ansi.res.js

@@ -0,0 +1,1133 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// node_modules/rescript/lib/es6/caml_option.js
+function some(x) {
+  if (x === void 0) {
+    return {
+      BS_PRIVATE_NESTED_SOME_NONE: 0
+    };
+  } else if (x !== null && x.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
+    return {
+      BS_PRIVATE_NESTED_SOME_NONE: x.BS_PRIVATE_NESTED_SOME_NONE + 1 | 0
+    };
+  } else {
+    return x;
+  }
+}
+__name(some, "some");
+function nullable_to_opt(x) {
+  if (x == null) {
+    return;
+  } else {
+    return some(x);
+  }
+}
+__name(nullable_to_opt, "nullable_to_opt");
+function valFromOption(x) {
+  if (!(x !== null && x.BS_PRIVATE_NESTED_SOME_NONE !== void 0)) {
+    return x;
+  }
+  var depth = x.BS_PRIVATE_NESTED_SOME_NONE;
+  if (depth === 0) {
+    return;
+  } else {
+    return {
+      BS_PRIVATE_NESTED_SOME_NONE: depth - 1 | 0
+    };
+  }
+}
+__name(valFromOption, "valFromOption");
+
+// node_modules/rescript/lib/es6/js_string.js
+function codePointAt(arg1, obj) {
+  return obj.codePointAt(arg1);
+}
+__name(codePointAt, "codePointAt");
+function slice(from, to_, obj) {
+  return obj.slice(from, to_);
+}
+__name(slice, "slice");
+function sliceToEnd(from, obj) {
+  return obj.slice(from);
+}
+__name(sliceToEnd, "sliceToEnd");
+
+// node_modules/@rescript/core/src/Core__List.res.mjs
+function add(xs, x) {
+  return {
+    hd: x,
+    tl: xs
+  };
+}
+__name(add, "add");
+function copyAuxCont(_cellX, _prec) {
+  while (true) {
+    var prec = _prec;
+    var cellX = _cellX;
+    if (!cellX) {
+      return prec;
+    }
+    var next = {
+      hd: cellX.hd,
+      tl: (
+        /* [] */
+        0
+      )
+    };
+    prec.tl = next;
+    _prec = next;
+    _cellX = cellX.tl;
+    continue;
+  }
+  ;
+}
+__name(copyAuxCont, "copyAuxCont");
+function length(xs) {
+  var _x = xs;
+  var _acc = 0;
+  while (true) {
+    var acc = _acc;
+    var x = _x;
+    if (!x) {
+      return acc;
+    }
+    _acc = acc + 1 | 0;
+    _x = x.tl;
+    continue;
+  }
+  ;
+}
+__name(length, "length");
+function fillAux(arr, _i, _x) {
+  while (true) {
+    var x = _x;
+    var i = _i;
+    if (!x) {
+      return;
+    }
+    arr[i] = x.hd;
+    _x = x.tl;
+    _i = i + 1 | 0;
+    continue;
+  }
+  ;
+}
+__name(fillAux, "fillAux");
+function toArray(x) {
+  var len = length(x);
+  var arr = new Array(len);
+  fillAux(arr, 0, x);
+  return arr;
+}
+__name(toArray, "toArray");
+function reverseConcat(_l1, _l2) {
+  while (true) {
+    var l2 = _l2;
+    var l1 = _l1;
+    if (!l1) {
+      return l2;
+    }
+    _l2 = {
+      hd: l1.hd,
+      tl: l2
+    };
+    _l1 = l1.tl;
+    continue;
+  }
+  ;
+}
+__name(reverseConcat, "reverseConcat");
+function reverse(l) {
+  return reverseConcat(
+    l,
+    /* [] */
+    0
+  );
+}
+__name(reverse, "reverse");
+function flatAux(_prec, _xs) {
+  while (true) {
+    var xs = _xs;
+    var prec = _prec;
+    if (xs) {
+      _xs = xs.tl;
+      _prec = copyAuxCont(xs.hd, prec);
+      continue;
+    }
+    prec.tl = /* [] */
+    0;
+    return;
+  }
+  ;
+}
+__name(flatAux, "flatAux");
+function flat(_xs) {
+  while (true) {
+    var xs = _xs;
+    if (!xs) {
+      return (
+        /* [] */
+        0
+      );
+    }
+    var match = xs.hd;
+    if (match) {
+      var cell = {
+        hd: match.hd,
+        tl: (
+          /* [] */
+          0
+        )
+      };
+      flatAux(copyAuxCont(match.tl, cell), xs.tl);
+      return cell;
+    }
+    _xs = xs.tl;
+    continue;
+  }
+  ;
+}
+__name(flat, "flat");
+
+// node_modules/@rescript/core/src/Core__Option.res.mjs
+function flatMap(opt, f) {
+  if (opt !== void 0) {
+    return f(valFromOption(opt));
+  }
+}
+__name(flatMap, "flatMap");
+function getOr(opt, $$default2) {
+  if (opt !== void 0) {
+    return valFromOption(opt);
+  } else {
+    return $$default2;
+  }
+}
+__name(getOr, "getOr");
+
+// src/Ansi.res.mjs
+import * as JsxRuntime from "react/jsx-runtime";
+function fourBitColors(code) {
+  switch (code) {
+    case 0:
+      return "black";
+    case 1:
+      return "red";
+    case 2:
+      return "green";
+    case 3:
+      return "yellow";
+    case 4:
+      return "blue";
+    case 5:
+      return "magenta";
+    case 6:
+      return "cyan";
+    case 9:
+      return "initial";
+    case 10:
+      return "grey";
+    case 11:
+      return "#DA2647";
+    case 12:
+      return "#87FF2A";
+    case 13:
+      return "#FFF700";
+    case 14:
+      return "#5DADEC";
+    case 15:
+      return "#FF3399";
+    case 16:
+      return "#8DD9CC";
+    case 7:
+    case 17:
+      return "white";
+    default:
+      console.log("Unknown color value:", code);
+      return;
+  }
+}
+__name(fourBitColors, "fourBitColors");
+function threeBitColors(code) {
+  switch (code) {
+    case 0:
+      return "grey";
+    case 1:
+      return "red";
+    case 2:
+      return "green";
+    case 3:
+      return "yellow";
+    case 4:
+      return "blue";
+    case 5:
+      return "magenta";
+    case 6:
+      return "cyan";
+    case 7:
+      return "white";
+    default:
+      console.log("Unknown color value:", code);
+      return;
+  }
+}
+__name(threeBitColors, "threeBitColors");
+function combine(css1, css2) {
+  return Object.assign({}, css1, css2);
+}
+__name(combine, "combine");
+function addWeight(fontWeight) {
+  return {
+    fontWeight
+  };
+}
+__name(addWeight, "addWeight");
+function addStyle(fontStyle) {
+  return {
+    fontStyle
+  };
+}
+__name(addStyle, "addStyle");
+function addDecoration(textDecoration) {
+  return {
+    textDecoration
+  };
+}
+__name(addDecoration, "addDecoration");
+function int_of_cp(c) {
+  return c - 48 | 0;
+}
+__name(int_of_cp, "int_of_cp");
+function getColorStyle(colorMode, colorValue) {
+  switch (colorMode) {
+    case 3:
+      return {
+        TAG: "Foreground",
+        _0: colorValue
+      };
+    case 0:
+    case 4:
+      return {
+        TAG: "Background",
+        _0: colorValue
+      };
+    case 9:
+      return {
+        TAG: "BrightForeground",
+        _0: colorValue
+      };
+    default:
+  }
+  console.log("Unknown color code:", colorMode, colorValue);
+}
+__name(getColorStyle, "getColorStyle");
+function getColorStyleCss(color) {
+  switch (color.TAG) {
+    case "Foreground":
+      return flatMap(fourBitColors(color._0), function(color2) {
+        return {
+          color: color2
+        };
+      });
+    case "BrightForeground":
+      return flatMap(threeBitColors(color._0), function(color2) {
+        return {
+          color: color2,
+          fontWeight: "bold"
+        };
+      });
+    case "Background":
+      return flatMap(fourBitColors(color._0), function(background) {
+        return {
+          background
+        };
+      });
+  }
+}
+__name(getColorStyleCss, "getColorStyleCss");
+function get(colorMode, colorValue) {
+  return flatMap(getColorStyle(colorMode - 48 | 0, colorValue - 48 | 0), getColorStyleCss);
+}
+__name(get, "get");
+var ColorCss = {
+  getColorStyle,
+  getColorStyleCss,
+  get
+};
+function getFontStyle(fontMode) {
+  switch (fontMode) {
+    case 1:
+      return {
+        TAG: "FontStyle",
+        _0: addWeight("bold")
+      };
+    case 2:
+      return {
+        TAG: "FontStyle",
+        _0: addWeight("lighter")
+      };
+    case 3:
+      return {
+        TAG: "FontStyle",
+        _0: addStyle("italic")
+      };
+    case 4:
+      return {
+        TAG: "FontStyle",
+        _0: addDecoration("underline")
+      };
+    case 0:
+    case 7:
+      return "Regular";
+    case 9:
+      return {
+        TAG: "FontStyle",
+        _0: addDecoration("line-through")
+      };
+    default:
+      return;
+  }
+}
+__name(getFontStyle, "getFontStyle");
+function getFontStyleCss(font) {
+  if (typeof font !== "object") {
+    return;
+  } else {
+    return font._0;
+  }
+}
+__name(getFontStyleCss, "getFontStyleCss");
+function get$1(fontMode) {
+  return flatMap(getFontStyle(fontMode - 48 | 0), getFontStyleCss);
+}
+__name(get$1, "get$1");
+var FontCss = {
+  getFontStyle,
+  getFontStyleCss,
+  get: get$1
+};
+var linkRe = new RegExp("^(http(s)?:\\/\\/[^\\)>\\s\x1B]+)");
+function get$2(txt) {
+  return getOr(flatMap(nullable_to_opt(linkRe.exec(txt)), function(res) {
+    return flatMap(res[0], function(url) {
+      return [
+        url.length,
+        {
+          TAG: "HRef",
+          _0: url
+        }
+      ];
+    });
+  }), [
+    1,
+    void 0
+  ]);
+}
+__name(get$2, "get$2");
+var HttpLink = {
+  linkRe,
+  get: get$2
+};
+function parse(txt, pos) {
+  var match = codePointAt(pos, txt);
+  var exit = 0;
+  if (match === void 0) {
+    return [
+      0,
+      void 0
+    ];
+  }
+  if (match >= 14) {
+    if (match !== 27) {
+      if (match !== 104) {
+        return [
+          0,
+          void 0
+        ];
+      } else {
+        return get$2(slice(pos, 512, txt));
+      }
+    }
+    exit = 1;
+  } else {
+    if (match === 10) {
+      return [
+        1,
+        "CarriageReturn"
+      ];
+    }
+    if (match < 13) {
+      return [
+        0,
+        void 0
+      ];
+    }
+    exit = 1;
+  }
+  if (exit === 1) {
+    var codePoints = [];
+    var readCodePoints = /* @__PURE__ */ __name(function(_idx) {
+      while (true) {
+        var idx = _idx;
+        var match2 = idx > 10;
+        var match$110 = codePointAt(pos + idx | 0, txt);
+        if (match2) {
+          return;
+        }
+        if (match$110 === void 0) {
+          return;
+        }
+        if (match$110 === 109) {
+          return;
+        }
+        codePoints.push(match$110);
+        _idx = idx + 1 | 0;
+        continue;
+      }
+      ;
+    }, "readCodePoints");
+    readCodePoints(1);
+    var length2 = codePoints.length + 2 | 0;
+    var exit$1 = 0;
+    var colorMode;
+    var colorValue;
+    var xs;
+    var colorMode$1;
+    var colorValue$1;
+    var style;
+    var style$1;
+    var cm1;
+    var cv1;
+    var cm2;
+    var cv2;
+    var xs$1;
+    if (codePoints[0] === 10 && codePoints[1] === 27 && codePoints[2] === 91 && codePoints[3] === 49 && codePoints[4] === 65 && codePoints[5] === 27 && codePoints[6] === 91 && codePoints[7] === 74) {
+      return [
+        9,
+        "EraseLine"
+      ];
+    }
+    if (codePoints[0] === 91 && codePoints[2] === 75) {
+      return [
+        4,
+        "EraseLine"
+      ];
+    }
+    if (codePoints[0] === 91 && codePoints[1] === 75) {
+      return [
+        3,
+        "EraseLine"
+      ];
+    }
+    var len = codePoints.length;
+    if (len >= 11) {
+      return [
+        1,
+        void 0
+      ];
+    }
+    switch (len) {
+      case 1:
+        var match$1 = codePoints[0];
+        if (match$1 !== 91) {
+          return [
+            1,
+            void 0
+          ];
+        } else {
+          return [
+            length2,
+            "Clear"
+          ];
+        }
+      case 2:
+        var match$2 = codePoints[0];
+        if (match$2 !== 91) {
+          return [
+            1,
+            void 0
+          ];
+        }
+        var style$2 = codePoints[1];
+        if (style$2 !== 48) {
+          return [
+            length2,
+            flatMap(get$1(style$2), function(style2) {
+              return {
+                TAG: "Style",
+                _0: style2
+              };
+            })
+          ];
+        } else {
+          return [
+            length2,
+            "Clear"
+          ];
+        }
+      case 3:
+        var match$3 = codePoints[0];
+        if (match$3 !== 91) {
+          return [
+            1,
+            void 0
+          ];
+        }
+        var colorMode$2 = codePoints[1];
+        var exit$2 = 0;
+        if (colorMode$2 !== 48) {
+          exit$2 = 5;
+        } else {
+          var match$4 = codePoints[2];
+          if (match$4 === 48) {
+            return [
+              length2,
+              "Clear"
+            ];
+          }
+          exit$2 = 5;
+        }
+        if (exit$2 === 5) {
+          var colorValue$2 = codePoints[2];
+          colorMode = colorMode$2;
+          colorValue = colorValue$2;
+          xs = codePoints;
+          exit$1 = 2;
+        }
+        break;
+      case 4:
+        var match$5 = codePoints[0];
+        if (match$5 !== 91) {
+          return [
+            1,
+            void 0
+          ];
+        }
+        var match$6 = codePoints[1];
+        if (match$6 !== 49) {
+          return [
+            1,
+            void 0
+          ];
+        }
+        var colorMode$3 = codePoints[2];
+        var colorValue$3 = codePoints[3];
+        colorMode = colorMode$3;
+        colorValue = colorValue$3;
+        xs = codePoints;
+        exit$1 = 2;
+        break;
+      case 5:
+        var match$7 = codePoints[0];
+        if (match$7 !== 91) {
+          return [
+            1,
+            void 0
+          ];
+        }
+        var colorMode$4 = codePoints[1];
+        var colorValue$4 = codePoints[2];
+        var match$8 = codePoints[3];
+        if (match$8 !== 59) {
+          if (colorValue$4 !== 59) {
+            return [
+              1,
+              void 0
+            ];
+          }
+          var colorMode$5 = codePoints[3];
+          var colorValue$5 = codePoints[4];
+          colorMode$1 = colorMode$5;
+          colorValue$1 = colorValue$5;
+          style = colorMode$4;
+          exit$1 = 3;
+        } else {
+          var style$3 = codePoints[4];
+          colorMode$1 = colorMode$4;
+          colorValue$1 = colorValue$4;
+          style = style$3;
+          exit$1 = 3;
+        }
+        break;
+      case 6:
+        var match$9 = codePoints[0];
+        if (match$9 !== 91) {
+          return [
+            1,
+            void 0
+          ];
+        }
+        var match$10 = codePoints[1];
+        if (match$10 !== 48) {
+          return [
+            1,
+            void 0
+          ];
+        }
+        var style$4 = codePoints[2];
+        var match$11 = codePoints[3];
+        if (match$11 !== 59) {
+          return [
+            1,
+            void 0
+          ];
+        }
+        var colorMode$6 = codePoints[4];
+        var colorValue$6 = codePoints[5];
+        colorMode$1 = colorMode$6;
+        colorValue$1 = colorValue$6;
+        style = style$4;
+        exit$1 = 3;
+        break;
+      case 0:
+      case 7:
+        return [
+          1,
+          void 0
+        ];
+      case 8:
+        var match$12 = codePoints[0];
+        if (match$12 !== 91) {
+          return [
+            1,
+            void 0
+          ];
+        }
+        var style$5 = codePoints[1];
+        var match$13 = codePoints[2];
+        if (match$13 !== 59) {
+          return [
+            1,
+            void 0
+          ];
+        }
+        var cm1$1 = codePoints[3];
+        var cv1$1 = codePoints[4];
+        var match$14 = codePoints[5];
+        if (match$14 !== 59) {
+          return [
+            1,
+            void 0
+          ];
+        }
+        var cm2$1 = codePoints[6];
+        var cv2$1 = codePoints[7];
+        style$1 = style$5;
+        cm1 = cm1$1;
+        cv1 = cv1$1;
+        cm2 = cm2$1;
+        cv2 = cv2$1;
+        xs$1 = codePoints;
+        exit$1 = 4;
+        break;
+      case 9:
+        var match$15 = codePoints[0];
+        if (match$15 !== 91) {
+          return [
+            1,
+            void 0
+          ];
+        }
+        var style$6 = codePoints[1];
+        var exit$3 = 0;
+        if (style$6 !== 48) {
+          exit$3 = 5;
+        } else {
+          var style$7 = codePoints[2];
+          var match$16 = codePoints[3];
+          if (match$16 !== 59) {
+            exit$3 = 5;
+          } else {
+            var cm1$2 = codePoints[4];
+            var cv1$2 = codePoints[5];
+            var match$17 = codePoints[6];
+            if (match$17 !== 59) {
+              exit$3 = 5;
+            } else {
+              var cm2$2 = codePoints[7];
+              var cv2$2 = codePoints[8];
+              style$1 = style$7;
+              cm1 = cm1$2;
+              cv1 = cv1$2;
+              cm2 = cm2$2;
+              cv2 = cv2$2;
+              xs$1 = codePoints;
+              exit$1 = 4;
+            }
+          }
+        }
+        if (exit$3 === 5) {
+          var match$18 = codePoints[2];
+          if (match$18 !== 59) {
+            return [
+              1,
+              void 0
+            ];
+          }
+          var cm1$3 = codePoints[3];
+          var cv1$3 = codePoints[4];
+          var match$19 = codePoints[5];
+          if (match$19 !== 59) {
+            return [
+              1,
+              void 0
+            ];
+          }
+          var match$20 = codePoints[6];
+          if (match$20 !== 49) {
+            return [
+              1,
+              void 0
+            ];
+          }
+          var cm2$3 = codePoints[7];
+          var cv2$3 = codePoints[8];
+          style$1 = style$6;
+          cm1 = cm1$3;
+          cv1 = cv1$3;
+          cm2 = cm2$3;
+          cv2 = cv2$3;
+          xs$1 = codePoints;
+          exit$1 = 4;
+        }
+        break;
+      case 10:
+        var match$21 = codePoints[0];
+        if (match$21 !== 91) {
+          return [
+            1,
+            void 0
+          ];
+        }
+        var match$22 = codePoints[1];
+        if (match$22 !== 48) {
+          return [
+            1,
+            void 0
+          ];
+        }
+        var style$8 = codePoints[2];
+        var match$23 = codePoints[3];
+        if (match$23 !== 59) {
+          return [
+            1,
+            void 0
+          ];
+        }
+        var cm1$4 = codePoints[4];
+        var cv1$4 = codePoints[5];
+        var match$24 = codePoints[6];
+        if (match$24 !== 59) {
+          return [
+            1,
+            void 0
+          ];
+        }
+        var match$25 = codePoints[7];
+        if (match$25 !== 49) {
+          return [
+            1,
+            void 0
+          ];
+        }
+        var cm2$4 = codePoints[8];
+        var cv2$4 = codePoints[9];
+        style$1 = style$8;
+        cm1 = cm1$4;
+        cv1 = cv1$4;
+        cm2 = cm2$4;
+        cv2 = cv2$4;
+        xs$1 = codePoints;
+        exit$1 = 4;
+        break;
+    }
+    switch (exit$1) {
+      case 2:
+        return [
+          length2,
+          flatMap(get(colorMode, colorValue + (xs.length === 4 ? 10 : 0) | 0), function(colorCss) {
+            return {
+              TAG: "Style",
+              _0: colorCss
+            };
+          })
+        ];
+      case 3:
+        return [
+          length2,
+          flatMap(get(colorMode$1, colorValue$1), function(colorCss) {
+            var fontCss = get$1(style);
+            if (fontCss !== void 0) {
+              return {
+                TAG: "Style",
+                _0: Object.assign({}, colorCss, fontCss)
+              };
+            } else {
+              return {
+                TAG: "Style",
+                _0: colorCss
+              };
+            }
+          })
+        ];
+      case 4:
+        return [
+          length2,
+          flatMap(get(cm1, cv1), function(colorCss1) {
+            return flatMap(get(cm2, cv2 + (xs$1.length === 9 ? 10 : 0) | 0), function(colorCss2) {
+              var css = Object.assign({}, colorCss1, colorCss2);
+              var fontCss = get$1(style$1);
+              if (fontCss !== void 0) {
+                return {
+                  TAG: "Style",
+                  _0: Object.assign({}, css, fontCss)
+                };
+              } else {
+                return {
+                  TAG: "Style",
+                  _0: css
+                };
+              }
+            });
+          })
+        ];
+    }
+  }
+}
+__name(parse, "parse");
+var AnsiCode = {
+  fourBitColors,
+  threeBitColors,
+  combine,
+  addWeight,
+  addStyle,
+  addDecoration,
+  int_of_cp,
+  ColorCss,
+  FontCss,
+  HttpLink,
+  parse
+};
+function text(txt, from, to_) {
+  return {
+    TAG: "Text",
+    _0: slice(from, to_, txt)
+  };
+}
+__name(text, "text");
+function parse$1(txt, length2, pos) {
+  var go = /* @__PURE__ */ __name(function(_pos, _prev) {
+    while (true) {
+      var prev = _prev;
+      var pos2 = _pos;
+      var match = pos2 === length2;
+      var match$1 = parse(txt, pos2);
+      if (match) {
+        return [
+          pos2,
+          {
+            hd: text(txt, prev, pos2),
+            tl: (
+              /* [] */
+              0
+            )
+          }
+        ];
+      }
+      var code = match$1[1];
+      if (code !== void 0) {
+        var prevElem = text(txt, prev, pos2);
+        var pos$1 = pos2 + match$1[0] | 0;
+        if (typeof code !== "object") {
+          switch (code) {
+            case "Clear":
+              return [
+                pos$1,
+                {
+                  hd: prevElem,
+                  tl: (
+                    /* [] */
+                    0
+                  )
+                }
+              ];
+            case "EraseLine":
+              _prev = pos$1;
+              _pos = pos$1;
+              continue;
+            case "CarriageReturn":
+              return [
+                pos$1,
+                {
+                  hd: prevElem,
+                  tl: {
+                    hd: "LineBreak",
+                    tl: (
+                      /* [] */
+                      0
+                    )
+                  }
+                }
+              ];
+          }
+        } else {
+          if (code.TAG === "HRef") {
+            return [
+              pos$1,
+              {
+                hd: prevElem,
+                tl: {
+                  hd: {
+                    TAG: "Link",
+                    _0: code._0
+                  },
+                  tl: (
+                    /* [] */
+                    0
+                  )
+                }
+              }
+            ];
+          }
+          var match$2 = go(pos$1, pos$1);
+          var styled = match$2[1];
+          if (styled !== void 0) {
+            return [
+              match$2[0],
+              {
+                hd: prevElem,
+                tl: {
+                  hd: {
+                    TAG: "DocStyle",
+                    _0: code._0,
+                    _1: styled
+                  },
+                  tl: (
+                    /* [] */
+                    0
+                  )
+                }
+              }
+            ];
+          } else {
+            return [
+              pos$1,
+              void 0
+            ];
+          }
+        }
+      } else {
+        _pos = pos2 + 1 | 0;
+        continue;
+      }
+    }
+    ;
+  }, "go");
+  return go(pos, pos);
+}
+__name(parse$1, "parse$1");
+var $$Document = {
+  text,
+  parse: parse$1
+};
+function parse$2(txt) {
+  var go = /* @__PURE__ */ __name(function(_txt, _acc) {
+    while (true) {
+      var acc = _acc;
+      var txt2 = _txt;
+      var length2 = txt2.length;
+      var match = parse$1(txt2, length2, 0);
+      var doc = match[1];
+      var pos = match[0];
+      if (doc === void 0) {
+        return acc;
+      }
+      if (pos === length2) {
+        return add(acc, doc);
+      }
+      _acc = add(acc, doc);
+      _txt = sliceToEnd(pos, txt2);
+      continue;
+    }
+    ;
+  }, "go");
+  return flat(reverse(go(
+    txt,
+    /* [] */
+    0
+  )));
+}
+__name(parse$2, "parse$2");
+function render(doc) {
+  var go = /* @__PURE__ */ __name(function(_xs, _idx, _acc) {
+    while (true) {
+      var acc = _acc;
+      var idx = _idx;
+      var xs = _xs;
+      if (!xs) {
+        return toArray(reverse(acc));
+      }
+      var txt = xs.hd;
+      if (typeof txt !== "object") {
+        _acc = add(acc, JsxRuntime.jsx("br", {}, String(idx)));
+        _idx = idx + 1 | 0;
+        _xs = xs.tl;
+        continue;
+      }
+      switch (txt.TAG) {
+        case "Text":
+          _acc = add(acc, txt._0);
+          _idx = idx + 1 | 0;
+          _xs = xs.tl;
+          continue;
+        case "Link":
+          var href = txt._0;
+          _acc = add(acc, JsxRuntime.jsx("a", {
+            children: href,
+            href
+          }, String(idx)));
+          _idx = idx + 1 | 0;
+          _xs = xs.tl;
+          continue;
+        case "DocStyle":
+          _acc = add(acc, JsxRuntime.jsx("span", {
+            children: go(
+              txt._1,
+              0,
+              /* [] */
+              0
+            ),
+            style: txt._0
+          }, String(idx)));
+          _idx = idx + 1 | 0;
+          _xs = xs.tl;
+          continue;
+      }
+    }
+    ;
+  }, "go");
+  return go(
+    doc,
+    0,
+    /* [] */
+    0
+  );
+}
+__name(render, "render");
+function Ansi(props) {
+  return JsxRuntime.jsx("div", {
+    children: render(parse$2(props.log))
+  });
+}
+__name(Ansi, "Ansi");
+var make = Ansi;
+var $$default = Ansi;
+export {
+  $$Document,
+  AnsiCode,
+  $$default as default,
+  make,
+  parse$2 as parse,
+  render
+};