@explorable-viz/fluid 0.12.3 → 0.12.4

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

@@ -0,0 +1,26 @@
+import * as $runtime from "../runtime.js";
+import * as Control$dMonad$dGen from "../Control.Monad.Gen/index.js";
+import * as Data$dChar$dGen from "../Data.Char.Gen/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$dUnfoldable from "../Data.Unfoldable/index.js";
+const max = x => y => {
+  const v = Data$dOrd.ordInt.compare(x)(y);
+  if (v === "LT") { return y; }
+  if (v === "EQ") { return x; }
+  if (v === "GT") { return x; }
+  $runtime.fail();
+};
+const genString = dictMonadRec => dictMonadGen => {
+  const Bind1 = dictMonadGen.Monad0().Bind1();
+  const unfoldable1 = Control$dMonad$dGen.unfoldable(dictMonadRec)(dictMonadGen)(Data$dUnfoldable.unfoldableArray);
+  return genChar => dictMonadGen.sized(size => Bind1.bind(dictMonadGen.chooseInt(1)(max(1)(size)))(newSize => dictMonadGen.resize(v => newSize)(Bind1.Apply0().Functor0().map(Data$dString$dCodeUnits.fromCharArray)(unfoldable1(genChar)))));
+};
+const genUnicodeString = dictMonadRec => dictMonadGen => genString(dictMonadRec)(dictMonadGen)(Data$dChar$dGen.genUnicodeChar(dictMonadGen));
+const genDigitString = dictMonadRec => dictMonadGen => genString(dictMonadRec)(dictMonadGen)(Data$dChar$dGen.genDigitChar(dictMonadGen));
+const genAsciiString$p = dictMonadRec => dictMonadGen => genString(dictMonadRec)(dictMonadGen)(Data$dChar$dGen.genAsciiChar$p(dictMonadGen));
+const genAsciiString = dictMonadRec => dictMonadGen => genString(dictMonadRec)(dictMonadGen)(Data$dChar$dGen.genAsciiChar(dictMonadGen));
+const genAlphaUppercaseString = dictMonadRec => dictMonadGen => genString(dictMonadRec)(dictMonadGen)(Data$dChar$dGen.genAlphaUppercase(dictMonadGen));
+const genAlphaString = dictMonadRec => dictMonadGen => genString(dictMonadRec)(dictMonadGen)(Data$dChar$dGen.genAlpha(dictMonadGen));
+const genAlphaLowercaseString = dictMonadRec => dictMonadGen => genString(dictMonadRec)(dictMonadGen)(Data$dChar$dGen.genAlphaLowercase(dictMonadGen));
+export {genAlphaLowercaseString, genAlphaString, genAlphaUppercaseString, genAsciiString, genAsciiString$p, genDigitString, genString, genUnicodeString, max};

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

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

package/output-es/Data.String.NonEmpty.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 CaseInsensitiveNonEmptyString = x => x;
+const showCaseInsensitiveNonEmptyString = {show: v => "(CaseInsensitiveNonEmptyString (NonEmptyString.unsafeFromString " + Data$dShow.showStringImpl(v) + "))"};
+const newtypeCaseInsensitiveNonEmptyString = {Coercible0: () => {}};
+const eqCaseInsensitiveNonEmptyString = {eq: v => v1 => Data$dString$dCommon.toLower(v) === Data$dString$dCommon.toLower(v1)};
+const ordCaseInsensitiveNonEmptyString = {
+  compare: v => v1 => Data$dOrd.ordString.compare(Data$dString$dCommon.toLower(v))(Data$dString$dCommon.toLower(v1)),
+  Eq0: () => eqCaseInsensitiveNonEmptyString
+};
+export {CaseInsensitiveNonEmptyString, eqCaseInsensitiveNonEmptyString, newtypeCaseInsensitiveNonEmptyString, ordCaseInsensitiveNonEmptyString, showCaseInsensitiveNonEmptyString};

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

