@pacem/pacem-foundation 1.0.0-abel

package/dist/esm/colors.js

@@ -0,0 +1,334 @@
+//namespace Pacem {
+import { NullChecker } from "./null-checker";
+const HSL_PATTERN = /^hsl\s*\(\s*([\d\.]+)\s*,\s*([\d\.]+)%\s*,\s*([\d\.]+)%\s*\)$/;
+const HSLA_PATTERN = /^hsla\s*\(\s*([\d\.]+)\s*,\s*([\d\.]+)%\s*,\s*([\d\.]+)%\s*,\s*([\d\.]+)\)$/;
+const RGB_PATTERN = /^rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/;
+const RGBA_PATTERN = /^rgba\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*([\d\.]+)\)$/;
+const HEX_PATTERN = /^#[a-f0-9]{6}$/;
+const HEX_SHORT_PATTERN = /^#[a-f0-9]{3}$/;
+;
+;
+;
+function isRgb(clr) {
+    const base = !NullChecker.isNullOrEmpty(clr) && typeof clr === 'object' && 'r' in clr && 'g' in clr && 'b' in clr // && 'a' in clr
+        && typeof clr.r === 'number' && typeof clr.b === 'number' && typeof clr.g === 'number' // && typeof clr.a === 'number'
+    ;
+    if (!base) {
+        return false;
+    }
+    clr.a ??= 1;
+    return clr.r >= 0 && clr.r <= 1
+        && clr.g >= 0 && clr.g <= 1
+        && clr.b >= 0 && clr.b <= 1
+        && clr.a >= 0 && clr.a <= 1;
+}
+function isHsl(clr) {
+    const base = !NullChecker.isNullOrEmpty(clr) && typeof clr === 'object' && 'h' in clr && 's' in clr && 'l' in clr // && 'a' in clr
+        && typeof clr.h === 'number' && typeof clr.s === 'number' && typeof clr.l === 'number' // && typeof clr.a === 'number'
+    ;
+    if (!base) {
+        return false;
+    }
+    clr.a ??= 1;
+    return clr.h >= 0 && clr.h <= 360
+        && clr.s >= 0 && clr.s <= 1
+        && clr.l >= 0 && clr.l <= 1
+        && clr.a >= 0 && clr.a <= 1;
+}
+function luminance(rgb) {
+    const r = rgb.r, g = rgb.g, b = rgb.b;
+    const l = .5 * (Math.max(r, g, b) + Math.min(r, g, b));
+    return l.clamp(0, 1);
+}
+const cieUtils = {
+    adjustRgbChannel: (v) => {
+        // sRGB => sR'G'B'
+        return v <= .03928 ? (v / 12.92) : Math.pow((v + .055) / 1.055, 2.4);
+    },
+    adjustRgbChannelInv: (v) => {
+        // sR'G'B' => sRGB
+        return v <= .00304 ? (v * 12.92) : 1.055 * (Math.pow(v, 1 / 2.4) - .055);
+    },
+    adjustRgb: (rgb) => {
+        const rgbOut = { r: cieUtils.adjustRgbChannel(rgb.r), g: cieUtils.adjustRgbChannel(rgb.g), b: cieUtils.adjustRgbChannel(rgb.b), a: rgb.a };
+        return rgbOut;
+    },
+    adjustRgbInv: (rgb) => {
+        const rgbOut = { r: cieUtils.adjustRgbChannelInv(rgb.r), g: cieUtils.adjustRgbChannelInv(rgb.g), b: cieUtils.adjustRgbChannelInv(rgb.b), a: rgb.a };
+        return rgbOut;
+    },
+    X: (adjustedRgb) => {
+        return .4125 * adjustedRgb.r + .3576 * adjustedRgb.g + .1804 * adjustedRgb.b;
+    },
+    Y: (adjustedRgb) => {
+        // https://www.w3.org/TR/WCAG20/#relativeluminancedef
+        return .2126 * adjustedRgb.r + .7152 * adjustedRgb.g + .0722 * adjustedRgb.b;
+    },
+    Z: (adjustedRgb) => {
+        return .0193 * adjustedRgb.r + .1191 * adjustedRgb.g + .9503 * adjustedRgb.b;
+    },
+    relativeLuminance: (rgb) => {
+        const adjRgb = cieUtils.adjustRgb(rgb);
+        return cieUtils.Y(adjRgb);
+    },
+    rgbToCieXYZ: (rgb) => {
+        const adjRgb = cieUtils.adjustRgb(rgb);
+        const xyz = { x: cieUtils.X(adjRgb), y: cieUtils.Y(adjRgb), z: cieUtils.Z(adjRgb), a: rgb.a };
+        return xyz;
+    },
+    cieXYZToRgb: (xyz) => {
+        const r = 3.2410 * xyz.x - 1.5374 * xyz.y - .4986 * xyz.z, g = -.9692 * xyz.x + 1.8760 * xyz.y + .0416 * xyz.z, b = .0556 * xyz.x - .2040 * xyz.y + 1.0570 * xyz.z;
+        return cieUtils.adjustRgbInv({ r, g, b, a: xyz.a });
+    },
+    /**
+     * Returns the contrast ratio between two colors.
+     * @param rgb1 Color 1
+     * @param rgb2 Color 2
+     * @returns A numeric value between 1 and 21.
+     */
+    contrastRatio: (rgb1, rgb2) => {
+        // https://www.w3.org/TR/WCAG20/#contrast-ratiodef
+        const l1 = cieUtils.relativeLuminance(rgb1) + .05, l2 = cieUtils.relativeLuminance(rgb2) + .05;
+        return l1 > l2 ?
+            l1 / l2
+            :
+                l2 / l1;
+    }
+};
+function saturation(rgb, l) {
+    const r = rgb.r, g = rgb.g, b = rgb.b;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const s = (l === 0 || l === 1) ? 0 : (max - min) / (1 - Math.abs(2 * l - 1));
+    return s.clamp(0, 1);
+}
+/**
+ * Preucil 'hexagon' algorithm.
+ * @param rgb
+ */
+function hueHexagon(rgb) {
+    const r = rgb.r, g = rgb.g, b = rgb.b;
+    const deg = Math.atan2(Math.sqrt(3) * (g - b), 2 * r - g - b) * 180 / Math.PI;
+    return (deg + 360) % 360;
+}
+/**
+ * Preucil 'circle' algorithm.
+ * @param rgb
+ */
+function hueCircle(rgb) {
+    const r = rgb.r, g = rgb.g, b = rgb.b;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    let hue = 0;
+    if (max !== min) {
+        if (max === r) {
+            hue = (60 * ((g - b) / (max - min)) + 360) % 360;
+        }
+        else if (max === g) {
+            hue = (60 * ((b - r) / (max - min)) + 120) % 360;
+        }
+        else {
+            hue = (60 * ((r - g) / (max - min)) + 240) % 360;
+        }
+    }
+    return hue.clamp(0, 360);
+}
+function hexify(v) {
+    return v.toString(16).padStart(2, '0');
+    //return Pacem.Strings.leftPad(v.toString(16), 2, '0');
+}
+export class Colors {
+    static { this.WCAG_MINIMUM_CONTRAST = 3.0; }
+    static { this.WCAG_NORMAL_TEXT_CONTRAST = 4.5; }
+    static { this.WCAG_SAFE_CONTRAST = 7.0; }
+    static _clampRGB(rgb) {
+        const clmp = (n) => Math.min(1.0, Math.max(0, n));
+        if (rgb[3] == null) {
+            rgb[3] = 1.0;
+        }
+        return { r: clmp(rgb[0]), g: clmp(rgb[1]), b: clmp(rgb[2]), a: Math.min(1, Math.max(0, rgb[3])) };
+    }
+    static _normalize(rgb) {
+        return [rgb[0] / 255.0, rgb[1] / 255.0, rgb[2] / 255.0, rgb[3]];
+    }
+    static parse(clr) {
+        clr = (clr || '').toLowerCase();
+        /* rgb(255,255,255) */
+        if (RGB_PATTERN.test(clr)) {
+            let rgbArr = RGB_PATTERN.exec(clr);
+            return this._clampRGB(this._normalize([parseInt(rgbArr[1]), parseInt(rgbArr[2]), parseInt(rgbArr[3]), 1]));
+        }
+        /* rgba(255,255,255,.5) */
+        if (RGBA_PATTERN.test(clr)) {
+            let rgbArr = RGBA_PATTERN.exec(clr);
+            return this._clampRGB(this._normalize([parseInt(rgbArr[1]), parseInt(rgbArr[2]), parseInt(rgbArr[3]), parseFloat(rgbArr[4])]));
+        }
+        /* #ffffff */
+        if (HEX_PATTERN.test(clr)) {
+            let hex = HEX_PATTERN.exec(clr)[0];
+            return this._clampRGB(this._normalize([parseInt('0x' + hex.substr(1, 2)), parseInt('0x' + hex.substr(3, 2)), parseInt('0x' + hex.substr(5, 2)), 1]));
+        }
+        /* #fff */
+        if (HEX_SHORT_PATTERN.test(clr)) {
+            let hex = HEX_SHORT_PATTERN.exec(clr)[0];
+            let r = hex.substr(1, 1), g = hex.substr(2, 1), b = hex.substr(3, 1);
+            return this._clampRGB(this._normalize([parseInt('0x' + r + r), parseInt('0x' + g + g), parseInt('0x' + b + b), 1]));
+        }
+        /* hsl(0,60%,100%) */
+        if (HSL_PATTERN.test(clr)) {
+            let hslArr = HSL_PATTERN.exec(clr);
+            const hsl = { h: parseFloat(hslArr[1]), s: parseFloat(hslArr[2]) * .01, l: parseFloat(hslArr[3]) * .01 };
+            return this.rgb(hsl);
+        }
+        /* hsla(0,40%,50%,.5) */
+        if (HSLA_PATTERN.test(clr)) {
+            let hslaArr = HSLA_PATTERN.exec(clr);
+            const hsla = { h: parseFloat(hslaArr[1]), s: parseFloat(hslaArr[2]) * .01, l: parseFloat(hslaArr[3]) * .01, a: parseFloat(hslaArr[4]) };
+            return this.rgb(hsla);
+        }
+    }
+    static hsl(rgb) {
+        const l = luminance(rgb), s = saturation(rgb, l), h = hueCircle(rgb);
+        return { h, s, l, a: rgb.a };
+    }
+    static cieXYZ(clr) {
+        if (isHsl(clr)) {
+            clr = this.rgb(clr);
+        }
+        return cieUtils.rgbToCieXYZ(clr);
+    }
+    static rgb(clr) {
+        if (isHsl(clr)) {
+            // hsl
+            const h = clr.h, s = clr.s, l = clr.l, h6 = h / 60.0;
+            const C = (1 - Math.abs(2 * l - 1)) * s;
+            const X = C * (1 - Math.abs(h6 % 2 - 1));
+            const m = l - C / 2;
+            const compose = (r, g, b) => this._clampRGB([r + m, g + m, b + m, clr.a]);
+            if (h6 <= 1) {
+                return compose(C, X, 0);
+            }
+            else if (h6 <= 2) {
+                return compose(X, C, 0);
+            }
+            else if (h6 <= 3) {
+                return compose(0, C, X);
+            }
+            else if (h6 <= 4) {
+                return compose(0, X, C);
+            }
+            else if (h6 <= 5) {
+                return compose(X, 0, C);
+            }
+            else if (h6 <= 6) {
+                return compose(C, 0, X);
+            }
+        }
+        else {
+            // cie XYZ
+            const rgb = cieUtils.cieXYZToRgb(clr);
+            return this._clampRGB([rgb.r, rgb.g, rgb.b, rgb.a]);
+        }
+    }
+    static stringify(clr, arg1 = 1) {
+        if (isHsl(clr)) {
+            arg1 ??= 1;
+            clr.a ??= 1;
+            const precision = typeof arg1 === 'number' ? arg1 : 1;
+            return `hsla(${clr.h.roundoff(precision)},${(clr.s * 100).roundoff(precision)}%,${(clr.l * 100).roundoff(precision)}%,${clr.a.roundoff()})`;
+        }
+        else if (isRgb(clr)) {
+            arg1 ??= true;
+            clr.a ??= 1;
+            const hex = typeof arg1 === 'boolean' ? arg1 : !!arg1, r = Math.round(clr.r * 255), g = Math.round(clr.g * 255), b = Math.round(clr.b * 255), a = clr.a.roundoff();
+            if (a === 1) {
+                if (hex) {
+                    return ('#' + hexify(r) + hexify(g) + hexify(b)).toUpperCase();
+                }
+                return `rgb(${r},${g},${b})`;
+            }
+            return `rgba(${r},${g},${b},${a})`;
+        }
+        return undefined;
+    }
+    /**
+     * Contrast ratio betwen two colors (useful for accessibility assessments). Output range: 1 (no-contrast) to 21 (maximum contrast)
+     */
+    static contrastRatio(clr1, clr2) {
+        if (isHsl(clr1)) {
+            clr1 = this.rgb(clr1);
+        }
+        if (isHsl(clr2)) {
+            clr2 = this.rgb(clr2);
+        }
+        return cieUtils.contrastRatio(clr1, clr2);
+    }
+    /**
+     * Returns the relative luminance as of WCAG specs.
+     */
+    static luminance(clr) {
+        if (isHsl(clr)) {
+            clr = Colors.rgb(clr);
+        }
+        return cieUtils.relativeLuminance(clr);
+    }
+    static lighten(clr, amount = 0.1) {
+        amount ||= 0;
+        if (isHsl(clr)) {
+            const l = Math.min(1, Math.max(0, clr.l + amount));
+            return Object.assign({}, clr, { l });
+        }
+        if (isRgb(clr)) {
+            const hsl = this.lighten(this.hsl(clr), amount);
+            return this.rgb(hsl);
+        }
+        return clr;
+    }
+    static darken(clr, amount = 0.1) {
+        return this.lighten(clr, -amount);
+    }
+    static saturate(clr, amount = 0.1) {
+        amount ||= 0;
+        if (isHsl(clr)) {
+            const s = Math.min(1, Math.max(0, clr.s + amount));
+            return Object.assign({}, clr, { s });
+        }
+        if (isRgb(clr)) {
+            const hsl = this.saturate(this.hsl(clr), amount);
+            return this.rgb(hsl);
+        }
+        return clr;
+    }
+    static desaturate(clr, amount = 0.1) {
+        return this.saturate(clr, -amount);
+    }
+    static interpolate(clr1, clr2, weight1, weight2) {
+        weight1 ??= .5;
+        weight2 ??= weight1;
+        const weight = (weight1 + weight2).roundoff();
+        const ratio1 = (weight1 / weight).roundoff(), ratio2 = (weight2 / weight).roundoff();
+        const rgb = isRgb(clr1), hsl = isHsl(clr1);
+        const toCieXYZ = (c) => {
+            if (isRgb(c) || isHsl(c)) {
+                return Colors.cieXYZ(c);
+            }
+            return c;
+        };
+        clr1 = toCieXYZ(clr1);
+        clr2 = toCieXYZ(clr2);
+        const clr = {
+            x: (clr1.x * ratio1 + clr2.x * ratio2).roundoff(),
+            y: (clr1.y * ratio1 + clr2.y * ratio2).roundoff(),
+            z: (clr1.z * ratio1 + clr2.z * ratio2).roundoff(),
+            a: (clr1.a * ratio1 + clr2.a * ratio2).roundoff(),
+        };
+        if (rgb) {
+            return Colors.rgb(clr);
+        }
+        if (hsl) {
+            return Colors.hsl(Colors.rgb(clr));
+        }
+        return clr;
+    }
+}
+//}

