functionalscript 0.1.609 → 0.2.0

package/fsm/module.f.d.mts

@@ -1,21 +1,14 @@
-declare namespace _default {
-    export { dfa };
-    export { run };
-    export { toRange };
-    export { toUnion };
-}
-export default _default;
-export type Rule = readonly [string, byteSetT.ByteSet, string];
-export type Grammar = List.List<Rule>;
-export type Dfa = { readonly [state in string]: RM.RangeMapArray<string>; };
+/** @type {(s: string) => byteSet.ByteSet} */
+export const toRange: (s: string) => byteSet.ByteSet;
+/** @type {(s: string) => byteSet.ByteSet} */
+export const toUnion: (s: string) => byteSet.ByteSet;
 /** @type {(grammar: Grammar) => Dfa} */
-declare const dfa: (grammar: Grammar) => Dfa;
-/** @type {(dfa: Dfa) => (input: List.List<number>) => List.List<string>} */
-declare const run: (dfa: Dfa) => (input: List.List<number>) => List.List<string>;
-/** @type {(s: string) => byteSetT.ByteSet} */
-declare const toRange: (s: string) => byteSetT.ByteSet;
-/** @type {(s: string) => byteSetT.ByteSet} */
-declare const toUnion: (s: string) => byteSetT.ByteSet;
-import * as byteSetT from '../types/byte_set/module.f.mjs';
-import * as List from '../types/list/module.f.mjs';
-import * as RM from '../types/range_map/module.f.mjs';
+export const dfa: (grammar: Grammar) => Dfa;
+/** @type {(dfa: Dfa) => (input: list.List<number>) => list.List<string>} */
+export const run: (dfa: Dfa) => (input: list.List<number>) => list.List<string>;
+export type Rule = readonly [string, byteSet.ByteSet, string];
+export type Grammar = list.List<Rule>;
+export type Dfa = { readonly [state in string]: rangeMap.RangeMapArray<string>; };
+import * as byteSet from '../types/byte_set/module.f.mjs';
+import * as list from '../types/list/module.f.mjs';
+import * as rangeMap from '../types/range_map/module.f.mjs';

package/fsm/module.f.mjs

@@ -1,73 +1,73 @@
 // @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 { equal, isEmpty, fold, toArray, scan, foldScan, empty: emptyList } = list
-import byteSet, * as byteSetT from '../types/byte_set/module.f.mjs'
+import * as byteSet from '../types/byte_set/module.f.mjs'
 const { toRangeMap, union: byteSetUnion, one, empty } = byteSet
-import sortedSet, * as SortedSet from '../types/sorted_set/module.f.mjs'
+import * as sortedSet from '../types/sorted_set/module.f.mjs'
 const { intersect, union: sortedSetUnion } = sortedSet
-import rangeMap, * as RM from '../types/range_map/module.f.mjs'
+import * as rangeMap from '../types/range_map/module.f.mjs'
 const { merge } = rangeMap
-import cmp from '../types/function/compare/module.f.mjs'
+import * as cmp from '../types/function/compare/module.f.mjs'
 const { unsafeCmp } = cmp
-import operator, * as Operator from '../types/function/operator/module.f.mjs'
+import * as operator from '../types/function/operator/module.f.mjs'
 const { strictEqual } = operator
-import j from '../json/module.f.mjs'
+import * as j from '../json/module.f.mjs'
 const { stringify } = j
-import f from '../types/function/module.f.mjs'
+import * as f from '../types/function/module.f.mjs'
 const { identity } = f
-import utf16 from '../text/utf16/module.f.mjs'
+import * as utf16 from '../text/utf16/module.f.mjs'
 const { stringToList } = utf16
 
-/** @typedef {readonly[string, byteSetT.ByteSet, string]} Rule */
+/** @typedef {readonly[string, byteSet.ByteSet, string]} Rule */
 
-/** @typedef {List.List<Rule>} Grammar */
+/** @typedef {list.List<Rule>} Grammar */
 
 /**
  * @typedef {{
- *  readonly[state in string]: RM.RangeMapArray<string>
+ *  readonly[state in string]: rangeMap.RangeMapArray<string>
  * }} Dfa
  */
 
 const stringifyIdentity = stringify(identity)
 
