functionalscript 0.1.608 → 0.2.0

package/text/README.md

@@ -34,7 +34,7 @@ Total error states:
 - 34_432
 - < 2^16
 
-### utf8/module.f.cjs
+### utf8/module.f.mjs
 
 ```js
 /** @type {(input: List<u8|null>) => List<i32>} */
@@ -69,7 +69,7 @@ Requirement: no loss for UTF16 => codepoint => UTF16
 
 Total error states: 11 bit
 
-### utf16/module.f.cjs
+### utf16/module.f.mjs
 
 ```js
 /** @type {(input: List<u16|null>) => List<i32>} */

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

@@ -1,73 +1,70 @@
-declare namespace _default {
-    export { one };
-    export { range };
-    export let backspace: number;
-    export let ht: number;
-    export let lf: number;
-    export let ff: number;
-    export let cr: number;
-    export let space: number;
-    export let exclamationMark: number;
-    export let quotationMark: number;
-    export let numberSign: number;
-    export let dollarSign: number;
-    export let percentSign: number;
-    export let ampersand: number;
-    export let apostrophe: number;
-    export let leftParenthesis: number;
-    export let rightParenthesis: number;
-    export let asterisk: number;
-    export let plusSign: number;
-    export let comma: number;
-    export let hyphenMinus: number;
-    export let fullStop: number;
-    export let solidus: number;
-    export let digitRange: Range.Range;
-    export let digit0: number;
-    export let digit1: number;
-    export let digit2: number;
-    export let digit3: number;
-    export let digit4: number;
-    export let digit5: number;
-    export let digit6: number;
-    export let digit7: number;
-    export let digit8: number;
-    export let digit9: number;
-    export let colon: number;
-    export let semicolon: number;
-    export let lessThanSign: number;
-    export let equalsSign: number;
-    export let greaterThanSign: number;
-    export let questionMark: number;
-    export let commercialAt: number;
-    export let latinCapitalLetterRange: Range.Range;
-    export let latinCapitalLetterA: number;
-    export let latinCapitalLetterE: number;
-    export let latinCapitalLetterF: number;
-    export let leftSquareBracket: number;
-    export let reverseSolidus: number;
-    export let rightSquareBracket: number;
-    export let circumflexAccent: number;
-    export let lowLine: number;
-    export let graveAccent: number;
-    export let latinSmallLetterRange: Range.Range;
-    export let latinSmallLetterA: number;
-    export let latinSmallLetterB: number;
-    export let latinSmallLetterE: number;
-    export let latinSmallLetterF: number;
-    export let latinSmallLetterN: number;
-    export let latinSmallLetterR: number;
-    export let latinSmallLetterT: number;
-    export let latinSmallLetterU: number;
-    export let latinSmallLetterZ: number;
-    export let leftCurlyBracket: number;
-    export let verticalLine: number;
-    export let rightCurlyBracket: number;
-    export let tilde: number;
-}
-export default _default;
 /** @type {(s: string) => number} */