package/dist/esm/dates.js

@@ -0,0 +1,58 @@
+//namespace Pacem {
+const JSON_DATE_PATTERN = /^\/Date\([\d]+\)\/$/i;
+export class Dates {
+    static parse(input) {
+        let d;
+        if (typeof input === 'string') {
+            if (JSON_DATE_PATTERN.test(input))
+                d = parseInt(input.substring(6));
+            else
+                d = Date.parse(input);
+            return new Date(d);
+        }
+        else if (typeof input === 'number') {
+            return new Date(input);
+        }
+        else
+            return input;
+    }
+    static isLeapYear(year) {
+        return (((year % 4 === 0) && (year % 100 !== 0)) || (year % 400 === 0));
+    }
+    static daysInMonth(year, month) {
+        return [31, (Dates.isLeapYear(year) ? 29 : 28), 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month];
+    }
+    /**
+     * Gets whether a date is an `Invalid Date` or not.
+     * @param date
+     */
+    static isDate(date) {
+        return date instanceof Date && !isNaN(date.valueOf());
+    }
+    /**
+     * Returns the date-only equaivalent of a provided datetime.
+     * @param datetime
+     */
+    static dateOnly(datetime) {
+        return new Date(datetime.getFullYear(), datetime.getMonth(), datetime.getDate());
+    }
+    static addMonths(input, value) {
+        let n = input.getDate(), i = new Date(input), month = i.getMonth() + value, years = 0;
+        while (month < 0) {
+            month += 12;
+            years--;
+        }
+        i.setDate(1);
+        i.setMonth(month % 12);
+        i.setFullYear(i.getFullYear() + years + Math.floor(month / 12));
+        i.setDate(Math.min(n, Dates.daysInMonth(i.getFullYear(), i.getMonth())));
+        return i;
+    }
+    static addDays(input, value) {
+        return new Date(input.valueOf() + value * 86400000);
+    }
+    static daysBetween(start, end) {
+        return (end.valueOf() - start.valueOf()) / 86400000;
+    }
+}
+//}

