functionalscript 0.35.2 → 0.37.0

package/fs/types/btree/set/proof.f.js

@@ -1,7 +1,7 @@
-import { set as setSet } from "./module.f.js";
-import { cmp } from "../../string/module.f.js";
-import { stringify } from "../../../json/module.f.js";
-import { sort } from "../../object/module.f.js";
+import { set as setSet } from './module.f.js';
+import { cmp } from '../../string/module.f.js';
+import { stringify } from '../../../media/json/module.f.js';
+import { sort } from '../../object/module.f.js';
 const set = (node) => (value) => setSet(cmp(value))(() => value)(node);
 const jsonStr = stringify(sort);
 const test = [

package/fs/types/byte_set/module.f.js

@@ -3,8 +3,8 @@
  *
  * @module
  */
-import { compose } from "../function/module.f.js";
-import { reverse, countdown, flat, map } from "../list/module.f.js";
+import { compose } from '../function/module.f.js';
+import { reverse, countdown, flat, map } from '../list/module.f.js';
 export const has = n => s => ((s >> BigInt(n)) & 1n) === 1n;
 // create a set
 export const empty = 0n;

package/fs/types/byte_set/proof.f.js

@@ -1,7 +1,7 @@
-import { has, empty, set, setRange, unset, universe, complement, toRangeMap } from "./module.f.js";
-import { every, countdown, map, toArray } from "../list/module.f.js";
-import { stringify as jsonStringify } from "../../json/module.f.js";
-import { sort } from "../object/module.f.js";
+import { has, empty, set, setRange, unset, universe, complement, toRangeMap } from './module.f.js';
+import { every, countdown, map, toArray } from '../list/module.f.js';
+import { stringify as jsonStringify } from '../../media/json/module.f.js';
+import { sort } from '../object/module.f.js';
 const stringify = jsonStringify(sort);
 export const proof = {
     has: [

package/fs/types/function/compare/proof.f.js

@@ -1,4 +1,4 @@
-import { cmp, min, max } from "./module.f.js";
+import { cmp, min, max } from './module.f.js';
 export const proof = () => {
     {
         const result = cmp(true)(false);

package/fs/types/function/operator/proof.f.d.ts

@@ -1,12 +1,23 @@
+declare const joinTest: () => void;
+declare const concatTest: () => void;
+declare const logicalNotTest: () => void;
+declare const strictEqualTest: () => void;
+declare const additionTest: () => void;
+declare const incrementTest: () => void;
+declare const foldToScanTest: () => void;
+declare const reduceToScanTest: () => void;
+declare const counterTest: () => void;
+declare const stateScanToScanTest: () => void;
 export declare const proof: {
-    joinTest: () => void;
-    concatTest: () => void;
-    logicalNotTest: () => void;
-    strictEqualTest: () => void;
-    additionTest: () => void;
-    incrementTest: () => void;
-    counterTest: () => void;
-    stateScanToScanTest: () => void;
-    foldToScanTest: () => void;
-    reduceToScanTest: () => void;
+    joinTest: typeof joinTest;
+    concatTest: typeof concatTest;
+    logicalNotTest: typeof logicalNotTest;
+    strictEqualTest: typeof strictEqualTest;
+    additionTest: typeof additionTest;
+    incrementTest: typeof incrementTest;
+    counterTest: typeof counterTest;
+    stateScanToScanTest: typeof stateScanToScanTest;
+    foldToScanTest: typeof foldToScanTest;
+    reduceToScanTest: typeof reduceToScanTest;
 };
+export {};

package/fs/types/function/operator/proof.f.js

@@ -1,4 +1,4 @@
-import { join, concat, logicalNot, strictEqual, addition, increment, counter, stateScanToScan, foldToScan, reduceToScan, } from "./module.f.js";
+import { join, concat, logicalNot, strictEqual, addition, increment, counter, stateScanToScan, foldToScan, reduceToScan, } from './module.f.js';
 const joinTest = () => {
     const result = join(', ')('world')('hello');
     if (result !== 'hello, world') {

package/fs/types/function/proof.f.js

@@ -1,4 +1,4 @@
-import { fn } from "./module.f.js";
+import { fn } from './module.f.js';
 export const proof = () => {
     const f = x => [x];
     const g = ([x]) => [x.length];

package/fs/types/list/module.f.js

@@ -3,8 +3,8 @@
  *
  * @module
  */
-import { identity, fn, compose } from "../function/module.f.js";
-import { addition, logicalNot, strictEqual, stateScanToScan, foldToScan, reduceToScan, } from "../function/operator/module.f.js";
+import { identity, fn, compose } from '../function/module.f.js';
+import { addition, logicalNot, strictEqual, stateScanToScan, foldToScan, reduceToScan, } from '../function/operator/module.f.js';
 export const fromArrayLike = (array) => {
     const at = (i) => i < array.length ? { first: array[i], tail: () => at(i + 1) } : null;
     return at(0);

package/fs/types/list/proof.f.d.ts

@@ -1,22 +1,30 @@
+declare const stringifyTest: () => void;
+declare const countdownTest: () => void;
+declare const flatTest: () => void;
+declare const concatTest: () => void;
+declare const flatMapTest: () => void;
+declare const dropWhileTest: () => void;
+declare const logic: () => (() => void)[];
 export declare const proof: {
-    stringifyTest: () => void;
+    stringifyTest: typeof stringifyTest;
     cycle: (() => void)[];
-    countdown: () => void;
-    flat: () => void;
-    concat: () => void;
-    flatMap: () => void;
+    countdown: typeof countdownTest;
+    flat: typeof flatTest;
+    concat: typeof concatTest;
+    flatMap: typeof flatMapTest;
     take: (() => void)[];
     find: (() => void)[];
     takeWhile: (() => void)[];
-    dropWhile: () => void;
+    dropWhile: typeof dropWhileTest;
     drop: (() => void)[];
     additionTests: (() => void)[];
     entries: (() => void)[];
     reverse: (() => void)[];
     zip: (() => void)[];
-    logic: () => (() => void)[];
+    logic: typeof logic;
     strictEqual: (() => void)[];
     isEmpty: (() => void)[];
     length: () => void;
     filterMap: (() => void)[];
 };
+export {};

package/fs/types/list/proof.f.js

@@ -1,7 +1,7 @@
-import { length, concat, countdown, cycle, drop, dropWhile, entries, every, filter, find, flat, flatMap, map, next, reduce, reverse, scan, some, take, takeWhile, toArray, zip, first, filterMap, isEmpty, equal } from "./module.f.js";
-import { stringify } from "../../json/module.f.js";
-import { sort } from "../object/module.f.js";
-import { addition, strictEqual, reduceToScan } from "../function/operator/module.f.js";
+import { length, concat, countdown, cycle, drop, dropWhile, entries, every, filter, find, flat, flatMap, map, next, reduce, reverse, scan, some, take, takeWhile, toArray, zip, first, filterMap, isEmpty, equal } from './module.f.js';
+import { stringify } from '../../media/json/module.f.js';
+import { sort } from '../object/module.f.js';
+import { addition, strictEqual, reduceToScan } from '../function/operator/module.f.js';
 const str = sequence => stringify(sort)(toArray(sequence));
 const stringifyTest = () => {
     const s = str([1, 2, 3]);

package/fs/types/map/proof.f.js

@@ -1,5 +1,5 @@
-import { mapSet, mapDelete } from "./module.f.js";
-import { assertEq } from "../../asserts/module.f.js";
+import { mapSet, mapDelete } from './module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 export const proof = {
     set: () => {
         const map = mapSet(new Map(), 'a', 'b');

package/fs/types/nibble_set/proof.f.js

@@ -1,5 +1,5 @@
-import { every, map, countdown } from "../list/module.f.js";
-import { empty, has, set, setRange, unset, universe, complement } from "./module.f.js";
+import { every, map, countdown } from '../list/module.f.js';
+import { empty, has, set, setRange, unset, universe, complement } from './module.f.js';
 export const proof = {
     has: () => {
         if (has(0)(empty)) {

package/fs/types/nullable/module.f.js

@@ -3,8 +3,8 @@
  *
  * @module
  */
-import { assert } from "../../asserts/module.f.js";
-import { fn } from "../function/module.f.js";
+import { assert } from '../../asserts/module.f.js';
+import { fn } from '../function/module.f.js';
 export const map = f => value => value === null ? null : f(value);
 export const match = f => none => value => value === null ? none() : f(value);
 export const toOption = (value) => value === null ? [] : [value];

package/fs/types/nullable/proof.f.js

@@ -1,4 +1,4 @@
-import { fromUndefined, map, match, toOption } from "./module.f.js";
+import { fromUndefined, map, match, toOption } from './module.f.js';
 export const proof = [
     () => {
         const optionSq = map((v) => v * v);

package/fs/types/number/module.f.js

@@ -4,12 +4,12 @@
  *
  * @module
  */
-import { reduce } from "../list/module.f.js";
-import { addition } from "../function/operator/module.f.js";
-import { cmp as uCmp, min as uMin, max as uMax } from "../function/compare/module.f.js";
+import { reduce } from '../list/module.f.js';
+import { addition } from '../function/operator/module.f.js';
+import { cmp as uCmp, min as uMin, max as uMax } from '../function/compare/module.f.js';
 export const sum = reduce(addition)(0);
-export const min = reduce((uMin))(null);
-export const max = reduce((uMax))(null);
+export const min = reduce(uMin)(null);
+export const max = reduce(uMax)(null);
 export const cmp = uCmp;
 const mo = [
     [0x5555_5555, 1],

package/fs/types/number/proof.f.js

@@ -1,4 +1,4 @@
-import { sum, min, max, cmp, countOnes } from "./module.f.js";
+import { sum, min, max, cmp, countOnes } from './module.f.js';
 export const proof = {
     sum: () => {
         const result = sum([2, 3, 4, 5]);

package/fs/types/object/module.f.js

@@ -5,10 +5,10 @@
  *
  * @module
  */
-import { isArray } from "../array/module.f.js";
-import { iterable } from "../list/module.f.js";
-import { fromUndefined } from "../nullable/module.f.js";
-import { entries as mapEntries, fromEntries as mapFromEntries } from "../ordered_map/module.f.js";
+import { isArray } from '../array/module.f.js';
+import { iterable } from '../list/module.f.js';
+import { fromUndefined } from '../nullable/module.f.js';
+import { entries as mapEntries, fromEntries as mapFromEntries } from '../ordered_map/module.f.js';
 const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object;
 export const at = name => object => {
     const d = getOwnPropertyDescriptor(object, name);

package/fs/types/object/proof.f.js

@@ -1,4 +1,4 @@
-import { at } from "./module.f.js";
+import { at } from './module.f.js';
 export const proof = {
     stringMap: {
         infiniteIsOptional: true,

package/fs/types/ordered_map/module.f.js

@@ -1,9 +1,9 @@
-import { value, find } from "../btree/find/module.f.js";
-import { set } from "../btree/set/module.f.js";
-import { remove as btreeRemove } from "../btree/remove/module.f.js";
-import { values } from "../btree/module.f.js";
-import { cmp } from "../string/module.f.js";
-import { fold } from "../list/module.f.js";
+import { value, find } from '../btree/find/module.f.js';
+import { set } from '../btree/set/module.f.js';
+import { remove as btreeRemove } from '../btree/remove/module.f.js';
+import { values } from '../btree/module.f.js';
+import { cmp } from '../string/module.f.js';
+import { fold } from '../list/module.f.js';
 const keyCmp = a => ([b]) => cmp(a)(b);
 export const at = (name) => (map) => {
     if (map === null) {

package/fs/types/ordered_map/proof.f.js

@@ -1,6 +1,6 @@
-import { at, setReplace, setReduce, empty, entries, remove, fromEntries } from "./module.f.js";
-import { toArray } from "../list/module.f.js";
-import { assertEq } from "../../asserts/module.f.js";
+import { at, setReplace, setReduce, empty, entries, remove, fromEntries } from './module.f.js';
+import { toArray } from '../list/module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 export const proof = {
     main: [
         () => {

package/fs/types/patricia_trie/proof.f.d.ts

@@ -1,7 +1,13 @@
+declare const empty: () => void;
+declare const singleLeaf: () => void;
+declare const twoLeaves: () => void;
+declare const descending: () => void;
+declare const ascending: () => void;
 export declare const proof: {
-    empty: () => void;
-    singleLeaf: () => void;
-    twoLeaves: () => void;
-    descending: () => void;
-    ascending: () => void;
+    empty: typeof empty;
+    singleLeaf: typeof singleLeaf;
+    twoLeaves: typeof twoLeaves;
+    descending: typeof descending;
+    ascending: typeof ascending;
 };
+export {};

package/fs/types/patricia_trie/proof.f.js

@@ -1,5 +1,5 @@
-import { assert } from "../../asserts/module.f.js";
-import { emptyState, patriciaTrie } from "./module.f.js";
+import { assert } from '../../asserts/module.f.js';
+import { emptyState, patriciaTrie } from './module.f.js';
 const combine = (a, b) => a * 1000n + b;
 const create = (a, b, s) => {
     const h = combine(a, b);

package/fs/types/prime_field/module.f.js

@@ -1,5 +1,5 @@
-import { repeat } from "../monoid/module.f.js";
-import { assert } from "../../asserts/module.f.js";
+import { repeat } from '../../common/monoid/module.f.js';
+import { assert } from '../../asserts/module.f.js';
 /**
  * Creates a prime field with the specified prime modulus and associated operations.
  *

package/fs/types/prime_field/proof.f.js

@@ -1,5 +1,5 @@
-import { modSqrt, prime_field, sqrt } from "./module.f.js";
-import { assert, assertEq } from "../../asserts/module.f.js";
+import { modSqrt, prime_field, sqrt } from './module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
 export const proof = {
     throw: {
         reciprocal_zero: () => prime_field(7n).reciprocal(0n),

package/fs/types/range/proof.f.js

@@ -1,4 +1,4 @@
-import { contains } from "./module.f.js";
+import { contains } from './module.f.js';
 export const proof = () => {
     if (!contains([0, 5])(1)) {
         throw 1;

package/fs/types/range_map/module.f.js

@@ -34,10 +34,10 @@
  * if (rmOps.get(16)(merged) !== 0) { throw 'error' }
  * ```
  */
-import { genericMerge } from "../sorted_list/module.f.js";
-import { next } from "../list/module.f.js";
-import { cmp } from "../number/module.f.js";
-import { bsearch } from "../function/compare/module.f.js";
+import { genericMerge } from '../sorted_list/module.f.js';
+import { next } from '../list/module.f.js';
+import { cmp } from '../number/module.f.js';
+import { bsearch } from '../function/compare/module.f.js';
 const reduceOp = ({ union, equal }) => state => ([aItem, aMax]) => ([bItem, bMax]) => {
     const sign = cmp(aMax)(bMax);
     const min = sign === 1 ? bMax : aMax;

package/fs/types/range_map/proof.f.js

@@ -1,10 +1,10 @@
-import { get, merge, fromRange, rangeMap } from "./module.f.js";
-import { stringify } from "../../json/module.f.js";
-import { sort } from "../object/module.f.js";
-import { union } from "../sorted_set/module.f.js";
-import { equal, toArray } from "../list/module.f.js";
-import { strictEqual } from "../function/operator/module.f.js";
-import { cmp } from "../string/module.f.js";
+import { get, merge, fromRange, rangeMap } from './module.f.js';
+import { stringify } from '../../media/json/module.f.js';
+import { sort } from '../object/module.f.js';
+import { union } from '../sorted_set/module.f.js';
+import { equal, toArray } from '../list/module.f.js';
+import { strictEqual } from '../function/operator/module.f.js';
+import { cmp } from '../string/module.f.js';
 const str = stringify(sort);
 const op = {
     union: union(cmp),

package/fs/types/result/module.f.d.ts

@@ -55,3 +55,7 @@ export declare const unwrap: <T, E>([kind, v]: Result<T, E>) => T;
  * Swaps the `ok` and `error` cases of a result.
  */
 export declare const invert: <T, E>([k, v]: Result<T, E>) => Result<E, T>;
+/**
+ * Maps the `ok` case of a result, passing an `error` through unchanged.
+ */
+export declare const mapOk: <T, R>(f: (value: T) => R) => <E>(r: Result<T, E>) => Result<R, E>;

package/fs/types/result/module.f.js

@@ -48,3 +48,7 @@ export const unwrap = ([kind, v]) => {
  * Swaps the `ok` and `error` cases of a result.
  */
 export const invert = ([k, v]) => k === 'ok' ? error(v) : ok(v);
+/**
+ * Maps the `ok` case of a result, passing an `error` through unchanged.
+ */
+export const mapOk = (f) => (r) => r[0] === 'ok' ? ok(f(r[1])) : r;

package/fs/types/result/module.js

@@ -1,4 +1,4 @@
-import { ok, error } from "./module.f.js";
+import { ok, error } from './module.f.js';
 export const tryCatch = f => {
     // Side effect: `try catch` is not allowed in FunctionalScript.
     try {

package/fs/types/result/proof.f.d.ts

@@ -1,5 +1,11 @@
+declare const example: () => void;
+declare const invertTest: () => void;
+declare const unwrapError: () => void;
+declare const mapOkTest: () => void;
 export declare const proof: {
-    example: () => void;
-    invertTest: () => void;
-    unwrapError: () => void;
+    example: typeof example;
+    invertTest: typeof invertTest;
+    unwrapError: typeof unwrapError;
+    mapOkTest: typeof mapOkTest;
 };
+export {};

package/fs/types/result/proof.f.js

@@ -1,4 +1,4 @@
-import { error, ok, unwrap, invert } from "./module.f.js";
+import { error, ok, unwrap, invert, mapOk } from "./module.f.js";
 const example = () => {
     const success = ok(42);
     const failure = error('Something went wrong');
@@ -39,4 +39,14 @@ const unwrapError = () => {
         throw 'expected throw';
     }
 };
-export const proof = { example, invertTest, unwrapError };
+const mapOkTest = () => {
+    const [k0, v0] = mapOk((n) => n + 1)(ok(41));
+    if (k0 !== 'ok' || v0 !== 42) {
+        throw [k0, v0];
+    }
+    const [k1, v1] = mapOk((n) => n + 1)(error('oops'));
+    if (k1 !== 'error' || v1 !== 'oops') {
+        throw [k1, v1];
+    }
+};
+export const proof = { example, invertTest, unwrapError, mapOkTest };

package/fs/types/rtti/common/module.f.js

@@ -1,7 +1,7 @@
-import {} from "../module.f.js";
-import { error, ok } from "../../result/module.f.js";
-import { isArray as commonIsArray } from "../../array/module.f.js";
-import { isObject as commonIsObject } from "../../object/module.f.js";
+import {} from '../module.f.js';
+import { error, ok } from '../../result/module.f.js';
+import { isArray as commonIsArray } from '../../array/module.f.js';
+import { isObject as commonIsObject } from '../../object/module.f.js';
 /** Builds an error result with empty path and the given message. */
 export const verror = (message) => error({ path: [], message });
 /** Prepends `key` to the error's path, used to build the path bottom-up. */

package/fs/types/rtti/module.f.d.ts

@@ -9,7 +9,7 @@ export type ConstObject = Struct | Tuple;
 export type Struct = StringMap<string, Type>;
 /** A tuple schema: readonly array whose elements are nested `Type`s. */
 export type Tuple = readonly Type[];
-declare const primitive0List: readonly ["bigint", "boolean", "number", "string"];
+declare const primitive0List: readonly ['bigint', 'boolean', 'number', 'string'];
 export type Primitive0 = typeof primitive0List[number];
 export declare const tag0List: readonly ["bigint", "boolean", "number", "string", "unknown"];
 /** Tags for nullary (zero-parameter) type schemas. */
@@ -40,7 +40,7 @@ export declare const bigint: Bigint;
 export type Unknown = Type0<'unknown'>;
 /** Schema that validates any DJS-compatible value. */
 export declare const unknown: Unknown;
-declare const tag1List: readonly ["array", "record"];
+declare const tag1List: readonly ['array', 'record'];
 export declare const isTag1: Includes<string, typeof tag1List>;
 /** Tags for unary (one-parameter) type schemas. */
 export type Tag1 = typeof tag1List[number];

package/fs/types/rtti/module.f.js

@@ -1,4 +1,4 @@
-import { includes } from "../array/module.f.js";
+import { includes } from '../array/module.f.js';
 const primitive0List = ['bigint', 'boolean', 'number', 'string'];
 export const tag0List = [...primitive0List, 'unknown'];
 const type0 = (tag) => () => [tag];

package/fs/types/rtti/parse/module.f.js

@@ -26,11 +26,11 @@
  *
  * @module
  */
-import {} from "../module.f.js";
-import { ok } from "../../result/module.f.js";
-import { find, map as listMap } from "../../list/module.f.js";
-import { constPrimitiveValidate, isArray, isObject, prependPath, primitive0Validate, verror, visit, } from "../common/module.f.js";
-export {} from "../common/module.f.js";
+import {} from '../module.f.js';
+import { ok } from '../../result/module.f.js';
+import { find, map as listMap } from '../../list/module.f.js';
+import { constPrimitiveValidate, isArray, isObject, prependPath, primitive0Validate, verror, visit, } from '../common/module.f.js';
+export {} from '../common/module.f.js';
 const { entries } = Object;
 const keyedFirstError = (results) => {
     const e = results.find(([, r]) => r[0] === 'error');

package/fs/types/rtti/parse/proof.f.js

@@ -1,5 +1,5 @@
-import { parse } from "./module.f.js";
-import { boolean, number, string, bigint, unknown, array, record, or, option } from "../module.f.js";
+import { parse } from './module.f.js';
+import { boolean, number, string, bigint, unknown, array, record, or, option } from '../module.f.js';
 const assertOk = ([k]) => { if (k !== 'ok') {
     throw 'expected ok';
 } };

package/fs/types/rtti/ts/module.f.js

@@ -7,7 +7,7 @@
  * The runtime `toTs` function mirrors `Ts<T>` at value level, returning a TypeScript
  * type expression string for a given RTTI schema.
  */
-import { primitive, union, printer as tsPrinter } from "../../ts/module.f.js";
+import { primitive, union, printer as tsPrinter } from '../../ts/module.f.js';
 /**
  * Creates a printer that converts an RTTI schema `Type` to its TypeScript type expression as a string.
  *

package/fs/types/rtti/ts/proof.f.js

@@ -1,5 +1,5 @@
-import { printer } from "./module.f.js";
-import { boolean, number, string, bigint, unknown, array, record, or, option, never } from "../module.f.js";
+import { printer } from './module.f.js';
+import { boolean, number, string, bigint, unknown, array, record, or, option, never } from '../module.f.js';
 const toTs = printer();
 const toTsMut = printer(true);
 const eqMut = (rtti, expected) => {

package/fs/types/rtti/validate/module.f.js

@@ -1,7 +1,7 @@
-import {} from "../module.f.js";
-import { ok } from "../../result/module.f.js";
-import { constPrimitiveValidate, isArray, isObject, prependPath, primitive0Validate, verror, visit, } from "../common/module.f.js";
-export { constPrimitiveValidate, prependPath, primitive0Validate, verror, } from "../common/module.f.js";
+import {} from '../module.f.js';
+import { ok } from '../../result/module.f.js';
+import { constPrimitiveValidate, isArray, isObject, prependPath, primitive0Validate, verror, visit, } from '../common/module.f.js';
+export { constPrimitiveValidate, prependPath, primitive0Validate, verror, } from '../common/module.f.js';
 const { entries } = Object;
 /**
  * Builds a validator for `array` or `record` schemas.

package/fs/types/rtti/validate/proof.f.js

@@ -1,5 +1,5 @@
-import { validate } from "./module.f.js";
-import { boolean, number, string, bigint, unknown, array, record, or, option } from "../module.f.js";
+import { validate } from './module.f.js';
+import { boolean, number, string, bigint, unknown, array, record, or, option } from '../module.f.js';
 const assertOk = ([k]) => { if (k !== 'ok') {
     throw 'expected ok';
 } };

package/fs/types/sorted_list/module.f.js

@@ -3,9 +3,9 @@
  *
  * @module
  */
-import { bsearch } from "../function/compare/module.f.js";
-import { next } from "../list/module.f.js";
-import { identity } from "../function/module.f.js";
+import { bsearch } from '../function/compare/module.f.js';
+import { next } from '../list/module.f.js';
+import { identity } from '../function/module.f.js';
 /**
  * Two-way sorted-list merge.
  * `reduceOp` returns `[output, sign, nextState]` where sign `-1` advances `a`, `1` advances `b`, `0` advances both; `null` output skips emission.

package/fs/types/sorted_list/proof.f.js

@@ -1,9 +1,9 @@
-import { find, merge } from "./module.f.js";
-import { stringify } from "../../json/module.f.js";
-import { sort } from "../object/module.f.js";
-import { toArray, countdown, length } from "../list/module.f.js";
-import { flip } from "../function/module.f.js";
-import { cmp } from "../number/module.f.js";
+import { find, merge } from './module.f.js';
+import { stringify } from '../../media/json/module.f.js';
+import { sort } from '../object/module.f.js';
+import { toArray, countdown, length } from '../list/module.f.js';
+import { flip } from '../function/module.f.js';
+import { cmp } from '../number/module.f.js';
 const str = stringify(sort);
 const reverseCmp = flip(cmp);
 export const proof = {

package/fs/types/sorted_set/module.f.js

@@ -1,5 +1,5 @@
 import { toArray } from "../list/module.f.js";
-import { merge, intersect as listIntersect, find } from "../sorted_list/module.f.js";
+import { merge, intersect as listIntersect, find } from '../sorted_list/module.f.js';
 export const union = cmp => a => b => toArray(merge(cmp)(a)(b));
 export const intersect = cmp => a => b => toArray(listIntersect(cmp)(a)(b));
 export const has = cmp => value => set => find(cmp)(value)(set) === value;

package/fs/types/sorted_set/proof.f.js

@@ -1,9 +1,9 @@
-import { has, intersect, union } from "./module.f.js";
-import { stringify } from "../../json/module.f.js";
-import { sort } from "../object/module.f.js";
-import { toArray, countdown, length } from "../list/module.f.js";
-import { flip } from "../function/module.f.js";
-import { cmp } from "../number/module.f.js";
+import { has, intersect, union } from './module.f.js';
+import { stringify } from '../../media/json/module.f.js';
+import { sort } from '../object/module.f.js';
+import { toArray, countdown, length } from '../list/module.f.js';
+import { flip } from '../function/module.f.js';
+import { cmp } from '../number/module.f.js';
 const str = a => stringify(sort)(a);
 const reverseCmp = flip(cmp);
 export const proof = {