snyk 1.814.0 → 1.815.0

package/dist/cli/{424.index.js → 55.index.js}

@@ -1,81 +1,46 @@
-exports.id = 424;
-exports.ids = [424];
+exports.id = 55;
+exports.ids = [55];
 exports.modules = {
 
-/***/ 87448:
-/***/ ((module) => {
-
-count = (arr) => arr.length;
-sum = (arr) => arr.reduce((a, b) => a + b, 0);
-product = (arr) => arr.reduce((total, num) => total * num, 1);
-max = (arr) => Math.max(arr);
-min = (arr) => Math.min(arr);
-sort = (arr) => [...arr].sort();
-all = (arr) => (arr.length === 0 ? true : arr.every((v) => v === true));
-any = (arr) => (arr.length === 0 ? false : arr.includes(true));
-
-module.exports = { count, sum, product, min, sort, all, any };
-
-
-/***/ }),
-
-/***/ 1778:
-/***/ ((module) => {
-
-arrayConcat = (arr1, arr2) => arr1.concat(arr2);
-arraySlice = (arr, startIndex, stopIndex) => arr.slice(startIndex, stopIndex);
-
-module.exports = { "array.concat": arrayConcat, "array.slice": arraySlice };
-
-
-/***/ }),
-
-/***/ 20028:
-/***/ ((module) => {
-
-to_number = (x) => Number(x);
-
-module.exports = { to_number };
-
-
-/***/ }),
-
 /***/ 42869:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const numbers = __webpack_require__(86132);
-const aggregates = __webpack_require__(87448);
-const arrays = __webpack_require__(1778);
+const json = __webpack_require__(29387);
 const strings = __webpack_require__(13043);
 const regex = __webpack_require__(13732);
-const types = __webpack_require__(95320);
-const conversions = __webpack_require__(20028);
+const yaml = __webpack_require__(76050);
 
 module.exports = {
-  ...numbers,
-  ...aggregates,
-  ...arrays,
+  ...json,
   ...strings,
   ...regex,
-  ...types,
-  ...conversions,
+  ...yaml,
 };
 
 
 /***/ }),
 
-/***/ 86132:
+/***/ 29387:
 /***/ ((module) => {
 
-plus = (a, b) => a + b;
-minus = (a, b) => a - b;
-mul = (a, b) => a * b;
-div = (a, b) => a / b;
-rem = (a, b) => a % b;
-round = (x) => Math.round(x);
-abs = (x) => Math.abs(x);
+function isValidJSON(str) {
+  if (typeof str !== "string") {
+    return;
+  }
+  try {
+    JSON.parse(str);
+    return true;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      return false;
+    }
+    throw err;
+  }
+}
 
-module.exports = { plus, minus, mul, div, rem, round, abs };
+module.exports = {
+  "json.is_valid": isValidJSON,
+};
 
 
 /***/ }),
@@ -83,10 +48,9 @@ module.exports = { plus, minus, mul, div, rem, round, abs };
 /***/ 13732:
 /***/ ((module) => {
 
-re_match = (pattern, value) => RegExp(pattern).test(value);
-regexSplit = (pattern, s) => s.split(RegExp(pattern));
+const regexSplit = (pattern, s) => s.split(RegExp(pattern));
 
-module.exports = { "regex.split": regexSplit, re_match };
+module.exports = { "regex.split": regexSplit };
 
 
 /***/ }),
@@ -94,57 +58,55 @@ module.exports = { "regex.split": regexSplit, re_match };
 /***/ 13043:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var vsprintf = __webpack_require__(8975).vsprintf
+const vsprintf = __webpack_require__(8975).vsprintf;
 
-contains = (s, search) => s.includes(search);
-endswith = (s, search) => s.endsWith(search);
-indexof = (s, search) => s.indexOf(search);
-lower = (s) => s.toLowerCase();
-replace = (s, searchValue, newValue) => s.replace(searchValue, newValue);
-split = (s, delimiter) => s.split(delimiter);
-sprintf = (s, values) => vsprintf(s, values);
-startswith = (s, search) => s.startsWith(search);
-substring = (s, start, length) => s.substr(start, length);
-concat = (delimiter, arr) => arr.join(delimiter);
+const sprintf = (s, values) => vsprintf(s, values);
 