package/dist/esm/deepmerger.js

@@ -0,0 +1,35 @@
+function isPlainObject(value) {
+    return (value != null &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        (value.constructor === Object || value.constructor === undefined));
+}
+function deepMerge(target, source) {
+    const output = target;
+    for (const key of Object.keys(source)) {
+        const sourceValue = source[key];
+        const targetValue = output[key];
+        if (isPlainObject(sourceValue)) {
+            // never adopt the source's object by reference: bundlers emit frozen
+            // namespace objects (`export * as X`), so a later merge into the same
+            // slot would throw ("object is not extensible"). Always merge into a
+            // fresh, extensible object instead.
+            output[key] = deepMerge(isPlainObject(targetValue) ? targetValue : {}, sourceValue);
+        }
+        else if (Array.isArray(sourceValue)) {
+            output[key] = sourceValue.slice();
+        }
+        else {
+            output[key] = sourceValue;
+        }
+    }
+    return output;
+}
+export class DeepMerger {
+    constructor() {
+    }
+    static merge(source, target) {
+        target ??= (globalThis['Pacem'] ??= {});
+        return deepMerge(target, source);
+    }
+}

package/dist/esm/geom.js

@@ -0,0 +1,112 @@
+import { NullChecker } from "./null-checker";
+// 1.7763568394002505e-15 -20.4551920341394 40 40
+const FLOAT_PATTERN = /[-+]?([\d]+(\.[\d]+(e-[\d]+)?)?|[\d]*(\.[\d]+(e-[\d]+)?))/g;
+export function parseAsNumericalArray(input) {
+    const arr = [];
+    let reg = input.match(FLOAT_PATTERN);
+    if (reg && reg.length > 0) {
+        reg.forEach(i => arr.push(parseFloat(i)));
+    }
+    return arr;
+}
+export class Angle {
+    static isAngle(obj) {
+        return typeof obj === 'object'
+            && 'vertex' in obj && Point.isPoint(obj['vertex'])
+            && 'start' in obj && Point.isPoint(obj['start'])
+            && 'end' in obj && Point.isPoint(obj['end']);
+    }
+    /**
+     * Returns the angle span in radians.
+     * Clockwise angles are positive, counterclockwise angles are negative.
+     */
+    static value(angle) {
+        if (NullChecker.isNullOrEmpty(angle) || !Angle.isAngle(angle)) {
+            return Number.NaN;
+        }
+        const { vertex, start, end } = angle;
+        return Angle.angleBetween(vertex, start, end);
+    }
+    /**
+     * Returns the angle (in radians) given the angle vertex and two points belonging to the rays that combine to build the angle sides.
+     * Clockwise angles are positive, counterclockwise angles are negative.
+     * @param vertex Angle vertex
+     * @param start Point belonging to the start side
+     * @param end Point belonging to the end side
+     * @returns Angle span in radians [-pi, pi]
+     */
+    static angleBetween(vertex, start, end) {
+        const v1 = { x: start.x - vertex.x, y: start.y - vertex.y }, v2 = { x: end.x - vertex.x, y: end.y - vertex.y };
+        const dot = v1.x * v2.x + v1.y * v2.y;
+        const cross = v1.x * v2.y - v1.y * v2.x;
+        // clockwise positive, ccw negative
+        return -Math.atan2(cross, dot);
+    }
+}
+;
+export class Size {
+    static parse(sz) {
+        let arr = parseAsNumericalArray(sz);
+        if (arr && arr.length === 2) {
+            return { width: arr[0], height: arr[1] };
+        }
+        throw new Error(`Cannot parse "${sz}" as a valid Size.`);
+    }
+    static isSize(obj) {
+        return typeof obj === 'object'
+            && 'width' in obj && typeof obj['width'] === 'number'
+            && 'height' in obj && typeof obj['height'] === 'number';
+    }
+}
+export class Point {
+    static parse(pt) {
+        let arr = parseAsNumericalArray(pt);
+        if (arr && arr.length === 2) {
+            return { x: arr[0], y: arr[1] };
+        }
+        throw new Error(`Cannot parse "${pt}" as a valid Point.`);
+    }
+    static isPoint(obj) {
+        return typeof obj === 'object'
+            && 'x' in obj && typeof obj['x'] === 'number'
+            && 'y' in obj && typeof obj['y'] === 'number';
+    }
+    /**
+     * Computes the distance between two points.
+     * @param p1 Point 1
+     * @param p2 Point 2
+     */
+    static distance(p1, p2) {
+        return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
+    }
+    /**
+     * Subtracts a point p from another and returns the resulting vector.
+     * @param p Point to subtract
+     * @param from Point to be subtracted from
+     */
+    static subtract(p, from) {
+        return { x: from.x - p.x, y: from.y - p.y };
+    }
+    /**
+     * Adds a set of points together and returns the resulting vector.
+     * @param points Points to add
+     */
+    static add(...points) {
+        var point = { x: 0, y: 0 };
+        for (var p of points) {
+            point.x += p.x;
+            point.y += p.y;
+        }
+        return point;
+    }
+    /**
+     * Memberwise multiplication.
+     * @param p Original Point object
+     * @param f Factor
+     * @returns New Point object.
+     */
+    static multiply(p, f) {
+        return { x: p.x * f, y: p.y * f };
+    }
+}
+//}