-/** @type {(s: string) => byteSetT.ByteSet} */
-const toRange = s => {
+/** @type {(s: string) => byteSet.ByteSet} */
+export const toRange = s => {
     const [b, e] = toArray(stringToList(s))
     return byteSet.range([b, e])
 }
 
-/** @type {Operator.Fold<number, byteSetT.ByteSet>} */
+/** @type {operator.Fold<number, byteSet.ByteSet>} */
 const toUnionOp = i => bs => byteSetUnion(bs)(one(i))
 
-/** @type {(s: string) => byteSetT.ByteSet} */
-const toUnion = s => {
+/** @type {(s: string) => byteSet.ByteSet} */
+export const toUnion = s => {
     const codePoints = stringToList(s)
     return fold(toUnionOp)(empty)(codePoints)
 }
 
-/** @type {RM.Operators<SortedSet.SortedSet<string>>} */
+/** @type {rangeMap.Operators<sortedSet.SortedSet<string>>} */
 const mergeOp = { union: sortedSetUnion(unsafeCmp), equal: equal(strictEqual) }
 
-/** @type {(s: string) => (set: SortedSet.SortedSet<string>) => boolean} */
+/** @type {(s: string) => (set: sortedSet.SortedSet<string>) => boolean} */
 const hasState = s => set => !isEmpty(intersect(unsafeCmp)([s])(set))
 
-/** @type {(set: SortedSet.SortedSet<string>) => Operator.Fold<Rule, RM.RangeMap<SortedSet.SortedSet<string>>>} */
+/** @type {(set: sortedSet.SortedSet<string>) => operator.Fold<Rule, rangeMap.RangeMap<sortedSet.SortedSet<string>>>} */
 const foldOp = set => ([ruleIn, bs, ruleOut]) => rm => {
     if (hasState(ruleIn)(set)) { return merge(mergeOp)(rm)(toRangeMap(bs)(ruleOut)) }
     return rm
 }
 
-/** @type {Operator.Scan<RM.Entry<SortedSet.SortedSet<string>>, RM.Entry<string>>} */
+/** @type {operator.Scan<rangeMap.Entry<sortedSet.SortedSet<string>>, rangeMap.Entry<string>>} */
 const stringifyOp = ([sortedSet, max]) => [[stringifyIdentity(sortedSet), max], stringifyOp]
 
 const scanStringify = scan(stringifyOp)
 
-/** @type {Operator.Scan<RM.Entry<SortedSet.SortedSet<string>>, SortedSet.SortedSet<string>>} */
+/** @type {operator.Scan<rangeMap.Entry<sortedSet.SortedSet<string>>, sortedSet.SortedSet<string>>} */
 const fetchOp = ([item, _]) => [item, fetchOp]
 
 const scanFetch = scan(fetchOp)
 
-/** @type {(grammar: Grammar) => Operator.Fold<SortedSet.SortedSet<string>, Dfa>} */
+/** @type {(grammar: Grammar) => operator.Fold<sortedSet.SortedSet<string>, Dfa>} */
 const addEntry = grammar => set => dfa => {
     const s = stringifyIdentity(set)
     if (s in dfa) { return dfa }
@@ -88,23 +88,12 @@ const initialState = ['']
 const initialStateStringify = stringifyIdentity(initialState)
 
 /** @type {(grammar: Grammar) => Dfa} */
-const dfa = grammar => addEntry(grammar)(initialState)({})
+export const dfa = grammar => addEntry(grammar)(initialState)({})
 
 const get = rangeMap.get(emptyStateStringify)
 
-/** @type {(dfa: Dfa) => Operator.Fold<number, string>} */
+/** @type {(dfa: Dfa) => operator.Fold<number, string>} */
 const runOp = dfa => input => s => get(input)(dfa[s])
 
-/** @type {(dfa: Dfa) => (input: List.List<number>) => List.List<string>} */
-const run = dfa => input => foldScan(runOp(dfa))(initialStateStringify)(input)
-
-export default {
-    /** @readonly */
-    dfa,
-    /** @readonly */
-    run,
-    /** @readonly */
-    toRange,
-    /** @readonly */
-    toUnion
-}
+/** @type {(dfa: Dfa) => (input: list.List<number>) => list.List<string>} */
+export const run = dfa => input => foldScan(runOp(dfa))(initialStateStringify)(input)

package/fsm/test.f.mjs

@@ -1,13 +1,13 @@
-import _, * as T from './module.f.mjs'
-import byteSet from '../types/byte_set/module.f.mjs'
-import o from '../types/object/module.f.mjs'
+import * as _ from './module.f.mjs'
+import * as byteSet from '../types/byte_set/module.f.mjs'
+import * as o from '../types/object/module.f.mjs'
 const { sort, fromEntries } = o
-import json from '../json/module.f.mjs'
-import f from '../types/function/module.f.mjs'
+import * as json from '../json/module.f.mjs'
+import * as f from '../types/function/module.f.mjs'
 const { identity } = f
-import list from '../types/list/module.f.mjs'
+import * as list from '../types/list/module.f.mjs'
 const { toArray } = list
-import utf16 from '../text/utf16/module.f.mjs'
+import * as utf16 from '../text/utf16/module.f.mjs'
 const { stringToList } = utf16
 
 const stringifyIdentity = json.stringify(identity)
@@ -22,7 +22,7 @@ const buildDfa = () => {
     const idNext = byteSet.union(idBegin)(digit)
     const dot = _.toUnion('.')
 
-    /** @type {T.Grammar} */
+    /** @type {_.Grammar} */
     const grammar = [
         ['', digit, 'int'],
         ['int', digit, 'int'],

package/html/module.f.d.mts

@@ -1,9 +1,7 @@
-declare namespace _default {
-    export { element };
-    export { html };
-    export { htmlToString };
-}
-export default _default;
+/** @type {(element: Element) => list.List<string>} */
+export const element: (element: Element) => list.List<string>;
+export const html: f.Func<Element, list.List<string>>;
+export const htmlToString: f.Func<Element, string>;
 export type Tag = string;
 export type Element1 = readonly [Tag];
 export type Element2A = readonly [Tag, Attributes];
@@ -11,10 +9,7 @@ export type Element2N = readonly [Tag, readonly Node[]];
 export type Element3 = readonly [Tag, Attributes, Nodes];
 export type Element = Element1 | Element2A | Element2N | Element3;
 export type Attributes = { readonly [k in string]: string; };
-export type Nodes = List.List<Node>;
+export type Nodes = list.List<Node>;
 export type Node = Element | string;
-/** @type {(element: Element) => List.List<string>} */
-declare const element: (element: Element) => List.List<string>;
-declare const html: import("../types/function/module.f.mjs").Func<Element, List.List<string>>;
-declare const htmlToString: import("../types/function/module.f.mjs").Func<Element, string>;
-import * as List from '../types/list/module.f.mjs';
+import * as list from '../types/list/module.f.mjs';
+import * as f from '../types/function/module.f.mjs';

package/html/module.f.mjs

@@ -1,12 +1,12 @@
 // @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 { map, flatMap, flat, concat: listConcat } = list
-import s from '../types/string/module.f.mjs'
+import * as s from '../types/string/module.f.mjs'
 const { concat: stringConcat } = s
 import * as O from '../types/object/module.f.mjs'
-import f from '../types/function/module.f.mjs'
+import * as f from '../types/function/module.f.mjs'
 const { compose } = f
-import utf16 from '../text/utf16/module.f.mjs'
+import * as utf16 from '../text/utf16/module.f.mjs'
 const { stringToList } = utf16
 const { fromCharCode } = String
 const { entries } = Object
@@ -50,7 +50,7 @@ const isVoid = tag => voidTagList.includes(tag)
  * }} Attributes
  */
 
-/** @typedef {List.List<Node>} Nodes */
+/** @typedef {list.List<Node>} Nodes */
 
 /** @typedef {Element | string} Node */
 
@@ -71,33 +71,33 @@ const escapeCharCode = code => {
 
 const escape = compose(stringToList)(map(escapeCharCode))
 
-/** @type {(n: Node) => List.List<string>} */
+/** @type {(n: Node) => list.List<string>} */
 const node = n => typeof n === 'string' ? escape(n) : element(n)
 
 const nodes = flatMap(node)
 
-/** @type {(a: O.Entry<string>) => List.List<string>} */
+/** @type {(a: O.Entry<string>) => list.List<string>} */
 const attribute = ([name, value]) => flat([[' ', name, '="'], escape(value), ['"']])
 
-/** @type {(a: Attributes) => List.List<string>} */
+/** @type {(a: Attributes) => list.List<string>} */
 const attributes = compose(entries)(flatMap(attribute))
 
 const open = (/** @type {Element2A} */[tag, a]) => flat([[`<`, tag], attributes(a), [`>`]])
 
 const close = (/** @type {string}*/tag) => ['</', tag, '>']
 
-/** @type {(_: Element3) => List.List<string>} */
+/** @type {(_: Element3) => list.List<string>} */
 const element3 = ([tag, a, ns]) =>
     flat([open([tag, a]), nodes(ns), close(tag)])
 
-/** @type {(_: Element2A) => List.List<string>} */
+/** @type {(_: Element2A) => list.List<string>} */
 const element2a = e => {
     const [tag] = e
     return flat([open(e), isVoid(tag) ? [] : close(tag)])
 }
 
-/** @type {(element: Element) => List.List<string>} */
-const element = e => {
+/** @type {(element: Element) => list.List<string>} */
+export const element = e => {
     switch (e.length) {
         case 1: { return element2a([e[0], {}]) }
         case 2: {
@@ -112,15 +112,6 @@ const element = e => {
     }
 }
 
-const html = compose(element)(listConcat(['<!DOCTYPE html>']))
+export const html = compose(element)(listConcat(['<!DOCTYPE html>']))
 
-const htmlToString = compose(html)(stringConcat)
-
-export default {
-    /** @readonly */
-    element,
-    /** @readonly */
-    html,
-    /** @readonly */
-    htmlToString,
-}
+export const htmlToString = compose(html)(stringConcat)

package/html/test.f.mjs

@@ -1,4 +1,4 @@
-import _, * as T from './module.f.mjs'
+import * as _ from './module.f.mjs'
 
 export default {
     empty: () => {
@@ -14,19 +14,19 @@ export default {
         if (r !== '<!DOCTYPE html><area>') { throw r }
     },
     some: () => {
-        /** @type {T.Element} */
+        /** @type {_.Element} */
         const x = ['div', {}, ['<div>&amp;</div>', ['a', { href: 'hello"' }, []]]]
         const s = _.htmlToString(x)
         if (s !== '<!DOCTYPE html><div>&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') { throw s }
     },
     some2: () => {
-        /** @type {T.Element} */
+        /** @type {_.Element} */
         const x = ['div', ['<div>&amp;</div>', ['a', { href: 'hello"' }, []]]]
         const s = _.htmlToString(x)
         if (s !== '<!DOCTYPE html><div>&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') { throw s }
     },
     someVoid: () => {
-        /** @type {T.Element} */
+        /** @type {_.Element} */
         const x = ['div', [['br', {id: '5'}], '<div>&amp;</div>', ['a', { href: 'hello"' }, []]]]
         const s = _.htmlToString(x)
         if (s !== '<!DOCTYPE html><div><br id="5">&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') { throw s }

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

@@ -1,8 +1,7 @@
-declare namespace _default {
-    export { tokenize };
-    export { isKeywordToken };
-}
-export default _default;
+/** @type {(token: JsToken) => Boolean} */
+export const isKeywordToken: (token: JsToken) => boolean;
+/** @type {(input: list.List<number>) => list.List<JsToken>} */
+export const tokenize: (input: list.List<number>) => list.List<JsToken>;
 export type StringToken = {
     readonly kind: "string";
     readonly value: string;
@@ -132,12 +131,12 @@ export type EofState = {
     readonly kind: "eof";
 };
 export type CharCodeOrEof = number | null;
-export type ToToken = (input: number) => readonly [List.List<JsToken>, TokenizerState];
+export type ToToken = (input: number) => readonly [list.List<JsToken>, TokenizerState];
 /**
  * <T>
  */
 export type CreateToToken<T> = (state: T) => ToToken;
-export type RangeSet = List.List<Range.Range>;
+export type RangeSet = list.List<_range.Range>;
 /**
  * <T>
  */
@@ -145,12 +144,8 @@ export type RangeFunc<T> = (def: CreateToToken<T>) => (RangeMapToToken<T>);
 /**
  * <T>
  */
-export type RangeMapToToken<T> = RangeMap.RangeMapArray<CreateToToken<T>>;
-/** @type {(input: List.List<number>) => List.List<JsToken>} */
-declare const tokenize: (input: List.List<number>) => List.List<JsToken>;
-/** @type {(token: JsToken) => Boolean} */
-declare const isKeywordToken: (token: JsToken) => boolean;
+export type RangeMapToToken<T> = range_map.RangeMapArray<CreateToToken<T>>;
+import * as list from '../../types/list/module.f.mjs';
 import * as bigfloatT from '../../types/bigfloat/module.f.mjs';
-import * as List from '../../types/list/module.f.mjs';
-import * as Range from '../../types/range/module.f.mjs';
-import * as RangeMap from '../../types/range_map/module.f.mjs';
+import * as _range from '../../types/range/module.f.mjs';
+import * as range_map from '../../types/range_map/module.f.mjs';