@isopodlabs/utilities 1.5.5 → 1.5.7

package/dist/glob.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGlob = parseGlob;
+exports.anchoredRe = anchoredRe;
+exports.globToRe = globToRe;
+exports.globToReMulti = globToReMulti;
+const posixClasses = {
+    alnum: '\\p{L}\\p{Nl}\\p{Nd}',
+    alpha: '\\p{L}\\p{Nl}',
+    ascii: '\\x00-\\x7f',
+    blank: '\\p{Zs}\\t',
+    cntrl: '\\p{Cc}',
+    digit: '\\p{Nd}',
+    graph: '^\\p{Z}\\p{C}',
+    lower: '\\p{Ll}',
+    print: '\\p{C}',
+    punct: '\\p{P}',
+    space: '\\p{Z}\\t\\r\\n\\v\\f',
+    upper: '\\p{Lu}',
+    word: '\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}',
+    xdigit: 'A-Fa-f0-9',
+};
+//-----------------------------------------------------------------------------
+// Glob pattern to regex
+//-----------------------------------------------------------------------------
+function parseGlob(glob) {
+    let result = '';
+    let depth = 0;
+    for (let i = 0; i < glob.length; ++i) {
+        let c = glob[i];
+        switch (c) {
+            case '\\':
+                c = glob[++i];
+                if ('*?+.,^$()|[]a-zA-Z'.includes(c))
+                    result += '\\';
+                break;
+            case '*':
+                if (glob[i + 1] === '*') {
+                    result += '.*';
+                    ++i;
+                }
+                else {
+                    result += '[^/]*';
+                }
+                continue;
+            case '?':
+                c = '.';
+                break;
+            case '+':
+            case '.':
+            case '^':
+            case '$':
+            case '(':
+            case ')':
+            case '|':
+                result += `\\`;
+                break;
+            case '[': {
+                const end = glob.indexOf(']', i + 1);
+                if (end > i) {
+                    const next = glob[i + 1];
+                    if (next === ':' && glob[end - 1] === ':') {
+                        const p = posixClasses[glob.slice(i + 2, end - 1)];
+                        if (p) {
+                            result += `[${p}]`;
+                            i = end;
+                            continue;
+                        }
+                        else {
+                            console.log(`Warning: Unknown POSIX class ${glob.slice(i + 2, end - 1)} in glob pattern ${glob}`);
+                        }
+                    }
+                    const neg = next === '!' || next === '^';
+                    result += `[${neg ? '^' : ''}${glob.slice(neg ? i + 2 : i + 1, end)}]`;
+                    i = end;
+                    continue;
+                }
+                result += '\\';
+                break;
+            }
+            case '{':
+                ++depth;
+                c = '(';
+                break;
+            case '}':
+                if (depth > 0) {
+                    --depth;
+                    c = ')';
+                }
+                break;
+            case ',':
+                if (depth > 0)
+                    c = '|';
+                break;
+        }
+        result += c;
+    }
+    if (depth > 0) {
+        console.log(`Warning: Unmatched { in glob pattern ${glob}`);
+        result += ')'.repeat(depth);
+    }
+    return result;
+}
+function anchoredRe(re) {
+    return new RegExp(`^${re}$`);
+}
+function globToRe(glob) {
+    return anchoredRe(parseGlob(glob));
+}
+function globToReMulti(globs) {
+    return anchoredRe(globs.map(parseGlob).join('|'));
+}

package/dist/index.d.ts

@@ -2,4 +2,10 @@ export * from './object';
 export * from './iterator';
 export * from './string';
 export * from './algorithm';
+export * from './glob';
+export * as bits from './bits';
+export * as array from './array';
+export * as async from './async';
 export * as insensitive from './insensitive';
+export declare function parallel(...fns: (() => any)[]): Promise<any[]>;
+export declare function serial(...fns: (() => any)[]): Promise<any[]>;

package/dist/index.js