@@ -0,0 +1,89 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dSemigroup from "../Data.Semigroup/index.js";
+import * as Data$dString$dCodePoints from "../Data.String.CodePoints/index.js";
+import * as Data$dString$dCodeUnits from "../Data.String.CodeUnits/index.js";
+const snoc = c => s => s + Data$dString$dCodePoints.singleton(c);
+const singleton = x => Data$dString$dCodePoints.singleton(x);
+const takeWhile = f => x => {
+  const $0 = Data$dString$dCodePoints.take(Data$dString$dCodePoints.countPrefix(f)(x))(x);
+  if ($0 === "") { return Data$dMaybe.Nothing; }
+  return Data$dMaybe.$Maybe("Just", $0);
+};
+const lastIndexOf$p = pat => x => v => Data$dString$dCodePoints.lastIndexOf$p(pat)(x)(v);
+const lastIndexOf = x => v => Data$dString$dCodePoints.lastIndexOf(x)(v);
+const indexOf$p = pat => x => v => Data$dString$dCodePoints.indexOf$p(pat)(x)(v);
+const indexOf = x => v => Data$dString$dCodePoints.indexOf(x)(v);
+const length = x => Data$dString$dCodePoints.toCodePointArray(x).length;
+const splitAt = i => nes => {
+  const v = Data$dString$dCodePoints.splitAt(i)(nes);
+  return {before: v.before === "" ? Data$dMaybe.Nothing : Data$dMaybe.$Maybe("Just", v.before), after: v.after === "" ? Data$dMaybe.Nothing : Data$dMaybe.$Maybe("Just", v.after)};
+};
+const take = i => nes => {
+  if (i < 1) { return Data$dMaybe.Nothing; }
+  return Data$dMaybe.$Maybe("Just", Data$dString$dCodePoints.take(i)(nes));
+};
+const toCodePointArray = x => Data$dString$dCodePoints.toCodePointArray(x);
+const toNonEmptyCodePointArray = x => {
+  const $0 = Data$dString$dCodePoints.toCodePointArray(x);
+  if ($0.length > 0) { return $0; }
+  $runtime.fail();
+};
+const uncons = nes => (
+  {
+    head: (() => {
+      const $0 = Data$dString$dCodePoints.codePointAt(0)(nes);
+      if ($0.tag === "Just") { return $0._1; }
+      $runtime.fail();
+    })(),
+    tail: (() => {
+      const $0 = Data$dString$dCodeUnits.drop(Data$dString$dCodeUnits.length(Data$dString$dCodePoints.take(1)(nes)))(nes);
+      if ($0 === "") { return Data$dMaybe.Nothing; }
+      return Data$dMaybe.$Maybe("Just", $0);
+    })()
+  }
+);
+const fromFoldable1 = dictFoldable1 => dictFoldable1.foldMap1(Data$dSemigroup.semigroupString)(singleton);
+const fromCodePointArray = v => {
+  if (v.length === 0) { return Data$dMaybe.Nothing; }
+  return Data$dMaybe.$Maybe("Just", Data$dString$dCodePoints.fromCodePointArray(v));
+};
+const fromNonEmptyCodePointArray = x => {
+  if (x.length === 0) { $runtime.fail(); }
+  return Data$dString$dCodePoints.fromCodePointArray(x);
+};
+const dropWhile = f => x => {
+  const $0 = Data$dString$dCodePoints.dropWhile(f)(x);
+  if ($0 === "") { return Data$dMaybe.Nothing; }
+  return Data$dMaybe.$Maybe("Just", $0);
+};
+const drop = i => nes => {
+  if (i >= Data$dString$dCodePoints.toCodePointArray(nes).length) { return Data$dMaybe.Nothing; }
+  return Data$dMaybe.$Maybe("Just", Data$dString$dCodeUnits.drop(Data$dString$dCodeUnits.length(Data$dString$dCodePoints.take(i)(nes)))(nes));
+};
+const countPrefix = x => Data$dString$dCodePoints.countPrefix(x);
+const cons = c => s => Data$dString$dCodePoints.singleton(c) + s;
+const codePointAt = x => v => Data$dString$dCodePoints.codePointAt(x)(v);
+export {
+  codePointAt,
+  cons,
+  countPrefix,
+  drop,
+  dropWhile,
+  fromCodePointArray,
+  fromFoldable1,
+  fromNonEmptyCodePointArray,
+  indexOf,
+  indexOf$p,
+  lastIndexOf,
+  lastIndexOf$p,
+  length,
+  singleton,
+  snoc,
+  splitAt,
+  take,
+  takeWhile,
+  toCodePointArray,
+  toNonEmptyCodePointArray,
+  uncons
+};

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