package/dist/esm/history-svc.js

@@ -0,0 +1,60 @@
+// namespace Pacem {
+/** Grants undo/redo functionalities for given state. */
+export class HistoryService {
+    constructor(state, maxlength) {
+        this.#current = state;
+        this.#maxlength = maxlength;
+    }
+    // it's a queue
+    #backwards = [];
+    // it's a stack
+    #forwards = [];
+    // max number of items (queue + stack)
+    #maxlength;
+    #current;
+    /**
+     * Gets the current state.
+     */
+    get current() {
+        return this.#current;
+    }
+    get canUndo() {
+        return this.#backwards.length > 0;
+    }
+    get canRedo() {
+        return this.#forwards.length > 0;
+    }
+    /** Sets the maximum number of stored states, queue + stack.
+     */
+    set maxlength(v) {
+        this.#maxlength = v;
+    }
+    undo() {
+        if (this.canUndo) {
+            const back = this.#backwards, fore = this.#forwards, current = this.#current;
+            fore.unshift(current);
+            this.#current = back.pop();
+        }
+    }
+    redo() {
+        if (this.canRedo) {
+            const back = this.#backwards, fore = this.#forwards, current = this.#current;
+            back.push(current);
+            this.#current = fore.shift();
+        }
+    }
+    push(state) {
+        this.#forwards.splice(0);
+        this.#backwards.push(this.#current);
+        this.#current = state;
+        const max = this.#maxlength, queue = this.#backwards;
+        if (max > 0 && queue.length > max) {
+            queue.splice(0, queue.length - max);
+        }
+    }
+    reset() {
+        this.#forwards.splice(0);
+        this.#backwards.splice(0);
+    }
+}
+// }

