@explorable-viz/fluid 0.12.3 → 0.12.4

package/output-es/Data.Show/index.js

@@ -0,0 +1,56 @@
+import * as Data$dVoid from "../Data.Void/index.js";
+import * as Record$dUnsafe from "../Record.Unsafe/index.js";
+import * as Type$dProxy from "../Type.Proxy/index.js";
+import {showArrayImpl, showCharImpl, showIntImpl, showNumberImpl, showStringImpl} from "./foreign.js";
+const showVoid = {show: Data$dVoid.absurd};
+const showUnit = {show: v => "unit"};
+const showString = {show: showStringImpl};
+const showRecordFieldsNil = {showRecordFields: v => v1 => ""};
+const showRecordFields = dict => dict.showRecordFields;
+const showRecord = () => () => dictShowRecordFields => ({show: record => "{" + dictShowRecordFields.showRecordFields(Type$dProxy.Proxy)(record) + "}"});
+const showProxy = {show: v => "Proxy"};
+const showNumber = {show: showNumberImpl};
+const showInt = {show: showIntImpl};
+const showChar = {show: showCharImpl};
+const showBoolean = {
+  show: v => {
+    if (v) { return "true"; }
+    return "false";
+  }
+};
+const show = dict => dict.show;
+const showArray = dictShow => ({show: showArrayImpl(dictShow.show)});
+const showRecordFieldsCons = dictIsSymbol => dictShowRecordFields => dictShow => (
+  {
+    showRecordFields: v => record => {
+      const key = dictIsSymbol.reflectSymbol(Type$dProxy.Proxy);
+      return " " + key + ": " + dictShow.show(Record$dUnsafe.unsafeGet(key)(record)) + "," + dictShowRecordFields.showRecordFields(Type$dProxy.Proxy)(record);
+    }
+  }
+);
+const showRecordFieldsConsNil = dictIsSymbol => dictShow => (
+  {
+    showRecordFields: v => record => {
+      const key = dictIsSymbol.reflectSymbol(Type$dProxy.Proxy);
+      return " " + key + ": " + dictShow.show(Record$dUnsafe.unsafeGet(key)(record)) + " ";
+    }
+  }
+);
+export {
+  show,
+  showArray,
+  showBoolean,
+  showChar,
+  showInt,
+  showNumber,
+  showProxy,
+  showRecord,
+  showRecordFields,
+  showRecordFieldsCons,
+  showRecordFieldsConsNil,
+  showRecordFieldsNil,
+  showString,
+  showUnit,
+  showVoid
+};
+export * from "./foreign.js";

package/output-es/Data.Show.Generic/foreign.js

@@ -0,0 +1,5 @@
+export const intercalate = function (separator) {
+  return function (xs) {
+    return xs.join(separator);
+  };
+};

package/output-es/Data.Show.Generic/index.js

@@ -0,0 +1,43 @@
+import * as $runtime from "../runtime.js";
+import * as Type$dProxy from "../Type.Proxy/index.js";
+import {intercalate} from "./foreign.js";
+const genericShowArgsNoArguments = {genericShowArgs: v => []};
+const genericShowArgsArgument = dictShow => ({genericShowArgs: v => [dictShow.show(v)]});
+const genericShowArgs = dict => dict.genericShowArgs;
+const genericShowArgsProduct = dictGenericShowArgs => dictGenericShowArgs1 => (
+  {genericShowArgs: v => [...dictGenericShowArgs.genericShowArgs(v._1), ...dictGenericShowArgs1.genericShowArgs(v._2)]}
+);
+const genericShowConstructor = dictGenericShowArgs => dictIsSymbol => (
+  {
+    "genericShow'": v => {
+      const ctor = dictIsSymbol.reflectSymbol(Type$dProxy.Proxy);
+      const v1 = dictGenericShowArgs.genericShowArgs(v);
+      if (v1.length === 0) { return ctor; }
+      return "(" + intercalate(" ")([ctor, ...v1]) + ")";
+    }
+  }
+);
+const genericShow$p = dict => dict["genericShow'"];
+const genericShowNoConstructors = {"genericShow'": a => genericShowNoConstructors["genericShow'"](a)};
+const genericShowSum = dictGenericShow => dictGenericShow1 => (
+  {
+    "genericShow'": v => {
+      if (v.tag === "Inl") { return dictGenericShow["genericShow'"](v._1); }
+      if (v.tag === "Inr") { return dictGenericShow1["genericShow'"](v._1); }
+      $runtime.fail();
+    }
+  }
+);
+const genericShow = dictGeneric => dictGenericShow => x => dictGenericShow["genericShow'"](dictGeneric.from(x));
+export {
+  genericShow,
+  genericShow$p,
+  genericShowArgs,
+  genericShowArgsArgument,
+  genericShowArgsNoArguments,
+  genericShowArgsProduct,
+  genericShowConstructor,
+  genericShowNoConstructors,
+  genericShowSum
+};
+export * from "./foreign.js";