-declare const one: (s: string) => number;
-/** @type {(s: string) => Range.Range} */
-declare const range: (s: string) => Range.Range;
-import * as Range from '../../types/range/module.f.mjs';
+export const one: (s: string) => number;
+/** @type {(s: string) => _range.Range} */
+export const range: (s: string) => _range.Range;
+export namespace ascii {
+    let backspace: number;
+    let ht: number;
+    let lf: number;
+    let ff: number;
+    let cr: number;
+    let space: number;
+    let exclamationMark: number;
+    let quotationMark: number;
+    let numberSign: number;
+    let dollarSign: number;
+    let percentSign: number;
+    let ampersand: number;
+    let apostrophe: number;
+    let leftParenthesis: number;
+    let rightParenthesis: number;
+    let asterisk: number;
+    let plusSign: number;
+    let comma: number;
+    let hyphenMinus: number;
+    let fullStop: number;
+    let solidus: number;
+    let digitRange: _range.Range;
+    let digit0: number;
+    let digit1: number;
+    let digit2: number;
+    let digit3: number;
+    let digit4: number;
+    let digit5: number;
+    let digit6: number;
+    let digit7: number;
+    let digit8: number;
+    let digit9: number;
+    let colon: number;
+    let semicolon: number;
+    let lessThanSign: number;
+    let equalsSign: number;
+    let greaterThanSign: number;
+    let questionMark: number;
+    let commercialAt: number;
+    let latinCapitalLetterRange: _range.Range;
+    let latinCapitalLetterA: number;
+    let latinCapitalLetterE: number;
+    let latinCapitalLetterF: number;
+    let leftSquareBracket: number;
+    let reverseSolidus: number;
+    let rightSquareBracket: number;
+    let circumflexAccent: number;
+    let lowLine: number;
+    let graveAccent: number;
+    let latinSmallLetterRange: _range.Range;
+    let latinSmallLetterA: number;
+    let latinSmallLetterB: number;
+    let latinSmallLetterE: number;
+    let latinSmallLetterF: number;
+    let latinSmallLetterN: number;
+    let latinSmallLetterR: number;
+    let latinSmallLetterT: number;
+    let latinSmallLetterU: number;
+    let latinSmallLetterZ: number;
+    let leftCurlyBracket: number;
+    let verticalLine: number;
+    let rightCurlyBracket: number;
+    let tilde: number;
+}
+import * as _range from '../../types/range/module.f.mjs';

package/text/ascii/module.f.mjs

@@ -1,5 +1,5 @@
 // @ts-self-types="./module.f.d.mts"