@@ -0,0 +1,98 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dSemigroup from "../Data.Semigroup/index.js";
+import * as Data$dSemigroup$dFoldable from "../Data.Semigroup.Foldable/index.js";
+import * as Data$dString$dCodeUnits from "../Data.String.CodeUnits/index.js";
+import * as Data$dString$dUnsafe from "../Data.String.Unsafe/index.js";
+const snoc = c => s => s + Data$dString$dCodeUnits.singleton(c);
+const singleton = x => Data$dString$dCodeUnits.singleton(x);
+const takeWhile = f => x => {
+  const $0 = Data$dString$dCodeUnits.take(Data$dString$dCodeUnits.countPrefix(f)(x))(x);
+  if ($0 === "") { return Data$dMaybe.Nothing; }
+  return Data$dMaybe.$Maybe("Just", $0);
+};
+const lastIndexOf$p = pat => Data$dString$dCodeUnits.lastIndexOf$p(pat);
+const lastIndexOf = x => Data$dString$dCodeUnits.lastIndexOf(x);
+const indexOf$p = pat => Data$dString$dCodeUnits.indexOf$p(pat);
+const indexOf = x => Data$dString$dCodeUnits.indexOf(x);
+const length = x => Data$dString$dCodeUnits.length(x);
+const splitAt = i => nes => {
+  const v = Data$dString$dCodeUnits.splitAt(i)(nes);
+  return {before: v.before === "" ? Data$dMaybe.Nothing : Data$dMaybe.$Maybe("Just", v.before), after: v.after === "" ? Data$dMaybe.Nothing : Data$dMaybe.$Maybe("Just", v.after)};
+};
+const take = i => nes => {
+  if (i < 1) { return Data$dMaybe.Nothing; }
+  return Data$dMaybe.$Maybe("Just", Data$dString$dCodeUnits.take(i)(nes));
+};
+const takeRight = i => nes => {
+  if (i < 1) { return Data$dMaybe.Nothing; }
+  return Data$dMaybe.$Maybe("Just", Data$dString$dCodeUnits.drop(Data$dString$dCodeUnits.length(nes) - i | 0)(nes));
+};
+const toChar = x => Data$dString$dCodeUnits.toChar(x);
+const toCharArray = x => Data$dString$dCodeUnits.toCharArray(x);
+const toNonEmptyCharArray = x => {
+  const $0 = Data$dString$dCodeUnits.toCharArray(x);
+  if ($0.length > 0) { return $0; }
+  $runtime.fail();
+};
+const uncons = nes => (
+  {
+    head: Data$dString$dUnsafe.charAt(0)(nes),
+    tail: (() => {
+      const $0 = Data$dString$dCodeUnits.drop(1)(nes);
+      if ($0 === "") { return Data$dMaybe.Nothing; }
+      return Data$dMaybe.$Maybe("Just", $0);
+    })()
+  }
+);
+const fromFoldable1 = dictFoldable1 => dictFoldable1.foldMap1(Data$dSemigroup.semigroupString)(Data$dSemigroup$dFoldable.identity);
+const fromCharArray = v => {
+  if (v.length === 0) { return Data$dMaybe.Nothing; }
+  return Data$dMaybe.$Maybe("Just", Data$dString$dCodeUnits.fromCharArray(v));
+};
+const fromNonEmptyCharArray = x => {
+  if (x.length === 0) { $runtime.fail(); }
+  return Data$dString$dCodeUnits.fromCharArray(x);
+};
+const dropWhile = f => x => {
+  const $0 = Data$dString$dCodeUnits.drop(Data$dString$dCodeUnits.countPrefix(f)(x))(x);
+  if ($0 === "") { return Data$dMaybe.Nothing; }
+  return Data$dMaybe.$Maybe("Just", $0);
+};
+const dropRight = i => nes => {
+  if (i >= Data$dString$dCodeUnits.length(nes)) { return Data$dMaybe.Nothing; }
+  return Data$dMaybe.$Maybe("Just", Data$dString$dCodeUnits.take(Data$dString$dCodeUnits.length(nes) - i | 0)(nes));
+};
+const drop = i => nes => {
+  if (i >= Data$dString$dCodeUnits.length(nes)) { return Data$dMaybe.Nothing; }
+  return Data$dMaybe.$Maybe("Just", Data$dString$dCodeUnits.drop(i)(nes));
+};
+const countPrefix = x => Data$dString$dCodeUnits.countPrefix(x);
+const cons = c => s => Data$dString$dCodeUnits.singleton(c) + s;
+const charAt = x => Data$dString$dCodeUnits.charAt(x);
+export {
+  charAt,
+  cons,
+  countPrefix,
+  drop,
+  dropRight,
+  dropWhile,
+  fromCharArray,
+  fromFoldable1,
+  fromNonEmptyCharArray,
+  indexOf,
+  indexOf$p,
+  lastIndexOf,
+  lastIndexOf$p,
+  length,
+  singleton,
+  snoc,
+  splitAt,
+  take,
+  takeRight,
+  takeWhile,
+  toChar,
+  toCharArray,
+  toNonEmptyCharArray,
+  uncons
+};

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