package/output-es/Data.String/index.js

@@ -0,0 +1 @@
+export {};

package/output-es/Data.String.CaseInsensitive/index.js

@@ -0,0 +1,12 @@
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Data$dString$dCommon from "../Data.String.Common/index.js";
+const CaseInsensitiveString = x => x;
+const showCaseInsensitiveString = {show: v => "(CaseInsensitiveString " + Data$dShow.showStringImpl(v) + ")"};
+const newtypeCaseInsensitiveString = {Coercible0: () => {}};
+const eqCaseInsensitiveString = {eq: v => v1 => Data$dString$dCommon.toLower(v) === Data$dString$dCommon.toLower(v1)};
+const ordCaseInsensitiveString = {
+  compare: v => v1 => Data$dOrd.ordString.compare(Data$dString$dCommon.toLower(v))(Data$dString$dCommon.toLower(v1)),
+  Eq0: () => eqCaseInsensitiveString
+};
+export {CaseInsensitiveString, eqCaseInsensitiveString, newtypeCaseInsensitiveString, ordCaseInsensitiveString, showCaseInsensitiveString};

package/output-es/Data.String.CodePoints/foreign.js

@@ -0,0 +1,107 @@
+/* global Symbol */
+
+var hasArrayFrom = typeof Array.from === "function";
+var hasStringIterator =
+  typeof Symbol !== "undefined" &&
+  Symbol != null &&
+  typeof Symbol.iterator !== "undefined" &&
+  typeof String.prototype[Symbol.iterator] === "function";
+var hasFromCodePoint = typeof String.prototype.fromCodePoint === "function";
+var hasCodePointAt = typeof String.prototype.codePointAt === "function";
+
+export const _unsafeCodePointAt0 = function (fallback) {
+  return hasCodePointAt
+    ? function (str) { return str.codePointAt(0); }
+    : fallback;
+};
+
+export const _codePointAt = function (fallback) {
+  return function (Just) {
+    return function (Nothing) {
+      return function (unsafeCodePointAt0) {
+        return function (index) {
+          return function (str) {
+            var length = str.length;
+            if (index < 0 || index >= length) return Nothing;
+            if (hasStringIterator) {
+              var iter = str[Symbol.iterator]();
+              for (var i = index;; --i) {
+                var o = iter.next();
+                if (o.done) return Nothing;
+                if (i === 0) return Just(unsafeCodePointAt0(o.value));
+              }
+            }
+            return fallback(index)(str);
+          };
+        };
+      };
+    };
+  };
+};
+
+export const _countPrefix = function (fallback) {
+  return function (unsafeCodePointAt0) {
+    if (hasStringIterator) {
+      return function (pred) {
+        return function (str) {
+          var iter = str[Symbol.iterator]();
+          for (var cpCount = 0; ; ++cpCount) {
+            var o = iter.next();
+            if (o.done) return cpCount;
+            var cp = unsafeCodePointAt0(o.value);
+            if (!pred(cp)) return cpCount;
+          }
+        };
+      };
+    }
+    return fallback;
+  };
+};
+
+export const _fromCodePointArray = function (singleton) {
+  return hasFromCodePoint
+    ? function (cps) {
+      // Function.prototype.apply will fail for very large second parameters,
+      // so we don't use it for arrays with 10,000 or more entries.
+      if (cps.length < 10e3) {
+        return String.fromCodePoint.apply(String, cps);
+      }
+      return cps.map(singleton).join("");
+    }
+    : function (cps) {
+      return cps.map(singleton).join("");
+    };
+};
+
+export const _singleton = function (fallback) {
+  return hasFromCodePoint ? String.fromCodePoint : fallback;
+};
+
+export const _take = function (fallback) {
+  return function (n) {
+    if (hasStringIterator) {
+      return function (str) {
+        var accum = "";
+        var iter = str[Symbol.iterator]();
+        for (var i = 0; i < n; ++i) {
+          var o = iter.next();
+          if (o.done) return accum;
+          accum += o.value;
+        }
+        return accum;
+      };
+    }
+    return fallback(n);
+  };
+};
+
+export const _toCodePointArray = function (fallback) {
+  return function (unsafeCodePointAt0) {
+    if (hasArrayFrom) {
+      return function (str) {
+        return Array.from(str, unsafeCodePointAt0);
+      };
+    }
+    return fallback;
+  };
+};

