https://beautysociety.com/wp-content/plugins/idstc-acuta/scripts/loStorage.js?ver=3.1.20251117

1// Copyright (c) 2012 Florian H., https://github.com/js-coder https://github.com/js-coder/lostorage.js
2!function (window, undefined) {
3
4    var utils = {
5
6        isArray: Array.isArray || function (value) {
7            return Object.prototype.toString.call(value) === '[object Array]';
8        },
9
10        isPlainObj: function (value) {
11            return value === Object(value);
12        },
13
14        toArray: function (value) {
15            return Array.prototype.slice.call(value);
16        },
17
18        // Convert arguments to an Array (`utils.toArray`) and prepend `element`.
19        prepareArgs: function (args, element) {
20            args = utils.toArray(args);
21            args.unshift(element);
22            return args;
23        },
24
25        getObjKeyByValue: function (obj, value) {
26            for (var key in obj) {
27                if (obj.hasOwnProperty(key)) {
28                    if (obj[key] === value) return key;
29                }
30            }
31        },
32
33        // Prepares the return value to enable chaining.
34        prepareReturn: function (type) {
35            return window[utils.getObjKeyByValue(types, type)];
36        },
37
38        retrieve: function (value, fallback) { // Returns fallback if the value is undefined, otherwise value.
39            return value == undefined ? fallback : value;
40        },
41
42        serialize: function (data) {
43            return JSON.stringify(data);
44        },
45
46        unserialize: function (data) {
47            if (data == undefined) return undefined;
48            return JSON.parse(data);
49        }
50
51    };
52
53    var _storage = function () {
54        return _storage.get.apply(this, arguments);
55    };
56
57    var host = {
58        storage: function () {
59            return storage.get.apply(storage, arguments);
60        },
61        session: function () {
62            return session.get.apply(session, arguments);
63        }
64    };
65
66    _storage.set = function (type, key, value) {
67
68        if (utils.isPlainObj(key)) {
69
70            for (var k in key) {
71                if (key.hasOwnProperty(k)) type.setItem(k, utils.serialize(key[k]));
72            }
73
74        } else type.setItem(key, utils.serialize(value));
75
76        return utils.prepareReturn(type); // to enable chaining
77
78    };
79
80    _storage.invert = function (type, key) {
81        return this.set(type, key, !(this.get(type, key)));
82    };
83
84    _storage.add = function (type, key, value) {
85        return this.set(type, key, this.get(type, key) + parseInt(value, 10));
86    };
87
88    _storage.increase = function (type, key, value) {
89        return this.add(type, key, utils.retrieve(value, 1));
90    };
91
92    _storage.decrease = function (type, key, value) {
93        return this.add(type, key, -utils.retrieve(value, 1));
94    };
95
96    _storage.concat = function (type, key, string) { // append?
97        return this.set(type, key, this.get(type, key) + string);
98    };
99
100    _storage.push = function (type, key, value) {
101
102        var args = utils.toArray(arguments),
103             arr = this.get(type, key, []);
104
105        args.splice(0, 2);
106        arr.push.apply(arr, args);
107
108        return this.set(type, key, arr);
109
110    }
111
112    _storage.extend = function (type, key, k, v) { // variables?
113
114        var value = this.get(type, key, {});
115
116        if (utils.isPlainObj(k)) {
117
118            for (var _k in k) {
119                if (k.hasOwnProperty(_k)) value[_k] = k[_k];
120            }
121
122        } else value[k] = v;
123
124        return this.set(type, key, value);
125
126    };
127
128    _storage.remove = function (type, keys) {
129
130        keys = utils.isArray(keys) ? keys : utils.toArray(arguments);
131
132        for (var i = 0, l = keys.length; i < l; i++) {
133            delete type[keys[i]];
134        }
135
136        return utils.prepareReturn(type);
137
138    };
139
140    _storage.empty = function (type) {
141
142        type.clear();
143
144        return utils.prepareReturn(type);
145
146    };
147
148    _storage.get = function (type, keys, fallback) {
149
150        fallback = fallback || undefined;
151
152        if (utils.isArray(keys)) {
153            var result = {};
154

155            for (var i = 0, l = keys.length; i < l; i++) {
156                var key = keys[i];
157                result[key] = this.get(type, key, fallback);
158            }
159
160            return result;
161        } else return utils.retrieve(utils.unserialize(type.getItem(keys)), fallback);
162
163    };
164
165    _storage.all = function (type) {
166
167        var obj = {};
168
169        for (var i = 0, l = type.length; i < l; i++) {
170            var key = type.key(i);
171            obj[key] = utils.unserialize(type.getItem(key));
172        }
173
174        return obj;
175    };
176
177    var methods = 'set invert add increase decrease concat push extend remove empty get all'.split(' '); // Methods of _storage that need to be copied to storage and session.
178
179    var types = {
180        storage: localStorage,
181        session: sessionStorage
182    };
183
184    for (var i = 0, l = methods.length; i < l; i++) {
185
186        var method = methods[i];
187
188        for (var name in types) {
189
190            if (!(types.hasOwnProperty(name))) continue;
191
192            var storeType = types[name];
193
194            host[name][method] = function (method, storeType) {
195                return function () {
196                    var args = utils.prepareArgs(arguments, storeType);
197                    return _storage[method].apply(_storage, args);
198                };
199            }(method, storeType);
200
201        }
202
203    }
204
205    // loStorage object for AMD & CommonJS.
206    var loStorage = {
207        storage: host.storage,
208        session: host.session
209    };
210
211    // AMD, CommonJS or global.
212    if (typeof define === 'function' && define.amd) {
213        define(function () {
214            return loStorage;
215        });
216    } else if (typeof exports !== 'undefined') {
217        module.exports = loStorage;
218    } else {
219        window.storage = host.storage;
220        window.session = host.session;
221    }
222
223}(window);