@@ -15,9 +15,6 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 var __importStar = (this && this.__importStar) || (function () {
     var ownKeys = function(o) {
         ownKeys = Object.getOwnPropertyNames || function (o) {
@@ -35,10 +32,26 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.insensitive = void 0;
+exports.insensitive = exports.async = exports.array = exports.bits = void 0;
+exports.parallel = parallel;
+exports.serial = serial;
+const async = __importStar(require("./async"));
 __exportStar(require("./object"), exports);
 __exportStar(require("./iterator"), exports);
 __exportStar(require("./string"), exports);
 __exportStar(require("./algorithm"), exports);
+__exportStar(require("./glob"), exports);
+exports.bits = __importStar(require("./bits"));
+exports.array = __importStar(require("./array"));
+exports.async = __importStar(require("./async"));
 exports.insensitive = __importStar(require("./insensitive"));
+async function parallel(...fns) {
+    return async.map(fns, f => f());
+}
+async function serial(...fns) {
+    return async.mapSerial(fns, f => f());
+}

package/dist/insensitive.d.ts

@@ -19,7 +19,7 @@ declare class CaseInsensitiveString2 extends CaseInsensitiveString {
 }
 export declare function String(value: string): CaseInsensitiveString;
 export declare function String2(value: string): CaseInsensitiveString2;
-export declare function compare(a: string, b: string): 0 | 1 | -1;
+export declare function compare(a: string | CaseInsensitiveString, b: string | CaseInsensitiveString): 0 | 1 | -1;
 export declare function Record<T>(obj: Record<string, T>): Record<string, T>;
 export declare function Record2<T>(obj: Record<string, T>): Record<string, T>;
 export declare class Map<T> extends globalThis.Map<string, T> {

package/dist/insensitive.js

@@ -60,11 +60,7 @@ function Record2(obj) {
 }
 class Map extends globalThis.Map {
     constructor(entries) {
-        super();
-        if (entries) {
-            for (const [key, value] of entries)
-                this.set(key, value);
-        }
+        super(Array.from(entries || []).map(([k, v]) => [k.toUpperCase(), v]));
     }
     delete(key) { return super.delete(key.toUpperCase()); }
     get(key) { return super.get(key.toUpperCase()); }
@@ -74,11 +70,7 @@ class Map extends globalThis.Map {
 exports.Map = Map;
 class Set extends globalThis.Set {
     constructor(values) {
-        super();
-        if (values) {
-            for (const value of values)
-                this.add(value);
-        }
+        super(Array.from(values || []).map(v => v.toUpperCase()));
     }
     add(value) { return super.add(value.toUpperCase()); }
     delete(value) { return super.delete(value.toUpperCase()); }

package/dist/iterator.d.ts

@@ -1,18 +1,7 @@
 export type SpreadType<T> = T extends Iterable<infer U> ? U[] : never;
-export declare function arrayRemove<T>(array: T[], item: T): boolean;
-export declare function arrayCompare<T>(arr1: T[], arr2: T[]): number;
-export declare function arrayEqual<T>(arr1: T[], arr2: T[]): boolean;
-export declare function arrayRotate<T>(array: T[], start: number, end: number, shift: number): void;
-export declare function arrayReverse<T>(array: T[], start: number, end: number): void;
-export declare function arrayMake<T>(n: number, constructor: new () => T): T[];
+export declare function remove<T>(iterable: Iterable<T>, item: T): boolean;
 export declare function forEach<T>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => void): void;
 export declare function find<T>(iterable: Iterable<T> | undefined, func: (v: T) => boolean): T | undefined;
 export declare function map<T, U>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => U): U[];
 export declare function reduce<T, U>(iterable: Iterable<T>, func: (acc: U, v: T, i: number, iterable: Iterable<T>) => U, initialValue: U): U;
 export declare function filter<T>(iterable: Iterable<T>, func: (v: T, i: number) => unknown): T[];
-export declare function asyncMap<T, U>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => Promise<U>): Promise<U[]>;
-export declare function asyncMapSerial<T, U>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => Promise<U>): Promise<U[]>;
-export declare function asyncReduce<T, U>(iterable: Iterable<T>, func: (acc: U, v: T, i: number, iterable: Iterable<T>) => Promise<U>, initialValue: U): Promise<U>;
-export declare function asyncFilter<T>(iterable: Iterable<T>, func: (v: T) => Promise<unknown>): Promise<T[]>;
-export declare function parallel(...fns: (() => any)[]): Promise<any[]>;
-export declare function serial(...fns: (() => any)[]): Promise<any[]>;

package/dist/iterator.js

@@ -1,67 +1,47 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayRemove = arrayRemove;
-exports.arrayCompare = arrayCompare;
-exports.arrayEqual = arrayEqual;
-exports.arrayRotate = arrayRotate;
-exports.arrayReverse = arrayReverse;
-exports.arrayMake = arrayMake;
+exports.remove = remove;
 exports.forEach = forEach;
 exports.find = find;
 exports.map = map;
 exports.reduce = reduce;
 exports.filter = filter;
-exports.asyncMap = asyncMap;
-exports.asyncMapSerial = asyncMapSerial;
-exports.asyncReduce = asyncReduce;
-exports.asyncFilter = asyncFilter;
-exports.parallel = parallel;
-exports.serial = serial;
-const object_1 = require("./object");
-//remove element of array
-function arrayRemove(array, item) {
-    const index = array.indexOf(item);
-    if (index === -1)
-        return false;
-    array.splice(index, 1);
-    return true;
-}
-function arrayCompare(arr1, arr2) {
-    const length = Math.min(arr1.length, arr2.length);
-    for (let i = 0; i < length; i++) {
-        const r = (0, object_1.compare)(arr1[i], arr2[i]);
-        if (r)
-            return r;
-    }
-    return arr1.length - arr2.length;
-}
-function arrayEqual(arr1, arr2) {
-    if (arr1.length !== arr2.length)
-        return false;
-    for (let i = 0; i < arr1.length; i++) {
-        if (arr1[i] !== arr2[i])
-            return false;
-    }
-    return true;
-}
-function arrayRotate(array, start, end, shift) {
-    const length = end - start;
-    if (length > 1 && shift % length) {
-        shift = ((shift % length) + length) % length;
-        arrayReverse(array, start, end - 1);
-        arrayReverse(array, start, start + shift - 1);
-        arrayReverse(array, start + shift, end - 1);
-    }
-}
-function arrayReverse(array, start, end) {
-    while (start < end) {
-        [array[start], array[end]] = [array[end], array[start]];
-        start++;
-        end--;
-    }
-}
-function arrayMake(n, constructor) {
-    return Array.from({ length: n }, () => new constructor);
+const array = __importStar(require("./array"));
+function remove(iterable, item) {
+    return array.remove(Array.from(iterable), item);
 }
 function forEach(iterable, func) {
     if (iterable) {
@@ -96,40 +76,3 @@ function filter(iterable, func) {
             array.push(v);
     return array;
 }
-async function asyncMap(iterable, func) {
-    return Promise.all(map(iterable, func));
-}
-async function asyncMapSerial(iterable, func) {
-    const results = [];
-    let i = 0;
-    for (const v of iterable || [])
-        results.push(await func(v, i++));
-    return results;
-}
-async function asyncReduce(iterable, func, initialValue) {
-    let i = 0;
-    let acc = initialValue;
-    for (const v of iterable)
-        acc = await func(acc, v, i++, iterable);
-    return acc;
-    /*
-        return reduce<T, Promise<U>>(
-            iterable,
-            async (promise, v, i, iterable) => func(await promise, v, i, iterable),
-            Promise.resolve(initialValue)
-        );
-        */
-}
-async function asyncFilter(iterable, func) {
-    const filters = await Promise.all(map(iterable, func));
-    return filter(iterable, (_, i) => filters[i]);
-}
-async function parallel(...fns) {
-    return asyncMap(fns, f => f());
-}
-async function serial(...fns) {
-    const results = [];
-    for (const f of fns)
-        results.push(await f());
-    return results;
-}

package/dist/object.d.ts

@@ -14,7 +14,7 @@ export declare class Lazy<T> {
     then<U>(this: T extends Promise<infer R> ? Lazy<T> : never, onFulfilled: (value: T extends Promise<infer R> ? R : never) => U): Promise<U>;
 }
 export declare class CallCombiner0 {
-    private timeout;
+    private timeout?;
     combine(delay: number, func: () => void): void;
     pending(): boolean;
 }
@@ -26,5 +26,8 @@ export declare class CallCombiner extends CallCombiner0 {
 }
 export declare function makeCache<T>(load: (key: string) => T): {
     get: (fullpath: string) => T;
-    remove: (fullpath: string) => void;
+    remove: (fullpath: string) => boolean;
+    clear: () => void;
 };
+export declare function union<T>(a: Set<T>, b: Set<T>): Set<T>;
+export declare function difference<T>(a: Set<T>, b: Set<T>): [Set<T>, Set<T>];

package/dist/object.js

@@ -10,6 +10,8 @@ exports.compare = compare;
 exports.reverse_compare = reverse_compare;
 exports.reverse = reverse;
 exports.makeCache = makeCache;
+exports.union = union;
+exports.difference = difference;
 function mapObject(obj, func) {
     return Object.fromEntries(Object.entries(obj).map(x => func(x)));
 }
@@ -64,12 +66,12 @@ class Lazy {
 }
 exports.Lazy = Lazy;
 class CallCombiner0 {
-    timeout = null;
+    timeout;
     combine(delay, func) {
         if (this.timeout)
             clearTimeout(this.timeout);
         this.timeout = setTimeout(() => {
-            this.timeout = null;
+            this.timeout = undefined;
             func();
         }, delay);
     }
@@ -99,8 +101,19 @@ function makeCache(load) {
                 cache[fullpath] = load(fullpath);
             return cache[fullpath];
         },
-        remove: (fullpath) => {
-            delete cache[fullpath];
-        },
+        remove: (fullpath) => delete cache[fullpath],
+        clear: () => Object.keys(cache).forEach(k => delete cache[k]),
     };
 }
+function union(a, b) {
+    return new Set([...a, ...b]);
+}
+function difference(a, b) {
+    const remaining = new Set(a);
+    const removed = new Set();
+    for (const item of b) {
+        if (remaining.delete(item))
+            removed.add(item);
+    }
+    return [remaining, removed];
+}

package/dist/regex.d.ts

@@ -0,0 +1,103 @@
+import { SparseBits } from "./bits";
+export declare class characterClass extends SparseBits {
+    type: 'class';
+    test(char: string): boolean;
+    mutable(): MutablecharacterClass;
+    isNegated(): boolean;
+    toString(): string;
+}
+declare class MutablecharacterClass extends characterClass {
+    setChar(char: string): void;
+    setString(c: string): this;
+    clearString(c: string): this;
+}
+export declare function range(from: string, to: string): MutablecharacterClass;
+export declare function chars(chars: string): MutablecharacterClass;
+export declare function union(...classes: characterClass[]): MutablecharacterClass;
+export declare const any: characterClass;
+export declare const digit: characterClass;
+export declare const lower: characterClass;
+export declare const upper: characterClass;
+export declare const alpha: characterClass;
+export declare const alnum: characterClass;
+export declare const word: characterClass;
+export declare const whitespace: characterClass;
+export declare const hex: characterClass;
+export declare const octal: characterClass;
+export declare function text(c: string): string;
+export declare function concatenation(parts: part[]): part[] | part;
+interface alternation {
+    type: 'alt';
+    parts: part[];
+}
+export declare function alternation(parts: part[]): alternation | part;
+type noncaptureOptions = 'ahead' | 'behind' | 'neg_ahead' | 'neg_behind' | 'atomic' | {
+    i?: boolean;
+    m?: boolean;
+    s?: boolean;
+};
+interface noncapture {
+    type: 'noncapture';
+    part: part;
+    options?: noncaptureOptions;
+}
+export declare function noncapture(part: part, options?: noncaptureOptions): noncapture;
+export declare function lookAhead(part: part): noncapture;
+export declare function negLookAhead(part: part): noncapture;
+export declare function lookBehind(part: part): noncapture;
+export declare function negLookBehind(part: part): noncapture;
+interface capture {
+    type: 'capture';
+    name?: string;
+    part: part;
+}
+export declare function capture(part: part, name?: string): capture;
+type quantifiedMod = 'greedy' | 'lazy' | 'possessive';
+interface quantified {
+    type: 'quantified';
+    part: part;
+    min: number;
+    max: number;
+    mod: quantifiedMod;
+}
+export declare function repeatFrom(part: part, min: number, max?: number, mod?: quantifiedMod): quantified;
+export declare function repeat(part: part, n: number, mod?: quantifiedMod): quantified;
+export declare function zeroOrMore(part: part, mod?: quantifiedMod): quantified;
+export declare function oneOrMore(part: part, mod?: quantifiedMod): quantified;
+export declare function optional(part: part, mod?: quantifiedMod): quantified;
+interface boundary {
+    type: 'wordbound' | 'nowordbound' | 'inputboundstart' | 'inputboundend';
+}
+export declare function boundary(type: boundary['type']): boundary;
+export declare const wordBoundary: boundary;
+export declare const nonWordBoundary: boundary;
+export declare const startAnchor: boundary;
+export declare const endAnchor: boundary;
+interface reference {
+    type: 'reference';
+    value: number | string;
+}
+export declare function reference(value: number | string): reference;
+export declare function anchored(part: part): part;
+interface unicode {
+    type: 'unicode' | 'notunicode';
+    property: string;
+}
+type _part = alternation | noncapture | capture | characterClass | unicode | quantified | boundary | reference;
+type part = string | part[] | _part;
+export declare function parse(re: string, unicode?: boolean, extended?: boolean): part;
+export declare function toRegExpString(part: part): string;
+export declare function toRegExp(part: part, flags?: string): RegExp;
+export declare function optimize(part: part): part;
+interface DFAState {
+    nfaStates: Set<number>;
+    transitions: Map<string, DFAState>;
+    isAccepting: boolean;
+}
+export declare function runDFA(dfa: DFAState, str: string): boolean;
+export declare function regexToDFA(part: part): DFAState;
+export declare function parseGlob(glob: string): string;
+export declare function anchoredRe(re: string): RegExp;
+export declare function globToRe(glob: string): RegExp;
+export declare function globToReMulti(globs: string[]): RegExp;
+export {};