package/output-es/Data.String.CodePoints/index.js

@@ -0,0 +1,201 @@
+// | These functions allow PureScript strings to be treated as if they were
+// | sequences of Unicode code points instead of their true underlying
+// | implementation (sequences of UTF-16 code units). For nearly all uses of
+// | strings, these functions should be preferred over the ones in
+// | `Data.String.CodeUnits`.
+import * as $runtime from "../runtime.js";
+import * as Data$dEnum from "../Data.Enum/index.js";
+import * as Data$dEuclideanRing from "../Data.EuclideanRing/index.js";
+import * as Data$dInt from "../Data.Int/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dString$dCodeUnits from "../Data.String.CodeUnits/index.js";
+import * as Data$dString$dCommon from "../Data.String.Common/index.js";
+import * as Data$dString$dUnsafe from "../Data.String.Unsafe/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Data$dUnfoldable from "../Data.Unfoldable/index.js";
+import {_codePointAt, _countPrefix, _fromCodePointArray, _singleton, _take, _toCodePointArray, _unsafeCodePointAt0} from "./foreign.js";
+const showCodePoint = {show: v => "(CodePoint 0x" + Data$dString$dCommon.toUpper(Data$dInt.toStringAs(16)(v)) + ")"};
+const uncons = s => {
+  const v = Data$dString$dCodeUnits.length(s);
+  if (v === 0) { return Data$dMaybe.Nothing; }
+  if (v === 1) { return Data$dMaybe.$Maybe("Just", {head: Data$dEnum.toCharCode(Data$dString$dUnsafe.charAt(0)(s)), tail: ""}); }
+  const cu1 = Data$dEnum.toCharCode(Data$dString$dUnsafe.charAt(1)(s));
+  const cu0 = Data$dEnum.toCharCode(Data$dString$dUnsafe.charAt(0)(s));
+  if (55296 <= cu0 && cu0 <= 56319 && 56320 <= cu1 && cu1 <= 57343) {
+    return Data$dMaybe.$Maybe("Just", {head: (((cu0 - 55296 | 0) * 1024 | 0) + (cu1 - 56320 | 0) | 0) + 65536 | 0, tail: Data$dString$dCodeUnits.drop(2)(s)});
+  }
+  return Data$dMaybe.$Maybe("Just", {head: cu0, tail: Data$dString$dCodeUnits.drop(1)(s)});
+};
+const unconsButWithTuple = s => {
+  const $0 = uncons(s);
+  if ($0.tag === "Just") { return Data$dMaybe.$Maybe("Just", Data$dTuple.$Tuple($0._1.head, $0._1.tail)); }
+  return Data$dMaybe.Nothing;
+};
+const toCodePointArrayFallback = s => Data$dUnfoldable.unfoldableArray.unfoldr(unconsButWithTuple)(s);
+const unsafeCodePointAt0Fallback = s => {
+  const cu0 = Data$dEnum.toCharCode(Data$dString$dUnsafe.charAt(0)(s));
+  if (55296 <= cu0 && cu0 <= 56319 && Data$dString$dCodeUnits.length(s) > 1) {
+    const cu1 = Data$dEnum.toCharCode(Data$dString$dUnsafe.charAt(1)(s));
+    if (56320 <= cu1 && cu1 <= 57343) { return (((cu0 - 55296 | 0) * 1024 | 0) + (cu1 - 56320 | 0) | 0) + 65536 | 0; }
+  }
+  return cu0;
+};
+const unsafeCodePointAt0 = /* #__PURE__ */ _unsafeCodePointAt0(unsafeCodePointAt0Fallback);
+const toCodePointArray = /* #__PURE__ */ _toCodePointArray(toCodePointArrayFallback)(unsafeCodePointAt0);
+const length = x => toCodePointArray(x).length;
+const lastIndexOf = p => s => {
+  const $0 = Data$dString$dCodeUnits.lastIndexOf(p)(s);
+  if ($0.tag === "Just") { return Data$dMaybe.$Maybe("Just", toCodePointArray(Data$dString$dCodeUnits.take($0._1)(s)).length); }
+  return Data$dMaybe.Nothing;
+};
+const indexOf = p => s => {
+  const $0 = Data$dString$dCodeUnits.indexOf(p)(s);
+  if ($0.tag === "Just") { return Data$dMaybe.$Maybe("Just", toCodePointArray(Data$dString$dCodeUnits.take($0._1)(s)).length); }
+  return Data$dMaybe.Nothing;
+};
+const fromCharCode = x => Data$dString$dCodeUnits.singleton((() => {
+  if (x >= 0 && x <= 65535) { return Data$dEnum.fromCharCode(x); }
+  if (x < 0) { return "\u0000"; }
+  return "￿";
+})());
+const singletonFallback = v => {
+  if (v <= 65535) { return fromCharCode(v); }
+  return fromCharCode($runtime.intDiv(v - 65536 | 0, 1024) + 55296 | 0) + fromCharCode(Data$dEuclideanRing.intMod(v - 65536 | 0)(1024) + 56320 | 0);
+};
+const fromCodePointArray = /* #__PURE__ */ _fromCodePointArray(singletonFallback);
+const singleton = /* #__PURE__ */ _singleton(singletonFallback);
+const takeFallback = v => v1 => {
+  if (v < 1) { return ""; }
+  const v2 = uncons(v1);
+  if (v2.tag === "Just") { return singleton(v2._1.head) + takeFallback(v - 1 | 0)(v2._1.tail); }
+  return v1;
+};
+const take = /* #__PURE__ */ _take(takeFallback);
+const lastIndexOf$p = p => i => s => {
+  const $0 = Data$dString$dCodeUnits.lastIndexOf$p(p)(Data$dString$dCodeUnits.length(take(i)(s)))(s);
+  if ($0.tag === "Just") { return Data$dMaybe.$Maybe("Just", toCodePointArray(Data$dString$dCodeUnits.take($0._1)(s)).length); }
+  return Data$dMaybe.Nothing;
+};
+const splitAt = i => s => {
+  const before = take(i)(s);
+  return {before, after: Data$dString$dCodeUnits.drop(Data$dString$dCodeUnits.length(before))(s)};
+};
+const eqCodePoint = {eq: x => y => x === y};
+const ordCodePoint = {compare: x => y => Data$dOrd.ordInt.compare(x)(y), Eq0: () => eqCodePoint};
+const drop = n => s => Data$dString$dCodeUnits.drop(Data$dString$dCodeUnits.length(take(n)(s)))(s);
+const indexOf$p = p => i => s => {
+  const s$p = Data$dString$dCodeUnits.drop(Data$dString$dCodeUnits.length(take(i)(s)))(s);
+  const $0 = Data$dString$dCodeUnits.indexOf(p)(s$p);
+  if ($0.tag === "Just") { return Data$dMaybe.$Maybe("Just", i + toCodePointArray(Data$dString$dCodeUnits.take($0._1)(s$p)).length | 0); }
+  return Data$dMaybe.Nothing;
+};
+const countTail = countTail$a0$copy => countTail$a1$copy => countTail$a2$copy => {
+  let countTail$a0 = countTail$a0$copy, countTail$a1 = countTail$a1$copy, countTail$a2 = countTail$a2$copy, countTail$c = true, countTail$r;
+  while (countTail$c) {
+    const p = countTail$a0, s = countTail$a1, accum = countTail$a2;
+    const v = uncons(s);
+    if (v.tag === "Just" && p(v._1.head)) {
+      countTail$a0 = p;
+      countTail$a1 = v._1.tail;
+      countTail$a2 = accum + 1 | 0;
+      continue;
+    }
+    countTail$c = false;
+    countTail$r = accum;
+  }
+  return countTail$r;
+};
+const countFallback = p => s => countTail(p)(s)(0);
+const countPrefix = /* #__PURE__ */ _countPrefix(countFallback)(unsafeCodePointAt0);
+const dropWhile = p => s => Data$dString$dCodeUnits.drop(Data$dString$dCodeUnits.length(take(countPrefix(p)(s))(s)))(s);
+const takeWhile = p => s => take(countPrefix(p)(s))(s);
+const codePointFromChar = x => Data$dEnum.toCharCode(x);
+const codePointAtFallback = codePointAtFallback$a0$copy => codePointAtFallback$a1$copy => {
+  let codePointAtFallback$a0 = codePointAtFallback$a0$copy, codePointAtFallback$a1 = codePointAtFallback$a1$copy, codePointAtFallback$c = true, codePointAtFallback$r;
+  while (codePointAtFallback$c) {
+    const n = codePointAtFallback$a0, s = codePointAtFallback$a1;
+    const v = uncons(s);
+    if (v.tag === "Just") {
+      if (n === 0) {
+        codePointAtFallback$c = false;
+        codePointAtFallback$r = Data$dMaybe.$Maybe("Just", v._1.head);
+        continue;
+      }
+      codePointAtFallback$a0 = n - 1 | 0;
+      codePointAtFallback$a1 = v._1.tail;
+      continue;
+    }
+    codePointAtFallback$c = false;
+    codePointAtFallback$r = Data$dMaybe.Nothing;
+  }
+  return codePointAtFallback$r;
+};
+const codePointAt = v => v1 => {
+  if (v < 0) { return Data$dMaybe.Nothing; }
+  if (v === 0) {
+    if (v1 === "") { return Data$dMaybe.Nothing; }
+    return Data$dMaybe.$Maybe("Just", unsafeCodePointAt0(v1));
+  }
+  return _codePointAt(codePointAtFallback)(Data$dMaybe.Just)(Data$dMaybe.Nothing)(unsafeCodePointAt0)(v)(v1);
+};
+const boundedCodePoint = {bottom: 0, top: 1114111, Ord0: () => ordCodePoint};
+const boundedEnumCodePoint = {
+  cardinality: 1114112,
+  fromEnum: v => v,
+  toEnum: n => {
+    if (n >= 0 && n <= 1114111) { return Data$dMaybe.$Maybe("Just", n); }
+    return Data$dMaybe.Nothing;
+  },
+  Bounded0: () => boundedCodePoint,
+  Enum1: () => enumCodePoint
+};
+const enumCodePoint = {
+  succ: a => {
+    const $0 = a + 1 | 0;
+    if ($0 >= 0 && $0 <= 1114111) { return Data$dMaybe.$Maybe("Just", $0); }
+    return Data$dMaybe.Nothing;
+  },
+  pred: a => {
+    const $0 = a - 1 | 0;
+    if ($0 >= 0 && $0 <= 1114111) { return Data$dMaybe.$Maybe("Just", $0); }
+    return Data$dMaybe.Nothing;
+  },
+  Ord0: () => ordCodePoint
+};
+export {
+  boundedCodePoint,
+  boundedEnumCodePoint,
+  codePointAt,
+  codePointAtFallback,
+  codePointFromChar,
+  countFallback,
+  countPrefix,
+  countTail,
+  drop,
+  dropWhile,
+  enumCodePoint,
+  eqCodePoint,
+  fromCharCode,
+  fromCodePointArray,
+  indexOf,
+  indexOf$p,
+  lastIndexOf,
+  lastIndexOf$p,
+  length,
+  ordCodePoint,
+  showCodePoint,
+  singleton,
+  singletonFallback,
+  splitAt,
+  take,
+  takeFallback,
+  takeWhile,
+  toCodePointArray,
+  toCodePointArrayFallback,
+  uncons,
+  unconsButWithTuple,
+  unsafeCodePointAt0,
+  unsafeCodePointAt0Fallback
+};
+export * from "./foreign.js";