-module.exports = {
-  contains,
-  endswith,
-  indexof,
-  lower,
-  replace,
-  split,
-  sprintf,
-  startswith,
-  substring,
-  concat,
-};
+module.exports = { sprintf };
 
 
 /***/ }),
 
-/***/ 95320:
-/***/ ((module) => {
+/***/ 76050:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-// Types
-is_number = (x) => !isNaN(x);
-is_string = (x) => typeof x == "string";
-is_boolean = (x) => typeof x == "boolean";
-is_array = (x) => Array.isArray(x);
-is_set = (x) => x instanceof Set;
-is_object = (x) => typeof x == "object";
-is_null = (x) => x === null;
-type_name = (x) => typeof x;
+const yaml = __webpack_require__(6792);
+
+// see: https://eemeli.org/yaml/v1/#errors
+const errors = new Set([
+  "YAMLReferenceError",
+  "YAMLSemanticError",
+  "YAMLSyntaxError",
+  "YAMLWarning",
+]);
+
+function parse(str) {
+  if (typeof str !== "string") {
+    return { ok: false, result: undefined };
+  }
+
+  const YAML_SILENCE_WARNINGS_CACHED = global.YAML_SILENCE_WARNINGS;
+  try {
+    // see: https://eemeli.org/yaml/v1/#silencing-warnings
+    global.YAML_SILENCE_WARNINGS = true;
+    return { ok: true, result: yaml.parse(str) };
+  } catch (err) {
+    // Ignore parser errors.
+    if (err && errors.has(err.name)) {
+      return { ok: false, result: undefined };
+    }
+    throw err;
+  } finally {
+    global.YAML_SILENCE_WARNINGS = YAML_SILENCE_WARNINGS_CACHED;
+  }
+}
 
 module.exports = {
-  is_number,
-  is_string,
-  is_boolean,
-  is_array,
-  is_set,
-  is_object,
-  is_null,
-  type_name,
+  // is_valid is expected to return nothing if input is invalid otherwise
+  // true/false for it being valid YAML.
+  "yaml.is_valid": (str) => typeof str === "string" ? parse(str).ok : undefined,
+  "yaml.marshal": (data) => yaml.stringify(data),
+  "yaml.unmarshal": (str) => parse(str).result,
 };
 
 
@@ -157,7 +119,16 @@ module.exports = {
 // Use of this source code is governed by an Apache2
 // license that can be found in the LICENSE file.
 const builtIns = __webpack_require__(42869);
-const utf8 = __webpack_require__(57458);
+const util = __webpack_require__(31669);
+
+// NOTE: The util shim here exists for Node 10.x and can be removed
+// when dropping support. Browsers and Node >= 11.x use the global.
+const TextEncoder = typeof global.TextEncoder !== "undefined"
+  ? global.TextEncoder
+  : util.TextEncoder;
+const TextDecoder = typeof global.TextDecoder !== "undefined"
+  ? global.TextDecoder
+  : util.TextDecoder;
 
 /**
  * @param {WebAssembly.Memory} mem
@@ -177,23 +148,28 @@ function stringDecoder(mem) {
  * Stringifies and loads an object into OPA's Memory
  * @param {WebAssembly.Instance} wasmInstance
  * @param {WebAssembly.Memory} memory
- * @param {any} value
+ * @param {any | ArrayBuffer} value data as `object`, literal primitive or ArrayBuffer (last is assumed to be a well-formed stringified JSON)
  * @returns {number}
  */
 function _loadJSON(wasmInstance, memory, value) {
   if (value === undefined) {
-    throw "unable to load undefined value into memory";
+    return 0;
   }
 
-  const str = utf8.encode(JSON.stringify(value));
-  const rawAddr = wasmInstance.exports.opa_malloc(str.length);
-  const buf = new Uint8Array(memory.buffer);
-
-  for (let i = 0; i < str.length; i++) {
-    buf[rawAddr + i] = str.charCodeAt(i);
+  let valueBuf;
+  if (value instanceof ArrayBuffer) {
+    valueBuf = new Uint8Array(value);
+  } else {
+    const valueAsText = JSON.stringify(value);
+    valueBuf = new TextEncoder().encode(valueAsText);
   }
 
-  const parsedAddr = wasmInstance.exports.opa_json_parse(rawAddr, str.length);
+  const valueBufLen = valueBuf.byteLength;
+  const rawAddr = wasmInstance.exports.opa_malloc(valueBufLen);
+  const memoryBuffer = new Uint8Array(memory.buffer);
+  memoryBuffer.set(valueBuf, rawAddr);
+
+  const parsedAddr = wasmInstance.exports.opa_json_parse(rawAddr, valueBufLen);
 
   if (parsedAddr === 0) {
     throw "failed to parse json value";
@@ -210,16 +186,28 @@ function _loadJSON(wasmInstance, memory, value) {
  */
 function _dumpJSON(wasmInstance, memory, addr) {
   const rawAddr = wasmInstance.exports.opa_json_dump(addr);
+  return _dumpJSONRaw(memory, rawAddr);
+}
+
+/**
+ * Parses a JSON object from wasm instance's memory
+ * @param {WebAssembly.Memory} memory
+ * @param {number} addr
+ * @returns {object}
+ */
+function _dumpJSONRaw(memory, addr) {
   const buf = new Uint8Array(memory.buffer);
 
-  let s = "";
-  let idx = rawAddr;
+  let idx = addr;
 
   while (buf[idx] !== 0) {
-    s += String.fromCharCode(buf[idx++]);
+    idx++;
   }
 
-  return JSON.parse(utf8.decode(s));
+  const utf8View = new Uint8Array(memory.buffer, addr, idx - addr);
+  const jsonAsText = new TextDecoder().decode(utf8View);
+
+  return JSON.parse(jsonAsText);
 }
 
 const builtinFuncs = builtIns;
@@ -232,22 +220,21 @@ const builtinFuncs = builtIns;
  * @param {{ [builtinId: number]: string }} builtins
  * @param {string} builtin_id
  */
-function _builtinCall(wasmInstance, memory, builtins, builtin_id) {
-  const builtInName = builtins[builtin_id];
+function _builtinCall(wasmInstance, memory, builtins, builtinId) {
+  const builtInName = builtins[builtinId];
   const impl = builtinFuncs[builtInName];
 
   if (impl === undefined) {
     throw {
-      message:
-        "not implemented: built-in function " +
-        builtin_id +
+      message: "not implemented: built-in function " +
+        builtinId +
         ": " +
-        builtins[builtin_id],
+        builtins[builtinId],
     };
   }
 
-  var argArray = Array.prototype.slice.apply(arguments);
-  let args = [];
+  const argArray = Array.prototype.slice.apply(arguments);
+  const args = [];
 
   for (let i = 4; i < argArray.length; i++) {
     const jsArg = _dumpJSON(wasmInstance, memory, argArray[i]);
@@ -265,66 +252,97 @@ function _builtinCall(wasmInstance, memory, builtins, builtin_id) {
  * It will return a Promise, depending on the input type the promise
  * resolves to both a compiled WebAssembly.Module and its first WebAssembly.Instance
  * or to the WebAssemblyInstance.
- * @param {BufferSource | WebAssembly.Module} policy_wasm
+ * @param {BufferSource | WebAssembly.Module} policyWasm
  * @param {WebAssembly.Memory} memory
- * @returns {Promise<WebAssembly.WebAssemblyInstantiatedSource | WebAssembly.Instance>}
+ * @returns {Promise<{ policy: WebAssembly.WebAssemblyInstantiatedSource | WebAssembly.Instance, minorVersion: number }>}
  */
-async function _loadPolicy(policy_wasm, memory) {
+async function _loadPolicy(policyWasm, memory) {
   const addr2string = stringDecoder(memory);
 
-  let env = {};
+  const env = {};
 
-  const wasm = await WebAssembly.instantiate(policy_wasm, {
+  const wasm = await WebAssembly.instantiate(policyWasm, {
     env: {
-      memory: memory,
+      memory,
       opa_abort: function (addr) {
         throw addr2string(addr);
       },
       opa_println: function (addr) {
-        console.log(addr2string(addr))
+        console.log(addr2string(addr));
       },
-      opa_builtin0: function (builtin_id, ctx) {
-        return _builtinCall(env.instance, memory, env.builtins, builtin_id);
+      opa_builtin0: function (builtinId, _ctx) {
+        return _builtinCall(env.instance, memory, env.builtins, builtinId);
       },
-      opa_builtin1: function (builtin_id, ctx, _1) {
-        return _builtinCall(env.instance, memory, env.builtins, builtin_id, _1);
+      opa_builtin1: function (builtinId, _ctx, arg1) {
+        return _builtinCall(
+          env.instance,
+          memory,
+          env.builtins,
+          builtinId,
+          arg1,
+        );
       },
-      opa_builtin2: function (builtin_id, ctx, _1, _2) {
+      opa_builtin2: function (builtinId, _ctx, arg1, arg2) {
         return _builtinCall(
           env.instance,
           memory,
           env.builtins,
-          builtin_id,
-          _1,
-          _2,
+          builtinId,
+          arg1,
+          arg2,
         );
       },
-      opa_builtin3: function (builtin_id, ctx, _1, _2, _3) {
+      opa_builtin3: function (builtinId, _ctx, arg1, arg2, arg3) {
         return _builtinCall(
           env.instance,
           memory,
           env.builtins,
-          builtin_id,
-          _1,
-          _2,
-          _3,
+          builtinId,
+          arg1,
+          arg2,
+          arg3,
         );
       },
-      opa_builtin4: function (builtin_id, ctx, _1, _2, _3, _4) {
+      opa_builtin4: function (builtinId, _ctx, arg1, arg2, arg3, arg4) {
         return _builtinCall(
           env.instance,
           memory,
           env.builtins,
-          builtin_id,
-          _1,
-          _2,
-          _3,
-          _4,
+          builtinId,
+          arg1,
+          arg2,
+          arg3,
+          arg4,
         );
       },
     },
   });
 
+  // Note: On Node 10.x this value is a number on Node 12.x and up it is
+  // an object with numberic `value` property.
+  const abiVersionGlobal = wasm.instance.exports.opa_wasm_abi_version;
+  if (abiVersionGlobal !== undefined) {
+    const abiVersion = typeof abiVersionGlobal === "number"
+      ? abiVersionGlobal
+      : abiVersionGlobal.value;
+    if (abiVersion !== 1) {
+      throw `unsupported ABI version ${abiVersion}`;
+    }
+  } else {
+    console.error("opa_wasm_abi_version undefined"); // logs to stderr
+  }
+
+  const abiMinorVersionGlobal =
+    wasm.instance.exports.opa_wasm_abi_minor_version;
+  let abiMinorVersion;
+  if (abiMinorVersionGlobal !== undefined) {
+    abiMinorVersion = typeof abiMinorVersionGlobal === "number"
+      ? abiMinorVersionGlobal
+      : abiMinorVersionGlobal.value;
+  } else {
+    console.error("opa_wasm_abi_minor_version undefined");
+  }
+
   env.instance = wasm.instance ? wasm.instance : wasm;
 
   const builtins = _dumpJSON(
@@ -336,11 +354,11 @@ async function _loadPolicy(policy_wasm, memory) {
   /** @type {typeof builtIns} */
   env.builtins = {};
 
-  for (var key of Object.keys(builtins)) {
+  for (const key of Object.keys(builtins)) {
     env.builtins[builtins[key]] = key;
   }
 
-  return wasm;
+  return { policy: wasm, minorVersion: abiMinorVersion };
 }
 
 /**
@@ -354,7 +372,8 @@ class LoadedPolicy {
    * @param {WebAssembly.WebAssemblyInstantiatedSource} policy
    * @param {WebAssembly.Memory} memory
    */
-  constructor(policy, memory) {
+  constructor(policy, memory, minorVersion) {
+    this.minorVersion = minorVersion;
     this.mem = memory;
 
     // Depending on how the wasm was instantiated "policy" might be a
@@ -365,15 +384,76 @@ class LoadedPolicy {
     this.dataAddr = _loadJSON(this.wasmInstance, this.mem, {});
     this.baseHeapPtr = this.wasmInstance.exports.opa_heap_ptr_get();
     this.dataHeapPtr = this.baseHeapPtr;
+    this.entrypoints = _dumpJSON(
+      this.wasmInstance,
+      this.mem,
+      this.wasmInstance.exports.entrypoints(),
+    );
   }
 
   /**
    * Evaluates the loaded policy with the given input and
    * return the result set. This should be re-used for multiple evaluations
    * of the same policy with different inputs.
-   * @param {object} input
+   *
+   * To call a non-default entrypoint in your WASM specify it as the second
+   * param. A list of entrypoints can be accessed with the `this.entrypoints`
+   * property.
+   * @param {any | ArrayBuffer} input input to be evaluated in form of `object`, literal primitive or ArrayBuffer (last is assumed to be a well-formed stringified JSON)
+   * @param {number | string} entrypoint ID or name of the entrypoint to call (optional)
    */
-  evaluate(input) {
+  evaluate(input, entrypoint = 0) {
+    // determine entrypoint ID
+    if (typeof entrypoint === "number") {
+      // used as-is
+    } else if (typeof entrypoint === "string") {
+      if (Object.prototype.hasOwnProperty.call(this.entrypoints, entrypoint)) {
+        entrypoint = this.entrypoints[entrypoint];
+      } else {
+        throw `entrypoint ${entrypoint} is not valid in this instance`;
+      }
+    } else {
+      throw `entrypoint value is an invalid type, must be either string or number`;
+    }
+
+    // ABI 1.2 fastpath
+    if (this.minorVersion >= 2) {
+      // write input into memory, adjust heap pointer
+      let inputBuf = null;
+      let inputLen = 0;
+      let inputAddr = 0;
+      if (input) {
+        if (input instanceof ArrayBuffer) {
+          inputBuf = new Uint8Array(input);
+        } else {
+          const inputAsText = JSON.stringify(input);
+          inputBuf = new TextEncoder().encode(inputAsText);
+        }
+
+        inputAddr = this.dataHeapPtr;
+        inputLen = inputBuf.byteLength;
+        const delta = inputAddr + inputLen - this.mem.buffer.byteLength;
+        if (delta > 0) {
+          const pages = roundup(delta);
+          this.mem.grow(pages);
+        }
+        const buf = new Uint8Array(this.mem.buffer);
+        buf.set(inputBuf, this.dataHeapPtr);
+        this.dataHeapPtr = inputAddr + inputLen;
+      }
+
+      const ret = this.wasmInstance.exports.opa_eval(
+        0,
+        entrypoint,
+        this.dataAddr,
+        inputAddr,
+        inputLen,
+        this.dataHeapPtr,
+        0,
+      );
+      return _dumpJSONRaw(this.mem, ret);
+    }
+
     // Reset the heap pointer before each evaluation
     this.wasmInstance.exports.opa_heap_ptr_set(this.dataHeapPtr);
 
@@ -384,6 +464,7 @@ class LoadedPolicy {
     const ctxAddr = this.wasmInstance.exports.opa_eval_ctx_new();
     this.wasmInstance.exports.opa_eval_ctx_set_input(ctxAddr, inputAddr);
     this.wasmInstance.exports.opa_eval_ctx_set_data(ctxAddr, this.dataAddr);
+    this.wasmInstance.exports.opa_eval_ctx_set_entrypoint(ctxAddr, entrypoint);
 
     // Actually evaluate the policy
     this.wasmInstance.exports.eval(ctxAddr);
@@ -396,7 +477,7 @@ class LoadedPolicy {
   }
 
   /**
-   * eval_bool will evaluate the policy and return a boolean answer
+   * evalBool will evaluate the policy and return a boolean answer
    * depending on the return code from the policy evaluation.
    * @deprecated Use `evaluate` instead.
    * @param {object} input
@@ -408,7 +489,7 @@ class LoadedPolicy {
 
   /**
    * Loads data for use in subsequent evaluations.
-   * @param {object} data
+   * @param {object | ArrayBuffer} data  data in form of `object` or ArrayBuffer (last is assumed to be a well-formed stringified JSON)
    */
   setData(data) {
     this.wasmInstance.exports.opa_heap_ptr_set(this.baseHeapPtr);
@@ -417,19 +498,35 @@ class LoadedPolicy {
   }
 }
 
+function roundup(bytes) {
+  const pageSize = 64 * 1024;
+  return Math.ceil(bytes / pageSize);
+}
+
 module.exports = {
   /**
    * Takes in either an ArrayBuffer or WebAssembly.Module
    * and will return a LoadedPolicy object which can be used to evaluate
    * the policy.
+   *
+   * To set custom memory size specify number of memory pages
+   * as second param.
+   * Defaults to 5 pages (320KB).
    * @param {BufferSource | WebAssembly.Module} regoWasm
+   * @param {number | WebAssembly.MemoryDescriptor} memoryDescriptor For backwards-compatibility, a 'number' argument is taken to be the initial memory size.
    */
-  async loadPolicy(regoWasm) {
-    const memory = new WebAssembly.Memory({ initial: 5 });
-    const policy = await _loadPolicy(regoWasm, memory);
-    return new LoadedPolicy(policy, memory);
-  }
-}
+  async loadPolicy(regoWasm, memoryDescriptor = {}) {
+    // back-compat, second arg used to be a number: 'memorySize', with default of 5
+    if (typeof memoryDescriptor === "number") {
+      memoryDescriptor = { initial: memoryDescriptor };
+    }
+    memoryDescriptor.initial = memoryDescriptor.initial || 5;
+
+    const memory = new WebAssembly.Memory(memoryDescriptor);
+    const { policy, minorVersion } = await _loadPolicy(regoWasm, memory);
+    return new LoadedPolicy(policy, memory, minorVersion);
+  },
+};
 
 
 /***/ }),
@@ -29412,215 +29509,14 @@ try {
 
 /***/ }),
 
-/***/ 57458:
-/***/ ((__unused_webpack_module, exports) => {
+/***/ 79264:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-/*! https://mths.be/utf8js v3.0.0 by @mathias */
-;(function(root) {
-
-	var stringFromCharCode = String.fromCharCode;
-
-	// Taken from https://mths.be/punycode
-	function ucs2decode(string) {
-		var output = [];
-		var counter = 0;
-		var length = string.length;
-		var value;
-		var extra;
-		while (counter < length) {
-			value = string.charCodeAt(counter++);
-			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
-				// high surrogate, and there is a next character
-				extra = string.charCodeAt(counter++);
-				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
-					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
-				} else {
-					// unmatched surrogate; only append this code unit, in case the next
-					// code unit is the high surrogate of a surrogate pair
-					output.push(value);
-					counter--;
-				}
-			} else {
-				output.push(value);
-			}
-		}
-		return output;
-	}
-
-	// Taken from https://mths.be/punycode
-	function ucs2encode(array) {
-		var length = array.length;
-		var index = -1;
-		var value;
-		var output = '';
-		while (++index < length) {
-			value = array[index];
-			if (value > 0xFFFF) {
-				value -= 0x10000;
-				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
-				value = 0xDC00 | value & 0x3FF;
-			}
-			output += stringFromCharCode(value);
-		}
-		return output;
-	}
-
-	function checkScalarValue(codePoint) {
-		if (codePoint >= 0xD800 && codePoint <= 0xDFFF) {
-			throw Error(
-				'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +
-				' is not a scalar value'
-			);
-		}
-	}
-	/*--------------------------------------------------------------------------*/
-
-	function createByte(codePoint, shift) {
-		return stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);
-	}
-
-	function encodeCodePoint(codePoint) {
-		if ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence
-			return stringFromCharCode(codePoint);
-		}
-		var symbol = '';
-		if ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence
-			symbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);
-		}
-		else if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence
-			checkScalarValue(codePoint);
-			symbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);
-			symbol += createByte(codePoint, 6);
-		}
-		else if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence
-			symbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);
-			symbol += createByte(codePoint, 12);
-			symbol += createByte(codePoint, 6);
-		}
-		symbol += stringFromCharCode((codePoint & 0x3F) | 0x80);
-		return symbol;
-	}
-
-	function utf8encode(string) {
-		var codePoints = ucs2decode(string);
-		var length = codePoints.length;
-		var index = -1;
-		var codePoint;
-		var byteString = '';
-		while (++index < length) {
-			codePoint = codePoints[index];
-			byteString += encodeCodePoint(codePoint);
-		}
-		return byteString;
-	}
-
-	/*--------------------------------------------------------------------------*/
-
-	function readContinuationByte() {
-		if (byteIndex >= byteCount) {
-			throw Error('Invalid byte index');
-		}
-
-		var continuationByte = byteArray[byteIndex] & 0xFF;
-		byteIndex++;
-
-		if ((continuationByte & 0xC0) == 0x80) {
-			return continuationByte & 0x3F;
-		}
-
-		// If we end up here, it’s not a continuation byte
-		throw Error('Invalid continuation byte');
-	}
-
-	function decodeSymbol() {
-		var byte1;
-		var byte2;
-		var byte3;
-		var byte4;
-		var codePoint;
-
-		if (byteIndex > byteCount) {
-			throw Error('Invalid byte index');
-		}
-
-		if (byteIndex == byteCount) {
-			return false;
-		}
-
-		// Read first byte
-		byte1 = byteArray[byteIndex] & 0xFF;
-		byteIndex++;
-
-		// 1-byte sequence (no continuation bytes)
-		if ((byte1 & 0x80) == 0) {
-			return byte1;
-		}
-
-		// 2-byte sequence
-		if ((byte1 & 0xE0) == 0xC0) {
-			byte2 = readContinuationByte();
-			codePoint = ((byte1 & 0x1F) << 6) | byte2;
-			if (codePoint >= 0x80) {
-				return codePoint;
-			} else {
-				throw Error('Invalid continuation byte');
-			}
-		}
-
-		// 3-byte sequence (may include unpaired surrogates)
-		if ((byte1 & 0xF0) == 0xE0) {
-			byte2 = readContinuationByte();
-			byte3 = readContinuationByte();
-			codePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;
-			if (codePoint >= 0x0800) {
-				checkScalarValue(codePoint);
-				return codePoint;
-			} else {
-				throw Error('Invalid continuation byte');
-			}
-		}
-
-		// 4-byte sequence
-		if ((byte1 & 0xF8) == 0xF0) {
-			byte2 = readContinuationByte();
-			byte3 = readContinuationByte();
-			byte4 = readContinuationByte();
-			codePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |
-				(byte3 << 0x06) | byte4;
-			if (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {
-				return codePoint;
-			}
-		}
-
-		throw Error('Invalid UTF-8 detected');
-	}
-
-	var byteArray;
-	var byteCount;
-	var byteIndex;
-	function utf8decode(byteString) {
-		byteArray = ucs2decode(byteString);
-		byteCount = byteArray.length;
-		byteIndex = 0;
-		var codePoints = [];
-		var tmp;
-		while ((tmp = decodeSymbol()) !== false) {
-			codePoints.push(tmp);
-		}
-		return ucs2encode(codePoints);
-	}
-
-	/*--------------------------------------------------------------------------*/
-
-	root.version = '3.0.0';
-	root.encode = utf8encode;
-	root.decode = utf8decode;
-
-}( false ? 0 : exports));
+module.exports = __webpack_require__(39026);
 
 
 /***/ })
 
 };
 ;
-//# sourceMappingURL=424.index.js.map
+//# sourceMappingURL=55.index.js.map