-import _range, * as Range from '../../types/range/module.f.mjs'
+import * as _range from '../../types/range/module.f.mjs'
 
 /** @type {(s: string) => (i: number) => number} */
 const at = s => i => {
@@ -9,22 +9,17 @@ const at = s => i => {
 }
 
 /** @type {(s: string) => number} */
-const one = s => at(s)(0)
+export const one = s => at(s)(0)
 
-/** @type {(s: string) => Range.Range} */
-const range = s => {
+/** @type {(s: string) => _range.Range} */
+export const range = s => {
     const f = at(s)
     const f0 = f(0)
     if (s.length === 1) { return [f0, f0] }
     return [f0, f(1)]
 }
 
-export default {
-    /** @readonly */
-    one,
-    /** @readonly */
-    range,
-
+export const ascii = {
     // 0x00..
 
     /** @readonly 0x08 */

package/text/ascii/test.f.mjs

@@ -1,7 +1,7 @@
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 const { range } = _
-import json from '../../json/module.f.mjs'
-import o from '../../types/object/module.f.mjs'
+import * as json from '../../json/module.f.mjs'
+import * as o from '../../types/object/module.f.mjs'
 const { sort } = o
 
 const stringify = json.stringify(sort)

package/text/module.f.d.mts

@@ -1,18 +1,13 @@
-declare namespace _default {
-    export { flat };
-    export { curly };
-}
-export default _default;
-export type Block = ItemThunk | ItemArray;
-export type ItemArray = readonly Item[];
-export type ItemThunk = () => List.List<Item>;
-export type Item = string | ItemArray | ItemThunk;
 /** @typedef {ItemThunk|ItemArray} Block */
 /** @typedef {readonly Item[]} ItemArray */
-/** @typedef {() => List.List<Item>} ItemThunk */
+/** @typedef {() => list.List<Item>} ItemThunk */
 /** @typedef {string|ItemArray|ItemThunk} Item */
-/** @type {(indent: string) => (text: Block) => List.List<string>} */
-declare const flat: (indent: string) => (text: Block) => List.List<string>;
+/** @type {(indent: string) => (text: Block) => list.List<string>} */
+export const flat: (indent: string) => (text: Block) => list.List<string>;
 /** @type {(type: string) => (name: string) => (body: Block) => Block} */
-declare const curly: (type: string) => (name: string) => (body: Block) => Block;
-import * as List from '../types/list/module.f.mjs';
+export const curly: (type: string) => (name: string) => (body: Block) => Block;
+export type Block = ItemThunk | ItemArray;
+export type ItemArray = readonly Item[];
+export type ItemThunk = () => list.List<Item>;
+export type Item = string | ItemArray | ItemThunk;
+import * as list from '../types/list/module.f.mjs';

package/text/module.f.mjs

@@ -1,21 +1,21 @@
 // @ts-self-types="./module.f.d.mts"
-import list, * as List from '../types/list/module.f.mjs'
+import * as list from '../types/list/module.f.mjs'
 const { flatMap } = list
 
 /** @typedef {ItemThunk|ItemArray} Block */
 
 /** @typedef {readonly Item[]} ItemArray */
 
-/** @typedef {() => List.List<Item>} ItemThunk */
+/** @typedef {() => list.List<Item>} ItemThunk */
 
 /** @typedef {string|ItemArray|ItemThunk} Item */
 
-/** @type {(indent: string) => (text: Block) => List.List<string>} */
-const flat = indent => {
+/** @type {(indent: string) => (text: Block) => list.List<string>} */
+export const flat = indent => {
 
-    /** @type {(prefix: string) => (text: Block) => List.List<string>} */
+    /** @type {(prefix: string) => (text: Block) => list.List<string>} */
     const f = prefix => {
-        /** @type {(item: Item) => List.List<string>} */
+        /** @type {(item: Item) => list.List<string>} */
         const g = item => typeof (item) === 'string' ? [`${prefix}${item}`] : f(`${prefix}${indent}`)(item)
         return flatMap(g)
     }
@@ -24,11 +24,4 @@ const flat = indent => {
 }
 
 /** @type {(type: string) => (name: string) => (body: Block) => Block} */
-const curly = type => name => body => [`${type} ${name}`, '{', body, '}']
-
-export default {
-    /** @readonly */
-    flat,
-    /** @readonly */
-    curly,
-}
+export const curly = type => name => body => [`${type} ${name}`, '{', body, '}']

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

@@ -1,14 +1,12 @@
-declare namespace _default {
-    export { sgr };
-    export let reset: string;
-    export let bold: string;
-    export let fgRed: string;
-    export let fgGreen: string;
-}
-export default _default;
 /**
  * https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
  *
  * @type {(c: number) => string}
  */
-declare const sgr: (c: number) => string;
+export const sgr: (c: number) => string;
+export namespace codes {
+    let reset: string;
+    let bold: string;
+    let fgRed: string;
+    let fgGreen: string;
+}

package/text/sgr/module.f.mjs

@@ -5,11 +5,9 @@
  *
  * @type {(c: number) => string}
  */
-const sgr = c => `\x1b[${c.toString()}m`
+export const sgr = c => `\x1b[${c.toString()}m`
 
-export default {
-    /** @readonly */
-    sgr,
+export const codes = {
     /** @readonly */
     reset: sgr(0),
     /** @readonly */

package/text/test.f.mjs

@@ -1,9 +1,9 @@
-import _, * as T from './module.f.mjs'
-import string from '../types/string/module.f.mjs'
+import * as _ from './module.f.mjs'
+import * as string from '../types/string/module.f.mjs'
 const { join } = string
 
 export default () => {
-    /** @type {T.Block} */
+    /** @type {_.Block} */
     const text = [
         'a',
         'b',

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

@@ -1,19 +1,12 @@
-declare namespace _default {
-    export { fromCodePointList };
-    export { toCodePointList };
-    export { stringToList };
-    export { listToString };
-}
-export default _default;
+export const fromCodePointList: (input: list.List<number>) => list.Thunk<number>;
+/** @type {(input: list.List<u16>) => list.List<i32>} */
+export const toCodePointList: (input: list.List<u16>) => list.List<i32>;
+/** @type {(s: string) => list.List<u16>} */
+export const stringToList: (s: string) => list.List<u16>;
+/** @type {(input: list.List<u16>) => string} */
+export const listToString: (input: list.List<u16>) => string;
 export type WordOrEof = u16 | null;
 export type Utf16State = number | null;
 export type u16 = number;
 export type i32 = number;
-declare const fromCodePointList: (input: List.List<number>) => List.Thunk<number>;
-/** @type {(input: List.List<u16>) => List.List<i32>} */
-declare const toCodePointList: (input: List.List<u16>) => List.List<i32>;
-/** @type {(s: string) => List.List<u16>} */
-declare const stringToList: (s: string) => List.List<u16>;
-/** @type {(input: List.List<u16>) => string} */
-declare const listToString: (input: List.List<u16>) => string;
-import * as List from '../../types/list/module.f.mjs';
+import * as list from '../../types/list/module.f.mjs';

package/text/utf16/module.f.mjs

@@ -1,9 +1,9 @@
 // @ts-self-types="./module.f.d.mts"
-import list, * as List from '../../types/list/module.f.mjs'
-import operator, * as Operator from '../../types/function/operator/module.f.mjs'
-import range from '../../types/range/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
+import * as operator from '../../types/function/operator/module.f.mjs'
+import * as range from '../../types/range/module.f.mjs'
 const { contains } = range
-import f from '../../types/function/module.f.mjs'
+import * as f from '../../types/function/module.f.mjs'
 const { fn } = f
 const { map, flat, stateScan, reduce, flatMap, empty } = list
 
@@ -32,7 +32,7 @@ const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000
 /** @type {(a: i32) => boolean} */
 const isSupplementaryPlane = contains([0x01_0000, 0x10_ffff])
 
-/** @type {(input: i32) => List.List<u16>} */
+/** @type {(input: i32) => list.List<u16>} */
 const codePointToUtf16 = codePoint => {
     if (isBmpCodePoint(codePoint)) { return [codePoint] }
     if (isSupplementaryPlane(codePoint)) {
@@ -44,11 +44,11 @@ const codePointToUtf16 = codePoint => {
     return [codePoint & 0xffff]
 }
 
-const fromCodePointList = flatMap(codePointToUtf16)
+export const fromCodePointList = flatMap(codePointToUtf16)
 
 const u16 = contains([0x0000, 0xFFFF])
 
-/** @type {Operator.StateScan<u16, Utf16State, List.List<i32>>} */
+/** @type {operator.StateScan<u16, Utf16State, list.List<i32>>} */
 const utf16ByteToCodePointOp = state => word => {
     if (!u16(word)) {
         return [[0xffffffff], state]
@@ -68,21 +68,21 @@ const utf16ByteToCodePointOp = state => word => {
     return [[state | errorMask, word | errorMask], null]
 }
 
-/** @type {(state: Utf16State) => readonly[List.List<i32>, Utf16State]} */
+/** @type {(state: Utf16State) => readonly[list.List<i32>, Utf16State]} */
 const utf16EofToCodePointOp = state => [state === null ? empty : [state | errorMask],  null]
 
-/** @type {Operator.StateScan<WordOrEof, Utf16State, List.List<i32>>} */
+/** @type {operator.StateScan<WordOrEof, Utf16State, list.List<i32>>} */
 const utf16ByteOrEofToCodePointOp = state => input => input === null ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input)
 
-/** @type {List.List<WordOrEof>} */
+/** @type {list.List<WordOrEof>} */
 const eofList = [null]
 
-/** @type {(input: List.List<u16>) => List.List<i32>} */
-const toCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(null)(flat([input, eofList])))
+/** @type {(input: list.List<u16>) => list.List<i32>} */
+export const toCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(null)(flat([input, eofList])))
 
-/** @type {(s: string) => List.List<u16>} */
-const stringToList = s => {
-    /** @type {(i: number) => List.Result<number>} */
+/** @type {(s: string) => list.List<u16>} */
+export const stringToList = s => {
+    /** @type {(i: number) => list.Result<number>} */
     const at = i => {
         const first = s.charCodeAt(i)
         return isNaN(first) ? empty : { first, tail: () => at(i + 1) }
@@ -90,18 +90,7 @@ const stringToList = s => {
     return at(0)
 }
 
-/** @type {(input: List.List<u16>) => string} */
-const listToString = fn(map(String.fromCharCode))
+/** @type {(input: list.List<u16>) => string} */
+export const listToString = fn(map(String.fromCharCode))
     .then(reduce(operator.concat)(''))
     .result
-
-export default {
-    /** @readonly */
-    fromCodePointList,
-    /** @readonly */
-    toCodePointList,
-    /** @readonly */
-    stringToList,
-    /** @readonly */
-    listToString
-}

package/text/utf16/test.f.mjs

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

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

@@ -1,15 +1,10 @@
-declare namespace _default {
-    export { fromCodePointList };
-    export { toCodePointList };
-}
-export default _default;
+export const fromCodePointList: (input: list.List<number>) => list.Thunk<number>;
+/** @type {(input: list.List<u8>) => list.List<i32>} */
+export const toCodePointList: (input: list.List<u8>) => list.List<i32>;
 export type ByteOrEof = u8 | null;
 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 list from '../../types/list/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,5 +1,5 @@
 // @ts-self-types="./module.f.d.mts"
-import list, * as List from '../../types/list/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 import * as operator from '../../types/function/operator/module.f.mjs'
 import * as Array from '../../types/array/module.f.mjs'
 const { flatMap, flat, stateScan } = list
@@ -16,7 +16,7 @@ const { flatMap, flat, stateScan } = list
 
 const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000
 
-/** @type {(input:number) => List.List<u8>} */
+/** @type {(input:number) => list.List<u8>} */
 const codePointToUtf8 = input => {
     if (input >= 0x0000 && input <= 0x007f) { return [input & 0b01111_1111] }
     if (input >= 0x0080 && input <= 0x07ff) { return [input >> 6 | 0b1100_0000, input & 0b0011_1111 | 0b1000_0000] }
@@ -31,7 +31,7 @@ const codePointToUtf8 = input => {
     return [errorMask]
 }
 
-const fromCodePointList = flatMap(codePointToUtf8)
+export const fromCodePointList = flatMap(codePointToUtf8)
 
 /** @type {(state: Utf8NonEmptyState) => i32}*/
 const utf8StateToError = state => {
@@ -59,7 +59,7 @@ const utf8StateToError = state => {
     return x | errorMask
 }
 
-/** @type {operator.StateScan<number, Utf8State, List.List<i32>>} */
+/** @type {operator.StateScan<number, Utf8State, list.List<i32>>} */
 const utf8ByteToCodePointOp = state => byte => {
     if (byte < 0x00 || byte > 0xff) {
         return [[errorMask], state]
@@ -95,22 +95,15 @@ const utf8ByteToCodePointOp = state => byte => {
     return [[error, byte | errorMask], null]
 }
 
-/** @type {(state: Utf8State) => readonly[List.List<i32>, Utf8State]} */
+/** @type {(state: Utf8State) => readonly[list.List<i32>, Utf8State]} */
 const utf8EofToCodePointOp = state =>
     [state === null ? null : [utf8StateToError(state)], null]
 
-/** @type {operator.StateScan<ByteOrEof, Utf8State, List.List<i32>>} */
+/** @type {operator.StateScan<ByteOrEof, Utf8State, list.List<i32>>} */
 const utf8ByteOrEofToCodePointOp = state => input => input === null ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input)
 
-/** @type {List.List<ByteOrEof>} */
+/** @type {list.List<ByteOrEof>} */
 const eofList = [null]
 
-/** @type {(input: List.List<u8>) => List.List<i32>} */
-const toCodePointList = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(null)(flat([input, eofList])))
-
-export default {
-    /** @readonly */
-    fromCodePointList,
-    /** @readonly */
-    toCodePointList
-}
+/** @type {(input: list.List<u8>) => list.List<i32>} */
+export const toCodePointList = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(null)(flat([input, eofList])))

package/text/utf8/test.f.mjs

@@ -1,8 +1,8 @@
-import encoding from './module.f.mjs'
-import json from '../../json/module.f.mjs'
-import o from '../../types/object/module.f.mjs'
+import * as encoding from './module.f.mjs'
+import * as json from '../../json/module.f.mjs'
+import * as o from '../../types/object/module.f.mjs'
 const { sort } = o
-import list from '../../types/list/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 
 const stringify = json.stringify(sort)
 

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

@@ -1,13 +1,17 @@
-declare namespace _default {
-    export { at };
-    export { first };
-    export { last };
-    export { head };
-    export { tail };
-    export { splitFirst };
-    export { splitLast };
-}
-export default _default;
+/** @type {(index: number) => <T>(a: readonly T[]) => T|null} */
+export const at: (index: number) => <T>(a: readonly T[]) => T | null;
+/** @type {<T>(_: readonly T[]) => T|null} */
+export const first: <T>(_: readonly T[]) => T | null;
+/** @type {<T>(_: readonly T[]) => T|null} */
+export const last: <T>(_: readonly T[]) => T | null;
+/** @type {<T>(_: readonly T[]) => readonly T[] | null} */
+export const tail: <T>(_: readonly T[]) => readonly T[] | null;
+/** @type {<T>(_: readonly T[]) => readonly[T, readonly T[]]|null} */
+export const splitFirst: <T>(_: readonly T[]) => readonly [T, readonly T[]] | null;
+/** @type {<T>(_: readonly T[]) => readonly T[]|null} */
+export const head: <T>(_: readonly T[]) => readonly T[] | null;
+/** @type {<T>(_: readonly T[]) => readonly[readonly T[], T]|null} */
+export const splitLast: <T>(_: readonly T[]) => readonly [readonly T[], T] | null;
 export type Array1<T> = readonly [T];
 export type Index1 = 0;
 export type Array2<T> = readonly [T, T];
@@ -25,17 +29,3 @@ export type Index16 = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13
 export type Array1_5<T> = Array1<T> | Array2<T> | Array3<T> | Array4<T> | Array5<T>;
 export type Index5 = 0 | 1 | 2 | 3 | 4;
 export type KeyOf<T> = T extends Array1<infer _> ? Index1 : T extends Array2<infer _> ? Index2 : T extends Array3<infer _> ? Index3 : T extends Array4<infer _> ? Index4 : T extends Array5<infer _> ? Index5 : T extends readonly (infer _)[] ? number : never;
-/** @type {(index: number) => <T>(a: readonly T[]) => T|null} */
-declare const at: (index: number) => <T>(a: readonly T[]) => T | null;
-/** @type {<T>(_: readonly T[]) => T|null} */
-declare const first: <T>(_: readonly T[]) => T | null;
-/** @type {<T>(_: readonly T[]) => T|null} */
-declare const last: <T>(_: readonly T[]) => T | null;
-/** @type {<T>(_: readonly T[]) => readonly T[]|null} */
-declare const head: <T>(_: readonly T[]) => readonly T[] | null;
-/** @type {<T>(_: readonly T[]) => readonly T[] | null} */
-declare const tail: <T>(_: readonly T[]) => readonly T[] | null;
-/** @type {<T>(_: readonly T[]) => readonly[T, readonly T[]]|null} */
-declare const splitFirst: <T>(_: readonly T[]) => readonly [T, readonly T[]] | null;
-/** @type {<T>(_: readonly T[]) => readonly[readonly T[], T]|null} */
-declare const splitLast: <T>(_: readonly T[]) => readonly [readonly T[], T] | null;