package/output-es/Data.String.CodeUnits/foreign.js

@@ -0,0 +1,116 @@
+export const fromCharArray = function (a) {
+  return a.join("");
+};
+
+export const toCharArray = function (s) {
+  return s.split("");
+};
+
+export const singleton = function (c) {
+  return c;
+};
+
+export const _charAt = function (just) {
+  return function (nothing) {
+    return function (i) {
+      return function (s) {
+        return i >= 0 && i < s.length ? just(s.charAt(i)) : nothing;
+      };
+    };
+  };
+};
+
+export const _toChar = function (just) {
+  return function (nothing) {
+    return function (s) {
+      return s.length === 1 ? just(s) : nothing;
+    };
+  };
+};
+
+export const length = function (s) {
+  return s.length;
+};
+
+export const countPrefix = function (p) {
+  return function (s) {
+    var i = 0;
+    while (i < s.length && p(s.charAt(i))) i++;
+    return i;
+  };
+};
+
+export const _indexOf = function (just) {
+  return function (nothing) {
+    return function (x) {
+      return function (s) {
+        var i = s.indexOf(x);
+        return i === -1 ? nothing : just(i);
+      };
+    };
+  };
+};
+
+export const _indexOfStartingAt = function (just) {
+  return function (nothing) {
+    return function (x) {
+      return function (startAt) {
+        return function (s) {
+          if (startAt < 0 || startAt > s.length) return nothing;
+          var i = s.indexOf(x, startAt);
+          return i === -1 ? nothing : just(i);
+        };
+      };
+    };
+  };
+};
+
+export const _lastIndexOf = function (just) {
+  return function (nothing) {
+    return function (x) {
+      return function (s) {
+        var i = s.lastIndexOf(x);
+        return i === -1 ? nothing : just(i);
+      };
+    };
+  };
+};
+
+export const _lastIndexOfStartingAt = function (just) {
+  return function (nothing) {
+    return function (x) {
+      return function (startAt) {
+        return function (s) {
+          var i = s.lastIndexOf(x, startAt);
+          return i === -1 ? nothing : just(i);
+        };
+      };
+    };
+  };
+};
+
+export const take = function (n) {
+  return function (s) {
+    return s.substr(0, n);
+  };
+};
+
+export const drop = function (n) {
+  return function (s) {
+    return s.substring(n);
+  };
+};
+
+export const slice = function (b) {
+  return function (e) {
+    return function (s) {
+      return s.slice(b,e);
+    };
+  };
+};
+
+export const splitAt = function (i) {
+  return function (s) {
+    return { before: s.substring(0, i), after: s.substring(i) };
+  };
+};