package/dist/esm/imaging.js

@@ -0,0 +1,50 @@
+// namespace Pacem {
+import { Rect } from "./rect";
+const DefaultImagingResizeOptions = {
+    mode: 'stretch',
+    align: 'center',
+    valign: 'middle',
+    quality: 1,
+    type: 'image/jpeg'
+};
+export class Imaging {
+    static async loadImage(url) {
+        const response = await fetch(url);
+        if (!response.ok) {
+            return null;
+        }
+        const blob = await response.blob();
+        return blob;
+    }
+    static async resizeImage(img, width, height, options) {
+        if (width <= 0 || height <= 0 || isNaN(width) || isNaN(height)) {
+            throw new Error('Invalid target size');
+        }
+        if (typeof img === 'string') {
+            img = await Imaging.loadImage(img);
+        }
+        const el = await self.createImageBitmap(img);
+        const origWidth = el.width, origHeight = el.height;
+        const cnv = new OffscreenCanvas(origWidth, origHeight);
+        const ctx = cnv.getContext('2d');
+        ctx.imageSmoothingEnabled =
+            ctx['mozImageSmoothingEnabled'] =
+                ctx['oImageSmoothingEnabled'] =
+                    ctx['webkitImageSmoothingEnabled'] =
+                        true;
+        const { quality, type, mode, align, valign, background } = Object.assign({}, DefaultImagingResizeOptions, options ?? {});
+        const from = { width: origWidth, height: origHeight, x: 0, y: 0 }, to = { x: 0, y: 0, width, height };
+        const transformMatrix = Rect.findTransform(from, to, mode, align, valign);
+        cnv.width = width;
+        cnv.height = height;
+        if (background) {
+            ctx.fillStyle = background;
+            ctx.fillRect(0, 0, cnv.width, cnv.height);
+        }
+        ctx.setTransform(transformMatrix);
+        ctx.drawImage(el, 0, 0);
+        const retval = await cnv.convertToBlob({ quality, type });
+        return retval;
+    }
+}
+// }

package/dist/esm/index-compile-markdown.js

@@ -0,0 +1 @@
+export * from './compile/markdown/parser';

package/dist/esm/index-compile.js

@@ -0,0 +1,2 @@
+export * as Markdown from './index-compile-markdown';
+export * from './compile/parser';

package/dist/esm/index-iife.js

@@ -0,0 +1,2 @@
+import * as Output from './index';
+Output.DeepMerger.merge(Output);

package/dist/esm/index.js

@@ -0,0 +1,20 @@
+// import './number-extensions';
+// import './array-extensions';
+export * from './number-extensions';
+export * from './array-extensions';
+export * from './deepmerger';
+export * from './arrays';
+export * from './blobs';
+export * from './browser';
+export * from './colors';
+export * from './dates';
+export * from './geom';
+export * from './rect';
+export * from "./null-checker";
+export * from './history-svc';
+export * from './imaging';
+export * from './keygenerator';
+export * from './matrix2d';
+export * from './numbers';
+export * from './strings';
+export * as Compile from './index-compile';