@@ -0,0 +1,119 @@
+// | While most of the code in this module is safe, this module does
+// | export a few partial functions and the `NonEmptyString` constructor.
+// | While the partial functions are obvious from the `Partial` constraint in
+// | their type signature, the `NonEmptyString` constructor can be overlooked
+// | when searching for issues in one's code. See the constructor's
+// | documentation for more information.
+import * as $runtime from "../runtime.js";
+import * as Data$dEq from "../Data.Eq/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dSemigroup from "../Data.Semigroup/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Data$dString$dCodeUnits from "../Data.String.CodeUnits/index.js";
+import * as Data$dString$dCommon from "../Data.String.Common/index.js";
+const NonEmptyString = x => x;
+const NonEmptyReplacement = x => x;
+const toUpper = v => Data$dString$dCommon.toUpper(v);
+const toString = v => v;
+const toLower = v => Data$dString$dCommon.toLower(v);
+const showNonEmptyString = {show: v => "(NonEmptyString.unsafeFromString " + Data$dShow.showStringImpl(v) + ")"};
+const showNonEmptyReplacement = {show: v => "(NonEmptyReplacement (NonEmptyString.unsafeFromString " + Data$dShow.showStringImpl(v) + "))"};
+const semigroupNonEmptyString = Data$dSemigroup.semigroupString;
+const semigroupNonEmptyReplacement = Data$dSemigroup.semigroupString;
+const replaceAll = pat => v => v1 => Data$dString$dCommon.replaceAll(pat)(v)(v1);
+const replace = pat => v => v1 => Data$dString$dCommon.replace(pat)(v)(v1);
+const prependString = s1 => v => s1 + v;
+const ordNonEmptyString = Data$dOrd.ordString;
+const ordNonEmptyReplacement = Data$dOrd.ordString;
+const nonEmptyNonEmpty = dictIsSymbol => ({nes: p => dictIsSymbol.reflectSymbol(p)});
+const nes = dict => dict.nes;
+const makeNonEmptyBad = () => ({nes: v => ""});
+const localeCompare = v => v1 => Data$dString$dCommon.localeCompare(v)(v1);
+const liftS = f => v => f(v);
+const joinWith1 = dictFoldable1 => {
+  const $0 = dictFoldable1.Foldable0();
+  return sep => xs => $0.foldl(v => v1 => {
+    if (v.init) { return {init: false, acc: v1}; }
+    return {init: false, acc: v.acc + sep + v1};
+  })({init: true, acc: ""})(xs).acc;
+};
+const joinWith = dictFoldable => splice => xs => dictFoldable.foldl(v => v1 => {
+  if (v.init) { return {init: false, acc: v1}; }
+  return {init: false, acc: v.acc + splice + v1};
+})({init: true, acc: ""})(xs).acc;
+const join1With = dictFoldable1 => {
+  const $0 = dictFoldable1.Foldable0();
+  return splice => xs => $0.foldl(v => v1 => {
+    if (v.init) { return {init: false, acc: v1}; }
+    return {init: false, acc: v.acc + splice + v1};
+  })({init: true, acc: ""})(xs).acc;
+};
+const fromString = v => {
+  if (v === "") { return Data$dMaybe.Nothing; }
+  return Data$dMaybe.$Maybe("Just", v);
+};
+const stripPrefix = pat => a => {
+  const $0 = Data$dString$dCodeUnits.stripPrefix(pat)(a);
+  if ($0.tag === "Just") {
+    if ($0._1 === "") { return Data$dMaybe.Nothing; }
+    return Data$dMaybe.$Maybe("Just", $0._1);
+  }
+  if ($0.tag === "Nothing") { return Data$dMaybe.Nothing; }
+  $runtime.fail();
+};
+const stripSuffix = pat => a => {
+  const $0 = Data$dString$dCodeUnits.stripSuffix(pat)(a);
+  if ($0.tag === "Just") {
+    if ($0._1 === "") { return Data$dMaybe.Nothing; }
+    return Data$dMaybe.$Maybe("Just", $0._1);
+  }
+  if ($0.tag === "Nothing") { return Data$dMaybe.Nothing; }
+  $runtime.fail();
+};
+const trim = v => {
+  const $0 = Data$dString$dCommon.trim(v);
+  if ($0 === "") { return Data$dMaybe.Nothing; }
+  return Data$dMaybe.$Maybe("Just", $0);
+};
+const unsafeFromString = () => x => {
+  if (x === "") { $runtime.fail(); }
+  return x;
+};
+const eqNonEmptyString = Data$dEq.eqString;
+const eqNonEmptyReplacement = Data$dEq.eqString;
+const contains = x => Data$dString$dCodeUnits.contains(x);
+const appendString = v => s2 => v + s2;
+export {
+  NonEmptyReplacement,
+  NonEmptyString,
+  appendString,
+  contains,
+  eqNonEmptyReplacement,
+  eqNonEmptyString,
+  fromString,
+  join1With,
+  joinWith,
+  joinWith1,
+  liftS,
+  localeCompare,
+  makeNonEmptyBad,
+  nes,
+  nonEmptyNonEmpty,
+  ordNonEmptyReplacement,
+  ordNonEmptyString,
+  prependString,
+  replace,
+  replaceAll,
+  semigroupNonEmptyReplacement,
+  semigroupNonEmptyString,
+  showNonEmptyReplacement,
+  showNonEmptyString,
+  stripPrefix,
+  stripSuffix,
+  toLower,
+  toString,
+  toUpper,
+  trim,
+  unsafeFromString
+};

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