package/output-es/Data.String.CodeUnits/index.js

@@ -0,0 +1,55 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dString$dUnsafe from "../Data.String.Unsafe/index.js";
+import {
+  _charAt,
+  _indexOf,
+  _indexOfStartingAt,
+  _lastIndexOf,
+  _lastIndexOfStartingAt,
+  _toChar,
+  countPrefix,
+  drop,
+  fromCharArray,
+  length,
+  singleton,
+  slice,
+  splitAt,
+  take,
+  toCharArray
+} from "./foreign.js";
+const uncons = v => {
+  if (v === "") { return Data$dMaybe.Nothing; }
+  return Data$dMaybe.$Maybe("Just", {head: Data$dString$dUnsafe.charAt(0)(v), tail: drop(1)(v)});
+};
+const toChar = /* #__PURE__ */ _toChar(Data$dMaybe.Just)(Data$dMaybe.Nothing);
+const takeWhile = p => s => take(countPrefix(p)(s))(s);
+const takeRight = i => s => drop(length(s) - i | 0)(s);
+const stripSuffix = v => str => {
+  const v1 = splitAt(length(str) - length(v) | 0)(str);
+  if (v1.after === v) { return Data$dMaybe.$Maybe("Just", v1.before); }
+  return Data$dMaybe.Nothing;
+};
+const stripPrefix = v => str => {
+  const v1 = splitAt(length(v))(str);
+  if (v1.before === v) { return Data$dMaybe.$Maybe("Just", v1.after); }
+  return Data$dMaybe.Nothing;
+};
+const lastIndexOf$p = /* #__PURE__ */ _lastIndexOfStartingAt(Data$dMaybe.Just)(Data$dMaybe.Nothing);
+const lastIndexOf = /* #__PURE__ */ _lastIndexOf(Data$dMaybe.Just)(Data$dMaybe.Nothing);
+const indexOf$p = /* #__PURE__ */ _indexOfStartingAt(Data$dMaybe.Just)(Data$dMaybe.Nothing);
+const indexOf = /* #__PURE__ */ _indexOf(Data$dMaybe.Just)(Data$dMaybe.Nothing);
+const dropWhile = p => s => drop(countPrefix(p)(s))(s);
+const dropRight = i => s => take(length(s) - i | 0)(s);
+const contains = pat => {
+  const $0 = indexOf(pat);
+  return x => {
+    const $1 = $0(x);
+    if ($1.tag === "Nothing") { return false; }
+    if ($1.tag === "Just") { return true; }
+    $runtime.fail();
+  };
+};
+const charAt = /* #__PURE__ */ _charAt(Data$dMaybe.Just)(Data$dMaybe.Nothing);
+export {charAt, contains, dropRight, dropWhile, indexOf, indexOf$p, lastIndexOf, lastIndexOf$p, stripPrefix, stripSuffix, takeRight, takeWhile, toChar, uncons};
+export * from "./foreign.js";

