functionalscript 0.1.596 → 0.1.598

package/html/module.f.mjs

@@ -2,7 +2,7 @@ import list, * as List from '../types/list/module.f.mjs'
 const { map, flatMap, flat, concat: listConcat } = list
 import s from '../types/string/module.f.mjs'
 const { concat: stringConcat } = s
-import object, * as O from '../types/object/module.f.mjs'
+import * as O from '../types/object/module.f.mjs'
 import f from '../types/function/module.f.mjs'
 const { compose } = f
 import utf16 from '../text/utf16/module.f.mjs'

package/js/tokenizer/test.f.mjs

@@ -1,12 +1,12 @@
-import tokenizer, * as tokenizerT from './module.f.mjs'
+import tokenizer, * as Tokenizer from './module.f.mjs'
 import list from '../../types/list/module.f.mjs'
-const { toArray, countdown } = list
+const { toArray } = list
 import djs from '../../djs/module.f.mjs'
 import o from '../../types/object/module.f.mjs'
 const { sort } = o
 import encoding from '../../text/utf16/module.f.mjs'
 
-/** @type {(s: string) => readonly tokenizerT.JsToken[]} */
+/** @type {(s: string) => readonly Tokenizer.JsToken[]} */
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = djs.stringify(sort)

package/json/parser/module.f.d.mts

@@ -27,10 +27,10 @@ export type StateError = {
     readonly message: string;
 };
 export type JsonState = StateParse | StateResult | StateError;
-/** @type {(tokenList: List.List<tokenizerT.JsonToken>) => Result.Result<Json.Unknown, string>} */
-declare const parse: (tokenList: List.List<tokenizerT.JsonToken>) => Result.Result<Json.Unknown, string>;
+/** @type {(tokenList: List.List<Tokenizer.JsonToken>) => Result.Result<Json.Unknown, string>} */
+declare const parse: (tokenList: List.List<Tokenizer.JsonToken>) => Result.Result<Json.Unknown, string>;
 import * as Map from '../../types/map/module.f.mjs';
 import * as Json from '../module.f.mjs';
 import * as List from '../../types/list/module.f.mjs';
-import * as tokenizerT from '../tokenizer/module.f.mjs';
+import * as Tokenizer from '../tokenizer/module.f.mjs';
 import * as Result from '../../types/result/module.f.mjs';

package/json/parser/module.f.mjs

@@ -2,7 +2,7 @@ import result, * as Result from '../../types/result/module.f.mjs'
 import list, * as List from '../../types/list/module.f.mjs'
 const { fold, first, drop, toArray } = list
 import * as Operator from '../../types/function/operator/module.f.mjs'
-import * as tokenizerT from '../tokenizer/module.f.mjs'
+import * as Tokenizer from '../tokenizer/module.f.mjs'
 import map, * as Map from '../../types/map/module.f.mjs'
 const { setReplace } = map
 import * as Json from '../module.f.mjs'
@@ -114,7 +114,7 @@ const endObject = state => {
     return pushValue(newState)(obj)
 }
 