@@ -0,0 +1,13 @@
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+const Replacement = x => x;
+const Pattern = x => x;
+const showReplacement = {show: v => "(Replacement " + Data$dShow.showStringImpl(v) + ")"};
+const showPattern = {show: v => "(Pattern " + Data$dShow.showStringImpl(v) + ")"};
+const newtypeReplacement = {Coercible0: () => {}};
+const newtypePattern = {Coercible0: () => {}};
+const eqReplacement = {eq: x => y => x === y};
+const ordReplacement = {compare: x => y => Data$dOrd.ordString.compare(x)(y), Eq0: () => eqReplacement};
+const eqPattern = {eq: x => y => x === y};
+const ordPattern = {compare: x => y => Data$dOrd.ordString.compare(x)(y), Eq0: () => eqPattern};
+export {Pattern, Replacement, eqPattern, eqReplacement, newtypePattern, newtypeReplacement, ordPattern, ordReplacement, showPattern, showReplacement};

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

@@ -0,0 +1,103 @@
+export const showRegexImpl = function (r) {
+  return "" + r;
+};
+
+export const regexImpl = function (left) {
+  return function (right) {
+    return function (s1) {
+      return function (s2) {
+        try {
+          return right(new RegExp(s1, s2));
+        } catch (e) {
+          return left(e.message);
+        }
+      };
+    };
+  };
+};
+
+export const source = function (r) {
+  return r.source;
+};
+
+export const flagsImpl = function (r) {
+  return {
+    multiline: r.multiline,
+    ignoreCase: r.ignoreCase,
+    global: r.global,
+    dotAll: r.dotAll,
+    sticky: !!r.sticky,
+    unicode: !!r.unicode
+  };
+};
+
+export const test = function (r) {
+  return function (s) {
+    var lastIndex = r.lastIndex;
+    var result = r.test(s);
+    r.lastIndex = lastIndex;
+    return result;
+  };
+};
+
+export const _match = function (just) {
+  return function (nothing) {
+    return function (r) {
+      return function (s) {
+        var m = s.match(r);
+        if (m == null || m.length === 0) {
+          return nothing;
+        } else {
+          for (var i = 0; i < m.length; i++) {
+            m[i] = m[i] == null ? nothing : just(m[i]);
+          }
+          return just(m);
+        }
+      };
+    };
+  };
+};
+
+export const replace = function (r) {
+  return function (s1) {
+    return function (s2) {
+      return s2.replace(r, s1);
+    };
+  };
+};
+
+export const _replaceBy = function (just) {
+  return function (nothing) {
+    return function (r) {
+      return function (f) {
+        return function (s) {
+          return s.replace(r, function (match) {
+            var groups = [];
+            var group, i = 1;
+            while (typeof (group = arguments[i++]) !== "number") {
+              groups.push(group == null ? nothing : just(group));
+            }
+            return f(match)(groups);
+          });
+        };
+      };
+    };
+  };
+};
+
+export const _search = function (just) {
+  return function (nothing) {
+    return function (r) {
+      return function (s) {
+        var result = s.search(r);
+        return result === -1 ? nothing : just(result);
+      };
+    };
+  };
+};
+
+export const split = function (r) {
+  return function (s) {
+    return s.split(r);
+  };
+};

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