package/output-es/Data.String.Common/foreign.js

@@ -0,0 +1,52 @@
+export const _localeCompare = function (lt) {
+  return function (eq) {
+    return function (gt) {
+      return function (s1) {
+        return function (s2) {
+          var result = s1.localeCompare(s2);
+          return result < 0 ? lt : result > 0 ? gt : eq;
+        };
+      };
+    };
+  };
+};
+
+export const replace = function (s1) {
+  return function (s2) {
+    return function (s3) {
+      return s3.replace(s1, s2);
+    };
+  };
+};
+
+export const replaceAll = function (s1) {
+  return function (s2) {
+    return function (s3) {
+      return s3.replace(new RegExp(s1.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&"), "g"), s2); // eslint-disable-line no-useless-escape
+    };
+  };
+};
+
+export const split = function (sep) {
+  return function (s) {
+    return s.split(sep);
+  };
+};
+
+export const toLower = function (s) {
+  return s.toLowerCase();
+};
+
+export const toUpper = function (s) {
+  return s.toUpperCase();
+};
+
+export const trim = function (s) {
+  return s.trim();
+};
+
+export const joinWith = function (s) {
+  return function (xs) {
+    return xs.join(s);
+  };
+};

package/output-es/Data.String.Common/index.js

@@ -0,0 +1,6 @@
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+import {_localeCompare, joinWith, replace, replaceAll, split, toLower, toUpper, trim} from "./foreign.js";
+const $$null = s => s === "";
+const localeCompare = /* #__PURE__ */ _localeCompare(Data$dOrdering.LT)(Data$dOrdering.EQ)(Data$dOrdering.GT);
+export {localeCompare, $$null as null};
+export * from "./foreign.js";