https://ypeng12-noname.hf.space/node_modules/.pnpm/[email protected]/node_modules/jszip/lib/utils.js

1import "../../../../../../_virtual/_commonjsHelpers.js";
2import { __exports as utils } from "../../../../../../_virtual/utils.js";
3import { __require as requireSupport } from "./support.js";
4import { __require as requireCompressions } from "./compressions.js";
5import { __require as requireNodeBuffer } from "./nodeBuffer.js";
6var hasRequiredUtils;
7function requireUtils() {
8  if (hasRequiredUtils) return utils;
9  hasRequiredUtils = 1;
10  (function(exports$1) {
11    "use strict";
12    var support = requireSupport();
13    var compressions = requireCompressions();
14    var nodeBuffer = requireNodeBuffer();
15    exports$1.string2binary = function(str) {
16      var result = "";
17      for (var i = 0; i < str.length; i++) {
18        result += String.fromCharCode(str.charCodeAt(i) & 255);
19      }
20      return result;
21    };
22    exports$1.arrayBuffer2Blob = function(buffer, mimeType) {
23      exports$1.checkSupport("blob");
24      mimeType = mimeType || "application/zip";
25      try {
26        return new Blob([buffer], {
27          type: mimeType
28        });
29      } catch (e) {
30        try {
31          var Builder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
32          var builder = new Builder();
33          builder.append(buffer);
34          return builder.getBlob(mimeType);
35        } catch (e2) {
36          throw new Error("Bug : can't construct the Blob.");
37        }
38      }
39    };
40    function identity(input) {
41      return input;
42    }
43    function stringToArrayLike(str, array) {
44      for (var i = 0; i < str.length; ++i) {
45        array[i] = str.charCodeAt(i) & 255;
46      }
47      return array;
48    }
49    function arrayLikeToString(array) {
50      var chunk = 65536;
51      var result = [], len = array.length, type = exports$1.getTypeOf(array), k = 0, canUseApply = true;
52      try {
53        switch (type) {
54          case "uint8array":
55            String.fromCharCode.apply(null, new Uint8Array(0));
56            break;
57          case "nodebuffer":
58            String.fromCharCode.apply(null, nodeBuffer(0));
59            break;
60        }
61      } catch (e) {
62        canUseApply = false;
63      }
64      if (!canUseApply) {
65        var resultStr = "";
66        for (var i = 0; i < array.length; i++) {
67          resultStr += String.fromCharCode(array[i]);
68        }
69        return resultStr;
70      }
71      while (k < len && chunk > 1) {
72        try {
73          if (type === "array" || type === "nodebuffer") {
74            result.push(String.fromCharCode.apply(null, array.slice(k, Math.min(k + chunk, len))));
75          } else {
76            result.push(String.fromCharCode.apply(null, array.subarray(k, Math.min(k + chunk, len))));
77          }
78          k += chunk;
79        } catch (e) {
80          chunk = Math.floor(chunk / 2);
81        }
82      }
83      return result.join("");
84    }
85    exports$1.applyFromCharCode = arrayLikeToString;
86    function arrayLikeToArrayLike(arrayFrom, arrayTo) {
87      for (var i = 0; i < arrayFrom.length; i++) {
88        arrayTo[i] = arrayFrom[i];
89      }
90      return arrayTo;
91    }
92    var transform = {};
93    transform["string"] = {
94      "string": identity,
95      "array": function(input) {
96        return stringToArrayLike(input, new Array(input.length));
97      },
98      "arraybuffer": function(input) {
99        return transform["string"]["uint8array"](input).buffer;
100      },
101      "uint8array": function(input) {
102        return stringToArrayLike(input, new Uint8Array(input.length));
103      },
104      "nodebuffer": function(input) {
105        return stringToArrayLike(input, nodeBuffer(input.length));
106      }
107    };
108    transform["array"] = {
109      "string": arrayLikeToString,
110      "array": identity,
111      "arraybuffer": function(input) {
112        return new Uint8Array(input).buffer;
113      },
114      "uint8array": function(input) {
115        return new Uint8Array(input);
116      },
117      "nodebuffer": function(input) {
118        return nodeBuffer(input);
119      }
120    };
121    transform["arraybuffer"] = {
122      "string": function(input) {
123        return arrayLikeToString(new Uint8Array(input));
124      },
125      "array": function(input) {
126        return arrayLikeToArrayLike(new Uint8Array(input), new Array(input.byteLength));
127      },
128      "arraybuffer": identity,
129      "uint8array": function(input) {
130        return new Uint8Array(input);
131      },
132      "nodebuffer": function(input) {
133        return nodeBuffer(new Uint8Array(input));
134      }
135    };
136    transform["uint8array"] = {
137      "string": arrayLikeToString,
138      "array": function(input) {
139        return arrayLikeToArrayLike(input, new Array(input.length));
140      },
141      "arraybuffer": function(input) {
142        return input.buffer;
143      },
144      "uint8array": identity,
145      "nodebuffer": function(input) {
146        return nodeBuffer(input);
147      }
148    };
149    transform["nodebuffer"] = {
150      "string": arrayLikeToString,
151      "array": function(input) {
152        return arrayLikeToArrayLike(input, new Array(input.length));
153      },
154      "arraybuffer": function(input) {
155        return transform["nodebuffer"]["uint8array"](input).buffer;
156      },
157      "uint8array": function(input) {
158        return arrayLikeToArrayLike(input, new Uint8Array(input.length));
159      },
160      "nodebuffer": identity
161    };
162    exports$1.transformTo = function(outputType, input) {
163      if (!input) {
164        input = "";
165      }
166      if (!outputType) {
167        return input;
168      }
169      exports$1.checkSupport(outputType);
170      var inputType = exports$1.getTypeOf(input);
171      var result = transform[inputType][outputType](input);
172      return result;
173    };
174    exports$1.getTypeOf = function(input) {
175      if (typeof input === "string") {
176        return "string";
177      }
178      if (Object.prototype.toString.call(input) === "[object Array]") {
179        return "array";
180      }
181      if (support.nodebuffer && nodeBuffer.test(input)) {
182        return "nodebuffer";
183      }
184      if (support.uint8array && input instanceof Uint8Array) {
185        return "uint8array";
186      }
187      if (support.arraybuffer && input instanceof ArrayBuffer) {
188        return "arraybuffer";
189      }
190    };
191    exports$1.checkSupport = function(type) {
192      var supported = support[type.toLowerCase()];
193      if (!supported) {
194        throw new Error(type + " is not supported by this browser");
195      }
196    };
197    exports$1.MAX_VALUE_16BITS = 65535;
198    exports$1.MAX_VALUE_32BITS = -1;
199    exports$1.pretty = function(str) {
200      var res = "", code, i;
201      for (i = 0; i < (str || "").length; i++) {
202        code = str.charCodeAt(i);
203        res += "\\x" + (code < 16 ? "0" : "") + code.toString(16).toUpperCase();
204      }
205      return res;
206    };
207    exports$1.findCompression = function(compressionMethod) {
208      for (var method in compressions) {
209        if (!compressions.hasOwnProperty(method)) {
210          continue;
211        }
212        if (compressions[method].magic === compressionMethod) {
213          return compressions[method];
214        }
215      }
216      return null;
217    };
218    exports$1.isRegExp = function(object) {
219      return Object.prototype.toString.call(object) === "[object RegExp]";
220    };
221    exports$1.extend = function() {
222      var result = {}, i, attr;
223      for (i = 0; i < arguments.length; i++) {
224        for (attr in arguments[i]) {
225          if (arguments[i].hasOwnProperty(attr) && typeof result[attr] === "undefined") {
226            result[attr] = arguments[i][attr];
227          }
228        }
229      }
230      return result;
231    };
232  })(utils);
233  return utils;
234}
235export {
236  requireUtils as __require
237};