@@ -0,0 +1,28 @@
+// | Wraps Javascript's `RegExp` object that enables matching strings with
+// | patterns defined by regular expressions.
+// | For details of the underlying implementation, see [RegExp Reference at MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp).
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dString$dCodeUnits from "../Data.String.CodeUnits/index.js";
+import {_match, _replaceBy, _search, flagsImpl, regexImpl, replace, showRegexImpl, source, split, test} from "./foreign.js";
+const showRegex = {show: showRegexImpl};
+const search = /* #__PURE__ */ _search(Data$dMaybe.Just)(Data$dMaybe.Nothing);
+const replace$p = /* #__PURE__ */ _replaceBy(Data$dMaybe.Just)(Data$dMaybe.Nothing);
+const renderFlags = v => (v.global ? "g" : "") + (v.ignoreCase ? "i" : "") + (v.multiline ? "m" : "") + (v.dotAll ? "s" : "") + (v.sticky ? "y" : "") + (v.unicode ? "u" : "");
+const regex = s => f => regexImpl(Data$dEither.Left)(Data$dEither.Right)(s)((f.global ? "g" : "") + (f.ignoreCase ? "i" : "") + (f.multiline ? "m" : "") + (f.dotAll ? "s" : "") + (f.sticky
+  ? "y"
+  : "") + (f.unicode ? "u" : ""));
+const parseFlags = s => (
+  {
+    global: Data$dString$dCodeUnits.contains("g")(s),
+    ignoreCase: Data$dString$dCodeUnits.contains("i")(s),
+    multiline: Data$dString$dCodeUnits.contains("m")(s),
+    dotAll: Data$dString$dCodeUnits.contains("s")(s),
+    sticky: Data$dString$dCodeUnits.contains("y")(s),
+    unicode: Data$dString$dCodeUnits.contains("u")(s)
+  }
+);
+const match = /* #__PURE__ */ _match(Data$dMaybe.Just)(Data$dMaybe.Nothing);
+const flags = x => flagsImpl(x);
+export {flags, match, parseFlags, regex, renderFlags, replace$p, search, showRegex};
+export * from "./foreign.js";

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

