@wener/utils 1.1.50 → 1.1.53

package/lib/io/parseDataUri.js

@@ -1,57 +1,305 @@
-import { ArrayBuffers } from './ArrayBuffers.js';
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length)
+        len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++)
+        arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr))
+        return arr;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    }
+    catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    }
+    else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function () {
+        var self = this, args = arguments;
+        return new Promise(function (resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+        return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null)
+        return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+            _arr.push(_s.value);
+            if (i && _arr.length === i)
+                break;
+        }
+    }
+    catch (err) {
+        _d = true;
+        _e = err;
+    }
+    finally {
+        try {
+            if (!_n && _i["return"] != null)
+                _i["return"]();
+        }
+        finally {
+            if (_d)
+                throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_array(arr) {
+    return _array_with_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o)
+        return;
+    if (typeof o === "string")
+        return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor)
+        n = o.constructor.name;
+    if (n === "Map" || n === "Set")
+        return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+        return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function () {
+            if (t[0] & 1)
+                throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+        return this;
+    }), g;
+    function verb(n) {
+        return function (v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f)
+            throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _)
+            try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                    return t;
+                if (y = 0, t)
+                    op = [
+                        op[0] & 2,
+                        t.value
+                    ];
+                switch (op[0]) {
+                    case 0:
+                    case 1:
+                        t = op;
+                        break;
+                    case 4:
+                        _.label++;
+                        return {
+                            value: op[1],
+                            done: false
+                        };
+                    case 5:
+                        _.label++;
+                        y = op[1];
+                        op = [
+                            0
+                        ];
+                        continue;
+                    case 7:
+                        op = _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                            _ = 0;
+                            continue;
+                        }
+                        if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                            _.label = op[1];
+                            break;
+                        }
+                        if (op[0] === 6 && _.label < t[1]) {
+                            _.label = t[1];
+                            t = op;
+                            break;
+                        }
+                        if (t && _.label < t[2]) {
+                            _.label = t[2];
+                            _.ops.push(op);
+                            break;
+                        }
+                        if (t[2])
+                            _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) {
+                op = [
+                    6,
+                    e
+                ];
+                y = 0;
+            }
+            finally {
+                f = t = 0;
+            }
+        if (op[0] & 5)
+            throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { ArrayBuffers } from "./ArrayBuffers.js";
 export function parseDataUri(data) {
-    if (!data || !data.startsWith('data:')) {
+    if (!data || !data.startsWith("data:")) {
         return;
     }
     // https://en.wikipedia.org/wiki/Data_URI_scheme
     // data:content/type;base64,
     // data:content/type;a=b,content
-    const [header, body] = data.split(',');
-    const [type, ...paramsStr] = header.slice('data:'.length).split(';');
-    const content = body;
-    const params = Object.fromEntries(paramsStr.map((s)=>{
-        const [k, v] = s.trim().split('=');
+    var _data_split = _sliced_to_array(data.split(","), 2), header = _data_split[0], body = _data_split[1];
+    var _header_slice_split = _to_array(header.slice("data:".length).split(";")), type = _header_slice_split[0], paramsStr = _header_slice_split.slice(1);
+    var content = body;
+    var params = Object.fromEntries(paramsStr.map(function (s) {
+        var _s_trim_split = _sliced_to_array(s.trim().split("="), 2), k = _s_trim_split[0], v = _s_trim_split[1];
         return [
             k,
-            v ?? true
+            v !== null && v !== void 0 ? v : true
         ];
     }));
     // params charset=utf-8
     // params base64
     // params a=b
-    let base64 = Boolean(params['base64']);
+    var base64 = Boolean(params["base64"]);
     return {
-        type,
-        params,
-        content,
-        base64,
-        getData: async (enc)=>{
-            if (!enc) {
-                return await fetch(data).then((v)=>v.arrayBuffer());
-            }
-            //
-            let buf;
-            if (base64) {
-                if (enc === 'base64') {
-                    return content;
-                }
-                buf = await fetch(data).then((v)=>v.arrayBuffer());
-            } else {
-                let raw = decodeURIComponent(content);
-                if (enc === 'utf-8') {
-                    return raw;
-                }
-                buf = ArrayBuffers.from(raw, 'utf-8');
-            }
-            if (enc === 'utf-8') {
-                return new TextDecoder(enc).decode(buf);
-            }
-            if (enc === 'base64') {
-                return ArrayBuffers.toString(buf, 'base64');
-            }
-            return buf;
+        type: type,
+        params: params,
+        content: content,
+        base64: base64,
+        getData: function (enc) {
+            return _async_to_generator(function () {
+                var buf, raw;
+                return _ts_generator(this, function (_state) {
+                    switch (_state.label) {
+                        case 0:
+                            if (!!enc)
+                                return [
+                                    3,
+                                    2
+                                ];
+                            return [
+                                4,
+                                fetch(data).then(function (v) {
+                                    return v.arrayBuffer();
+                                })
+                            ];
+                        case 1:
+                            return [
+                                2,
+                                _state.sent()
+                            ];
+                        case 2:
+                            if (!base64)
+                                return [
+                                    3,
+                                    4
+                                ];
+                            if (enc === "base64") {
+                                return [
+                                    2,
+                                    content
+                                ];
+                            }
+                            return [
+                                4,
+                                fetch(data).then(function (v) {
+                                    return v.arrayBuffer();
+                                })
+                            ];
+                        case 3:
+                            buf = _state.sent();
+                            return [
+                                3,
+                                5
+                            ];
+                        case 4:
+                            raw = decodeURIComponent(content);
+                            if (enc === "utf-8") {
+                                return [
+                                    2,
+                                    raw
+                                ];
+                            }
+                            buf = ArrayBuffers.from(raw, "utf-8");
+                            _state.label = 5;
+                        case 5:
+                            if (enc === "utf-8") {
+                                return [
+                                    2,
+                                    new TextDecoder(enc).decode(buf)
+                                ];
+                            }
+                            if (enc === "base64") {
+                                return [
+                                    2,
+                                    ArrayBuffers.toString(buf, "base64")
+                                ];
+                            }
+                            return [
+                                2,
+                                buf
+                            ];
+                    }
+                });
+            })();
         }
     };
 }
-
-//# sourceMappingURL=parseDataUri.js.map

package/lib/io/parseDataUri.test.js

@@ -0,0 +1,286 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    }
+    catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    }
+    else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function () {
+        var self = this, args = arguments;
+        return new Promise(function (resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _object_without_properties(source, excluded) {
+    if (source == null)
+        return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for (i = 0; i < sourceSymbolKeys.length; i++) {
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0)
+                continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key))
+                continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null)
+        return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for (i = 0; i < sourceKeys.length; i++) {
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0)
+            continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function () {
+            if (t[0] & 1)
+                throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+        return this;
+    }), g;
+    function verb(n) {
+        return function (v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f)
+            throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _)
+            try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                    return t;
+                if (y = 0, t)
+                    op = [
+                        op[0] & 2,
+                        t.value
+                    ];
+                switch (op[0]) {
+                    case 0:
+                    case 1:
+                        t = op;
+                        break;
+                    case 4:
+                        _.label++;
+                        return {
+                            value: op[1],
+                            done: false
+                        };
+                    case 5:
+                        _.label++;
+                        y = op[1];
+                        op = [
+                            0
+                        ];
+                        continue;
+                    case 7:
+                        op = _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                            _ = 0;
+                            continue;
+                        }
+                        if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                            _.label = op[1];
+                            break;
+                        }
+                        if (op[0] === 6 && _.label < t[1]) {
+                            _.label = t[1];
+                            t = op;
+                            break;
+                        }
+                        if (t && _.label < t[2]) {
+                            _.label = t[2];
+                            _.ops.push(op);
+                            break;
+                        }
+                        if (t[2])
+                            _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) {
+                op = [
+                    6,
+                    e
+                ];
+                y = 0;
+            }
+            finally {
+                f = t = 0;
+            }
+        if (op[0] & 5)
+            throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { assert, test } from "vitest";
+import { ArrayBuffers } from "./ArrayBuffers.js";
+import { parseDataUri } from "./parseDataUri.js";
+test("parseDataUri", function () {
+    return _async_to_generator(function () {
+        var uri, _parseDataUri, getData, out, _, _tmp, _1, uri1, _parseDataUri1, getData1, out1, _2, _3, _4, _tmp1, _5, _tmp2, _6;
+        return _ts_generator(this, function (_state) {
+            switch (_state.label) {
+                case 0:
+                    uri = "data:text/plain;base64,SGVsbG8sIFdvcmxkIQ==";
+                    _parseDataUri = parseDataUri(uri), getData = _parseDataUri.getData, out = _object_without_properties(_parseDataUri, [
+                        "getData"
+                    ]);
+                    assert.deepEqual(out, {
+                        type: "text/plain",
+                        params: {
+                            base64: true
+                        },
+                        content: "SGVsbG8sIFdvcmxkIQ==",
+                        base64: true
+                    });
+                    _ = assert.equal;
+                    return [
+                        4,
+                        getData("utf-8")
+                    ];
+                case 1:
+                    _tmp = [
+                        _state.sent()
+                    ];
+                    return [
+                        4,
+                        fetch(uri).then(function (v) {
+                            return v.text();
+                        })
+                    ];
+                case 2:
+                    _.apply(assert, _tmp.concat([
+                        _state.sent()
+                    ]));
+                    _1 = assert.equal;
+                    return [
+                        4,
+                        getData("base64")
+                    ];
+                case 3:
+                    _1.apply(assert, [
+                        _state.sent(),
+                        "SGVsbG8sIFdvcmxkIQ=="
+                    ]);
+                    // text
+                    uri1 = "data:text/plain,Hello%2C%20World!";
+                    _parseDataUri1 = parseDataUri(uri1), getData1 = _parseDataUri1.getData, out1 = _object_without_properties(_parseDataUri1, [
+                        "getData"
+                    ]);
+                    assert.deepEqual(out1, {
+                        type: "text/plain",
+                        params: {},
+                        content: "Hello%2C%20World!",
+                        base64: false
+                    });
+                    _2 = assert.equal;
+                    return [
+                        4,
+                        getData1("utf-8")
+                    ];
+                case 4:
+                    _2.apply(assert, [
+                        _state.sent(),
+                        "Hello, World!"
+                    ]);
+                    _3 = assert.deepEqual;
+                    _4 = ArrayBuffers.asView;
+                    _tmp1 = [
+                        Uint8Array
+                    ];
+                    return [
+                        4,
+                        getData1()
+                    ];
+                case 5:
+                    _3.apply(assert, [
+                        _4.apply(ArrayBuffers, _tmp1.concat([
+                            _state.sent()
+                        ])),
+                        new TextEncoder().encode("Hello, World!")
+                    ]);
+                    _5 = assert.equal;
+                    return [
+                        4,
+                        getData1("utf-8")
+                    ];
+                case 6:
+                    _tmp2 = [
+                        _state.sent()
+                    ];
+                    return [
+                        4,
+                        fetch(uri1).then(function (v) {
+                            return v.text();
+                        })
+                    ];
+                case 7:
+                    _5.apply(assert, _tmp2.concat([
+                        _state.sent()
+                    ]));
+                    _6 = assert.equal;
+                    return [
+                        4,
+                        getData1("base64")
+                    ];
+                case 8:
+                    _6.apply(assert, [
+                        _state.sent(),
+                        "SGVsbG8sIFdvcmxkIQ=="
+                    ]);
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+});

package/lib/io/types.js

@@ -0,0 +1 @@
+export { };