-/** @type {(token: tokenizerT.JsonToken) => Json.Unknown} */
+/** @type {(token: Tokenizer.JsonToken) => Json.Unknown} */
 const tokenToValue = token => {
     switch (token.kind) {
         case 'null': return null
@@ -126,7 +126,7 @@ const tokenToValue = token => {
     }
 }
 
-/** @type {(token: tokenizerT.JsonToken) => boolean} */
+/** @type {(token: Tokenizer.JsonToken) => boolean} */
 const isValueToken = token => {
     switch (token.kind) {
         case 'null':
@@ -138,7 +138,7 @@ const isValueToken = token => {
     }
 }
 
-/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
 const parseValueOp = token => state => {
     if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
     if (token.kind === '[') { return startArray(state) }
@@ -146,7 +146,7 @@ const parseValueOp = token => state => {
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
 const parseArrayStartOp = token => state => {
     if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
     if (token.kind === '[') { return startArray(state) }
@@ -155,40 +155,40 @@ const parseArrayStartOp = token => state => {
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
 const parseArrayValueOp = token => state => {
     if (token.kind === ']') { return endArray(state) }
     if (token.kind === ',') { return { status: '[,', top: state.top, stack: state.stack } }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
 const parseObjectStartOp = token => state => {
     if (token.kind === 'string') { return pushKey(state)(token.value) }
     if (token.kind === '}') { return endObject(state) }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
 const parseObjectKeyOp = token => state => {
     if (token.kind === ':') { return { status: '{:', top: state.top, stack: state.stack } }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
 const parseObjectNextOp = token => state => {
     if (token.kind === '}') { return endObject(state) }
     if (token.kind === ',') { return { status: '{,', top: state.top, stack: state.stack } }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
 const parseObjectCommaOp = token => state => {
     if (token.kind === 'string') { return pushKey(state)(token.value) }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {Operator.Fold<tokenizerT.JsonToken, JsonState>} */
+/** @type {Operator.Fold<Tokenizer.JsonToken, JsonState>} */
 const foldOp = token => state => {
     switch (state.status) {
         case 'result': return { status: 'error', message: 'unexpected token' }
@@ -205,7 +205,7 @@ const foldOp = token => state => {
     }
 }
 
-/** @type {(tokenList: List.List<tokenizerT.JsonToken>) => Result.Result<Json.Unknown, string>} */
+/** @type {(tokenList: List.List<Tokenizer.JsonToken>) => Result.Result<Json.Unknown, string>} */
 const parse = tokenList => {
     const state = fold(foldOp)({ status: '', top: null, stack: null })(tokenList)
     switch (state.status) {

package/json/parser/test.f.mjs

@@ -1,5 +1,5 @@
 import parser from './module.f.mjs'
-import tokenizer, * as tokenizerT from '../tokenizer/module.f.mjs'
+import tokenizer, * as Tokenizer from '../tokenizer/module.f.mjs'
 import list from '../../types/list/module.f.mjs'
 const { toArray } = list
 import json from '../module.f.mjs'
@@ -7,7 +7,7 @@ import o from '../../types/object/module.f.mjs'
 const { sort } = o
 import encoding from '../../text/utf16/module.f.mjs'
 
-/** @type {(s: string) => readonly tokenizerT.JsonToken[]} */
+/** @type {(s: string) => readonly Tokenizer.JsonToken[]} */
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = json.stringify(sort)

package/json/serializer/module.f.mjs

@@ -1,7 +1,7 @@
 import list, * as List from '../../types/list/module.f.mjs'
 const { flat, reduce, empty } = list
-import object, * as O from '../../types/object/module.f.mjs'
-import operator, * as Operator from '../../types/function/operator/module.f.mjs'
+import * as O from '../../types/object/module.f.mjs'
+import * as Operator from '../../types/function/operator/module.f.mjs'
 
 /**
  * @template T

package/json/tokenizer/module.f.d.mts

@@ -6,12 +6,12 @@ export type JsonToken = {
     readonly kind: "true" | "false" | "null";
 } | {
     readonly kind: "{" | "}" | ":" | "," | "[" | "]";
-} | jsTokenizerT.StringToken | jsTokenizerT.NumberToken | jsTokenizerT.ErrorToken;
+} | JsTokenizer.StringToken | JsTokenizer.NumberToken | JsTokenizer.ErrorToken;
 export type ScanState = {
     readonly kind: "def" | "-";
 };
-export type ScanInput = jsTokenizerT.JsToken | null;
+export type ScanInput = JsTokenizer.JsToken | null;
 /** @type {(input: List.List<number>) => List.List<JsonToken>} */
 declare const tokenize: (input: List.List<number>) => List.List<JsonToken>;
-import * as jsTokenizerT from '../../js/tokenizer/module.f.mjs';
+import * as JsTokenizer from '../../js/tokenizer/module.f.mjs';
 import * as List from '../../types/list/module.f.mjs';

package/json/tokenizer/module.f.mjs

@@ -1,17 +1,17 @@
-import operator, * as Operator from '../../types/function/operator/module.f.mjs'
+import * as Operator from '../../types/function/operator/module.f.mjs'
 import list, * as List from '../../types/list/module.f.mjs'
 const { empty, flat, stateScan } = list
 import bf from '../../types/bigfloat/module.f.mjs'
 const { multiply } = bf
-import jsTokenizer, * as jsTokenizerT from '../../js/tokenizer/module.f.mjs'
+import jsTokenizer, * as JsTokenizer from '../../js/tokenizer/module.f.mjs'
 
 /**
  * @typedef {|
 * {readonly kind: 'true' | 'false' | 'null' } |
 * {readonly kind: '{' | '}' | ':' | ',' | '[' | ']' } |
-* jsTokenizerT.StringToken |
-* jsTokenizerT.NumberToken |
-* jsTokenizerT.ErrorToken
+* JsTokenizer.StringToken |
+* JsTokenizer.NumberToken |
+* JsTokenizer.ErrorToken
 * } JsonToken
 */
 
@@ -23,11 +23,11 @@ import jsTokenizer, * as jsTokenizerT from '../../js/tokenizer/module.f.mjs'
 
 /**
  * @typedef {|
-* jsTokenizerT.JsToken | null
+* JsTokenizer.JsToken | null
 * } ScanInput
 */
 
-/** @type {(input: jsTokenizerT.JsToken) => List.List<JsonToken>} */
+/** @type {(input: JsTokenizer.JsToken) => List.List<JsonToken>} */
 const mapToken = input =>
 {
     switch(input.kind)

package/json/tokenizer/test.f.mjs

@@ -1,12 +1,12 @@
-import tokenizer, * as tokenizerT from './module.f.mjs'
+import tokenizer, * as Tokenizer from './module.f.mjs'
 import list from '../../types/list/module.f.mjs'
-const { toArray, countdown } = list
+const { toArray } = list
 import djs from '../../djs/module.f.mjs'
 import o from '../../types/object/module.f.mjs'
 const { sort } = o
 import encoding from '../../text/utf16/module.f.mjs'
 
-/** @type {(s: string) => readonly tokenizerT.JsonToken[]} */
+/** @type {(s: string) => readonly Tokenizer.JsonToken[]} */
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = djs.stringify(sort)

package/jsr.json

@@ -1,5 +1,5 @@
 {
   "name": "@functionalscript/functionalscript",
-  "version": "0.1.596",
+  "version": "0.1.598",
   "exports": "./index.f.mjs"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.1.596",
+  "version": "0.1.598",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.f.mjs",
   "scripts": {

package/secp/module.f.d.mts

@@ -14,12 +14,12 @@ export type Init = {
     readonly n: bigint;
 };
 export type Curve = {
-    readonly pf: pfT.PrimeField;
-    readonly nf: pfT.PrimeField;
+    readonly pf: Pf.PrimeField;
+    readonly nf: Pf.PrimeField;
     readonly y2: (x: bigint) => bigint;
     readonly y: (x: bigint) => bigint | null;
     readonly neg: (a: Point) => Point;
-    readonly add: op.Reduce<Point>;
+    readonly add: Operator.Reduce<Point>;
     readonly mul: (a: Point) => (n: bigint) => Point;
 };
 /** @typedef {readonly[bigint, bigint]} Point2D */
@@ -34,16 +34,16 @@ export type Curve = {
  */
 /**
  * @typedef {{
- *  readonly pf: pfT.PrimeField
- *  readonly nf: pfT.PrimeField
+ *  readonly pf: Pf.PrimeField
+ *  readonly nf: Pf.PrimeField
  *  readonly y2: (x: bigint) => bigint
  *  readonly y: (x: bigint) => bigint|null
  *  readonly neg: (a: Point) => Point
- *  readonly add: op.Reduce<Point>
+ *  readonly add: Operator.Reduce<Point>
  *  readonly mul: (a: Point) => (n: bigint) => Point
  * }} Curve
  */
 /** @type {(i: Init) => Curve} */
 declare const curve: (i: Init) => Curve;
-import * as pfT from '../prime_field/module.f.mjs';
-import * as op from '../types/function/operator/module.f.mjs';
+import * as Pf from '../prime_field/module.f.mjs';
+import * as Operator from '../types/function/operator/module.f.mjs';

package/secp/module.f.mjs

@@ -1,5 +1,5 @@
-import * as op from '../types/function/operator/module.f.mjs'
-import pf, * as pfT from '../prime_field/module.f.mjs'
+import * as Operator from '../types/function/operator/module.f.mjs'
+import pf, * as Pf from '../prime_field/module.f.mjs'
 import bi from '../types/bigint/module.f.mjs'
 const { scalar_mul } = bi
 const { prime_field, sqrt } = pf
@@ -19,12 +19,12 @@ const { prime_field, sqrt } = pf
 
 /**
  * @typedef {{
- *  readonly pf: pfT.PrimeField
- *  readonly nf: pfT.PrimeField
+ *  readonly pf: Pf.PrimeField
+ *  readonly nf: Pf.PrimeField
  *  readonly y2: (x: bigint) => bigint
  *  readonly y: (x: bigint) => bigint|null
  *  readonly neg: (a: Point) => Point
- *  readonly add: op.Reduce<Point>
+ *  readonly add: Operator.Reduce<Point>
  *  readonly mul: (a: Point) => (n: bigint) => Point
  * }} Curve
  */
@@ -41,7 +41,7 @@ const curve = ({ p, a: [a0, a1], n }) => {
     // y**2 = a1*x**3 + a0
     /** @type {(x: bigint) => bigint} */
     const y2 = x => addA0(add(pow3(x))(mulA1(x)))
-    /** @type {op.Reduce<Point>} */
+    /** @type {Operator.Reduce<Point>} */
     const addPoint = p => q => {
         if (p === null) {
             return q

package/secp/test.f.mjs

@@ -1,13 +1,13 @@
-import mt, * as mT from './module.f.mjs'
-const { curve, secp256k1, secp192r1, eq } = mt
+import _, * as T from './module.f.mjs'
+const { curve, secp256k1, secp192r1, eq } = _
 
 export default {
     test: () => {
-        /** @type {(c: mT.Init) => void} */
+        /** @type {(c: T.Init) => void} */
         const test_curve = c => {
             const { g } = c
             const { mul, neg, pf: { abs }, y: yf, nf: { p: n } } = curve(c)
-            /** @type {(p: mT.Point) => void} */
+            /** @type {(p: T.Point) => void} */
             const point_check = p => {
                 if (p === null) { throw 'null' }
                 const [x, y] = p
@@ -17,7 +17,7 @@ export default {
             }
             point_check(g)
             point_check(neg(g))
-            /** @type {(p: mT.Point) => void} */
+            /** @type {(p: T.Point) => void} */
             const test_mul = p => {
                 if (mul(p)(0n) !== null) { throw 'O' }
                 if (mul(p)(1n) !== p) { throw 'p' }

package/sha2/module.f.mjs

@@ -1,4 +1,4 @@
-import array, * as arrayT from '../types/array/module.f.mjs'
+import * as arrayT from '../types/array/module.f.mjs'
 
 /**
  * @typedef {{

package/sha2/test.f.mjs

@@ -2,7 +2,6 @@ import _ from './module.f.mjs'
 import json, * as jsonT from '../json/module.f.mjs'
 import o from '../types/object/module.f.mjs'
 const { sort } = o
-import list from '../types/list/module.f.mjs'
 
 /** @type {(a: number) => number} */
 const toU32 = x => (x + 0x1_0000_0000) % 0x1_0000_0000

package/text/utf16/test.f.mjs

@@ -1,10 +1,10 @@
 import encoding from './module.f.mjs'
-import json, * as jsonT from '../../json/module.f.mjs'
+import json, * as Json from '../../json/module.f.mjs'
 import o from '../../types/object/module.f.mjs'
 const { sort } = o
 import list from '../../types/list/module.f.mjs'
 
-/** @type {(a: readonly jsonT.Unknown[]) => string} */
+/** @type {(a: readonly Json.Unknown[]) => string} */
 const stringify = a => json.stringify(sort)(a)
 
 export default {

package/text/utf8/module.f.d.mts

@@ -4,12 +4,12 @@ declare namespace _default {
 }
 export default _default;
 export type ByteOrEof = u8 | null;
-export type Utf8NonEmptyState = arrayT.Array1<number> | arrayT.Array2<number> | arrayT.Array3<number>;
+export type Utf8NonEmptyState = Array.Array1<number> | Array.Array2<number> | Array.Array3<number>;
 export type Utf8State = null | Utf8NonEmptyState;
 export type u8 = number;
 export type i32 = number;
 declare const fromCodePointList: (input: List.List<number>) => List.Thunk<number>;
 /** @type {(input: List.List<u8>) => List.List<i32>} */
 declare const toCodePointList: (input: List.List<u8>) => List.List<i32>;
-import * as arrayT from '../../types/array/module.f.mjs';
+import * as Array from '../../types/array/module.f.mjs';
 import * as List from '../../types/list/module.f.mjs';

package/text/utf8/module.f.mjs

@@ -1,11 +1,11 @@
 import list, * as List from '../../types/list/module.f.mjs'
 import * as operator from '../../types/function/operator/module.f.mjs'
-import * as arrayT from '../../types/array/module.f.mjs'
+import * as Array from '../../types/array/module.f.mjs'
 const { flatMap, flat, stateScan } = list
 
 /** @typedef {u8|null} ByteOrEof */
 
-/** @typedef {arrayT.Array1<number>|arrayT.Array2<number>|arrayT.Array3<number>} Utf8NonEmptyState */
+/** @typedef {Array.Array1<number>|Array.Array2<number>|Array.Array3<number>} Utf8NonEmptyState */
 
 /** @typedef {null|Utf8NonEmptyState} Utf8State */
 

package/types/bigint/module.f.d.mts

@@ -9,26 +9,26 @@ declare namespace _default {
     export { bitLength };
 }
 export default _default;
-export type Unary = Op.Unary<bigint, bigint>;
+export type Unary = Operator.Unary<bigint, bigint>;
 export type Additive<T> = {
     readonly 0: T;
-    readonly add: Op.Reduce<T>;
+    readonly add: Operator.Reduce<T>;
 };
-/** @typedef {Op.Unary<bigint, bigint>} Unary*/
+/** @typedef {Operator.Unary<bigint, bigint>} Unary*/
 /** @type {(a: bigint) => (b: bigint) => bigint} */
 declare const addition: (a: bigint) => (b: bigint) => bigint;
 declare const sum: (input: import("../list/module.f.mjs").List<bigint>) => bigint;
 /** @type {(a: bigint) => bigint} */
 declare const abs: (a: bigint) => bigint;
-/** @type {(a: bigint) => compareT.Sign} */
-declare const sign: (a: bigint) => compareT.Sign;
+/** @type {(a: bigint) => Compare.Sign} */
+declare const sign: (a: bigint) => Compare.Sign;
 /** @type {(a: bigint) => string} */
 declare const serialize: (a: bigint) => string;
 /**
  * @template T
  * @typedef {{
  *  readonly 0: T
- *  readonly add: Op.Reduce<T>
+ *  readonly add: Operator.Reduce<T>
  * }} Additive
  */
 /** @type {<T>(a: Additive<T>) => (a: T) => (n: bigint) => T} */
@@ -73,5 +73,5 @@ declare function log2(v: bigint): bigint;
  * and adds `1n` to account for the MSB itself.For negative numbers, the absolute value is used.
  */
 declare function bitLength(v: bigint): bigint;
-import * as Op from '../function/operator/module.f.mjs';
-import * as compareT from '../function/compare/module.f.mjs';
+import * as Operator from '../function/operator/module.f.mjs';
+import * as Compare from '../function/compare/module.f.mjs';

package/types/bigint/module.f.mjs

@@ -1,10 +1,10 @@
-import compare, * as compareT from '../function/compare/module.f.mjs'
-import op, * as Op from '../function/operator/module.f.mjs'
+import compare, * as Compare from '../function/compare/module.f.mjs'
+import * as Operator from '../function/operator/module.f.mjs'
 const { unsafeCmp } = compare
 import list from '../list/module.f.mjs'
 const { reduce } = list
 
-/** @typedef {Op.Unary<bigint, bigint>} Unary*/
+/** @typedef {Operator.Unary<bigint, bigint>} Unary*/
 
 /** @type {(a: bigint) => (b: bigint) => bigint} */
 const addition = a => b => a + b
@@ -14,7 +14,7 @@ const sum = reduce(addition)(0n)
 /** @type {(a: bigint) => bigint} */
 const abs = a => a >= 0 ? a : -a
 
-/** @type {(a: bigint) => compareT.Sign} */
+/** @type {(a: bigint) => Compare.Sign} */
 const sign = a => unsafeCmp(a)(0n)
 
 /** @type {(a: bigint) => string} */
@@ -24,7 +24,7 @@ const serialize = a => `${a}n`
  * @template T
  * @typedef {{
  *  readonly 0: T
- *  readonly add: Op.Reduce<T>
+ *  readonly add: Operator.Reduce<T>
  * }} Additive
  */
 

package/types/btree/find/module.f.mjs

@@ -1,8 +1,8 @@
 import * as _ from '../types/module.f.mjs'
-import list, * as List from '../../list/module.f.mjs'
+import * as List from '../../list/module.f.mjs'
 import cmp, * as cmpT from '../../function/compare/module.f.mjs'
 const { index3, index5 } = cmp
-import array, * as arrayT from '../../array/module.f.mjs'
+import * as Array from '../../array/module.f.mjs'
 
 /**
  * @template T
@@ -68,12 +68,12 @@ const find = c => {
     /** @typedef {typeof c extends cmpT.Compare<infer T> ? T : never} T */
     /** @type {(prior: Path<T>) => (node: _.Node<T>) => Result<T>} */
     const f = tail => node => {
-        /** @type {(index: arrayT.KeyOf<typeof node>) => Result<T>} */
+        /** @type {(index: Array.KeyOf<typeof node>) => Result<T>} */
         const append = index => {
             const first = /** @type {PathItem<T>} */([index, node])
             return f({ first, tail })(child(first))
         }
-        /** @type {(index: arrayT.KeyOf<typeof node>) => Result<T>} */
+        /** @type {(index: Array.KeyOf<typeof node>) => Result<T>} */
         const done = index => ({ first: /** @type {First<T>} */([index, node]), tail })
         switch (node.length) {
             case 1: { return done(i3(node[0])) }

package/types/btree/find/test.f.mjs

@@ -1,6 +1,6 @@
 import _, * as T from './module.f.mjs'
 import list from '../../list/module.f.mjs'
-import json, * as jsonT from '../../../json/module.f.mjs'
+import json, * as Json from '../../../json/module.f.mjs'
 import o from '../../object/module.f.mjs'
 const { sort } = o
 import * as btree from '../types/module.f.mjs'
@@ -13,7 +13,7 @@ const jsonStr = json.stringify(sort)
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
 const set = node => value => s.set(cmp(value))(() => value)(node)
 
-/** @type {(r: T.Result<jsonT.Unknown>) => string} */
+/** @type {(r: T.Result<Json.Unknown>) => string} */
 const str = r => jsonStr(list.toArray(list.map(x => x[0])(r)))
 
 /** @type {(i: string) => (m: btree.Node<string>) => string} */

package/types/btree/remove/module.f.d.mts

@@ -6,14 +6,14 @@ export default _default;
 export type Leaf01<T> = null | _.Leaf1<T>;
 export type RemovePath<T> = {
     readonly first: Leaf01<T>;
-    readonly tail: findT.Path<T>;
+    readonly tail: Find.Path<T>;
 };
 export type Branch<T> = _.Branch1<T> | _.Branch3<T> | _.Branch5<T>;
 export type Merge<A, T> = (a: A) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>;
-/** @type {<T>(c: cmpT.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
-declare const nodeRemove: <T>(c: cmpT.Compare<T>) => (node: _.Node<T>) => _.Tree<T>;
-/** @type {<T>(c: cmpT.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
-declare const remove: <T>(c: cmpT.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>;
+/** @type {<T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
+declare const nodeRemove: <T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>;
+/** @type {<T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
+declare const remove: <T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>;
 import * as _ from '../types/module.f.mjs';
-import * as findT from '../find/module.f.mjs';
-import * as cmpT from '../../function/compare/module.f.mjs';
+import * as Find from '../find/module.f.mjs';
+import * as Cmp from '../../function/compare/module.f.mjs';

package/types/btree/remove/module.f.mjs

@@ -1,9 +1,9 @@
 import * as _ from '../types/module.f.mjs'
-import cmp, * as cmpT from '../../function/compare/module.f.mjs'
-import find, * as findT from '../find/module.f.mjs'
+import * as Cmp from '../../function/compare/module.f.mjs'
+import find, * as Find from '../find/module.f.mjs'
 import list from '../../list/module.f.mjs'
 const { fold, concat, next } = list
-import array, * as arrayT from '../../array/module.f.mjs'
+import * as Array from '../../array/module.f.mjs'
 import n from '../../nullable/module.f.mjs'
 const { map } = n
 
@@ -16,11 +16,11 @@ const { map } = n
  * @template T
  * @typedef {{
  *  readonly first: Leaf01<T>,
- *  readonly tail: findT.Path<T>
+ *  readonly tail: Find.Path<T>
  * }} RemovePath
  */
 
-/** @type {<T>(tail: findT.Path<T>) => (n: _.Node<T>) => readonly[T, RemovePath<T>]} */
+/** @type {<T>(tail: Find.Path<T>) => (n: _.Node<T>) => readonly[T, RemovePath<T>]} */
 const path = tail => n => {
     switch (n.length) {
         case 1: { return [n[0], { first: null, tail }] }
@@ -94,10 +94,10 @@ const initValue1 = a => n => {
  * @typedef {(a: A) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} Merge
  */
 
-/** @type {<A, T>(ms: arrayT.Array2<Merge<A, T>>) => (i: findT.PathItem<T>) => (a: A) => Branch<T>} */
+/** @type {<A, T>(ms: Array.Array2<Merge<A, T>>) => (i: Find.PathItem<T>) => (a: A) => Branch<T>} */
 const reduceX = ms => ([i, n]) => a => {
     const [m0, m2] = ms
-    /** @typedef {typeof ms extends arrayT.Array2<Merge<infer A, infer T>> ? [A,T] : never} AT */
+    /** @typedef {typeof ms extends Array.Array2<Merge<infer A, infer T>> ? [A,T] : never} AT */
     /** @typedef {AT[0]} A */
     /** @typedef {AT[1]} T */
     /** @type {(m: Merge<A, T>) => Branch<T>} */
@@ -116,15 +116,15 @@ const reduce = fold(reduceX([reduceValue0, reduceValue2]))
 
 const initReduce = reduceX([initValue0, initValue1])
 
-/** @type {<T>(c: cmpT.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
+/** @type {<T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
 const nodeRemove = c => node => {
-    /** @typedef {typeof c extends cmpT.Compare<infer T> ? T : never} T */
+    /** @typedef {typeof c extends Cmp.Compare<infer T> ? T : never} T */
     /** @type  {() => null | RemovePath<T>} */
     const f = () => {
         const { first, tail } = find.find(c)(node)
-        /** @type {(n: _.Node<T>) => (f: (v: T) => findT.PathItem<T>) => RemovePath<T>} */
+        /** @type {(n: _.Node<T>) => (f: (v: T) => Find.PathItem<T>) => RemovePath<T>} */
         const branch = n => f => {
-            const [v, p] = path(/** @type {findT.Path<T>} */(null))(n)
+            const [v, p] = path(/** @type {Find.Path<T>} */(null))(n)
             return { first: p.first, tail: concat(p.tail)({ first: f(v), tail }) }
         }
         const [i, n] = first
@@ -156,7 +156,7 @@ const nodeRemove = c => node => {
     return result.length === 1 ? result[0] : result
 }
 
-/** @type {<T>(c: cmpT.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
+/** @type {<T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
 const remove =  c => map(nodeRemove(c))
 
 export default {