@@ -0,0 +1,44 @@
+import * as Data$dEq from "../Data.Eq/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dString$dCommon from "../Data.String.Common/index.js";
+const eq = /* #__PURE__ */ Data$dEq.eqArrayImpl(Data$dEq.eqStringImpl);
+const RegexFlags = x => x;
+const unicode = {global: false, ignoreCase: false, multiline: false, dotAll: false, sticky: false, unicode: true};
+const sticky = {global: false, ignoreCase: false, multiline: false, dotAll: false, sticky: true, unicode: false};
+const showRegexFlags = {
+  show: v => {
+    const usedFlags = [
+      ...Data$dFunctor.arrayMap(v$1 => "global")(v.global ? [undefined] : []),
+      ...Data$dFunctor.arrayMap(v$1 => "ignoreCase")(v.ignoreCase ? [undefined] : []),
+      ...Data$dFunctor.arrayMap(v$1 => "multiline")(v.multiline ? [undefined] : []),
+      ...Data$dFunctor.arrayMap(v$1 => "dotAll")(v.dotAll ? [undefined] : []),
+      ...Data$dFunctor.arrayMap(v$1 => "sticky")(v.sticky ? [undefined] : []),
+      ...Data$dFunctor.arrayMap(v$1 => "unicode")(v.unicode ? [undefined] : [])
+    ];
+    if (eq(usedFlags)([])) { return "noFlags"; }
+    return "(" + Data$dString$dCommon.joinWith(" <> ")(usedFlags) + ")";
+  }
+};
+const semigroupRegexFlags = {
+  append: v => v1 => (
+    {
+      global: v.global || v1.global,
+      ignoreCase: v.ignoreCase || v1.ignoreCase,
+      multiline: v.multiline || v1.multiline,
+      dotAll: v.dotAll || v1.dotAll,
+      sticky: v.sticky || v1.sticky,
+      unicode: v.unicode || v1.unicode
+    }
+  )
+};
+const noFlags = {global: false, ignoreCase: false, multiline: false, dotAll: false, sticky: false, unicode: false};
+const newtypeRegexFlags = {Coercible0: () => {}};
+const multiline = {global: false, ignoreCase: false, multiline: true, dotAll: false, sticky: false, unicode: false};
+const monoidRegexFlags = {mempty: noFlags, Semigroup0: () => semigroupRegexFlags};
+const ignoreCase = {global: false, ignoreCase: true, multiline: false, dotAll: false, sticky: false, unicode: false};
+const global = {global: true, ignoreCase: false, multiline: false, dotAll: false, sticky: false, unicode: false};
+const eqRegexFlags = {
+  eq: ra => rb => ra.dotAll === rb.dotAll && ra.global === rb.global && ra.ignoreCase === rb.ignoreCase && ra.multiline === rb.multiline && ra.sticky === rb.sticky && ra.unicode === rb.unicode
+};
+const dotAll = {global: false, ignoreCase: false, multiline: false, dotAll: true, sticky: false, unicode: false};
+export {RegexFlags, dotAll, eq, eqRegexFlags, global, ignoreCase, monoidRegexFlags, multiline, newtypeRegexFlags, noFlags, semigroupRegexFlags, showRegexFlags, sticky, unicode};

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

@@ -0,0 +1,10 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dString$dRegex from "../Data.String.Regex/index.js";
+import * as Partial from "../Partial/index.js";
+const unsafeRegex = s => f => {
+  const $0 = Data$dString$dRegex.regex(s)(f);
+  if ($0.tag === "Left") { return Partial._crashWith($0._1); }
+  if ($0.tag === "Right") { return $0._1; }
+  $runtime.fail();
+};
+export {unsafeRegex};

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

@@ -0,0 +1,18 @@
+import * as Control$dBind from "../Control.Bind/index.js";
+import * as Data$dCodePoint$dUnicode$dInternal from "../Data.CodePoint.Unicode.Internal/index.js";
+import * as Data$dCodePoint$dUnicode$dInternal$dCasing from "../Data.CodePoint.Unicode.Internal.Casing/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dString$dCodePoints from "../Data.String.CodePoints/index.js";
+const convertFull = f => x => Data$dString$dCodePoints.fromCodePointArray(Control$dBind.arrayBind(Data$dString$dCodePoints.toCodePointArray(x))(f));
+const toLower = /* #__PURE__ */ convertFull(Data$dCodePoint$dUnicode$dInternal$dCasing.lower);
+const toUpper = /* #__PURE__ */ convertFull(Data$dCodePoint$dUnicode$dInternal$dCasing.upper);
+const convert = f => {
+  const $0 = Data$dFunctor.arrayMap(f);
+  return x => Data$dString$dCodePoints.fromCodePointArray($0(Data$dString$dCodePoints.toCodePointArray(x)));
+};
+const toLowerSimple = /* #__PURE__ */ convert(Data$dCodePoint$dUnicode$dInternal.uTowlower);
+const toUpperSimple = /* #__PURE__ */ convert(Data$dCodePoint$dUnicode$dInternal.uTowupper);
+const caseFoldSimple = /* #__PURE__ */ convert(Data$dCodePoint$dUnicode$dInternal$dCasing.fold);
+const caseFold = /* #__PURE__ */ convertFull(Data$dCodePoint$dUnicode$dInternal$dCasing.foldFull);
+const caselessMatch = s1 => s2 => Data$dString$dCodePoints.fromCodePointArray(Control$dBind.arrayBind(Data$dString$dCodePoints.toCodePointArray(s1))(Data$dCodePoint$dUnicode$dInternal$dCasing.foldFull)) === Data$dString$dCodePoints.fromCodePointArray(Control$dBind.arrayBind(Data$dString$dCodePoints.toCodePointArray(s2))(Data$dCodePoint$dUnicode$dInternal$dCasing.foldFull));
+export {caseFold, caseFoldSimple, caselessMatch, convert, convertFull, toLower, toLowerSimple, toUpper, toUpperSimple};

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

@@ -0,0 +1,11 @@
+export const charAt = function (i) {
+  return function (s) {
+    if (i >= 0 && i < s.length) return s.charAt(i);
+    throw new Error("Data.String.Unsafe.charAt: Invalid index.");
+  };
+};
+
+export const char = function (s) {
+  if (s.length === 1) return s.charAt(0);
+  throw new Error("Data.String.Unsafe.char: Expected string of length 1.");
+};

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

@@ -0,0 +1,4 @@
+// | Unsafe string and character functions.
+import {char as $$char, charAt} from "./foreign.js";
+export {};
+export * from "./foreign.js";

package/output-es/Data.Symbol/foreign.js

@@ -0,0 +1,6 @@
+// module Data.Symbol
+
+export const unsafeCoerce = function (arg) {
+  return arg;
+};
+

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

@@ -0,0 +1,6 @@
+import * as Type$dProxy from "../Type.Proxy/index.js";
+import {unsafeCoerce} from "./foreign.js";
+const reifySymbol = s => f => unsafeCoerce(dictIsSymbol => f(dictIsSymbol))({reflectSymbol: v => s})(Type$dProxy.Proxy);
+const reflectSymbol = dict => dict.reflectSymbol;
+export {reflectSymbol, reifySymbol};
+export * from "./foreign.js";