From 3d261d35fcd958488460b59baad6ae9eeb9bac66 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Thu, 14 Apr 2016 10:47:11 -0700
Subject: [PATCH] icu: add icu module

* Moves transcode and normalize to buffer module statics
* Moves getCharacterProperty and getColumnWidth to util
---
 doc/api/buffer.md         |  21 ++
 doc/api/util.md           |  18 ++
 lib/buffer.js             |   3 +
 lib/internal/buffer.js    |  96 ++++++++
 lib/internal/readline.js  | 172 ++++++++------
 lib/util.js               |  12 +
 node.gyp                  |   1 +
 src/node_buffer.cc        |  17 --
 src/node_constants.cc     | 167 ++++++++++++++
 src/node_i18n.cc          | 473 ++++++++++++++++++++++++++++++++++++++
 src/util.h                |  26 +++
 test/parallel/test-icu.js | 123 ++++++++++
 tools/icu/icu-generic.gyp |  18 +-
 13 files changed, 1048 insertions(+), 99 deletions(-)
 create mode 100644 lib/internal/buffer.js
 create mode 100644 test/parallel/test-icu.js

diff --git a/doc/api/buffer.md b/doc/api/buffer.md
index ac2c1e1b6752f0..8cebd8905ff296 100644
--- a/doc/api/buffer.md
+++ b/doc/api/buffer.md
@@ -2304,6 +2304,27 @@ added: v3.0.0
 On 32-bit architectures, this value is `(2^30)-1` (~1GB).
 On 64-bit architectures, this value is `(2^31)-1` (~2GB).
 
+## buffer.normalize(buf, form[, encoding])
+
+* `buf` {Buffer} A `Buffer` instance
+* `form` {String} A Unicode normalization form (one of: `'NFC'`, `'NFD'`,
+   `NFKC`, or `NFKD`)
+* `encoding` {String} The source character encoding of the `buf`. Defaults to
+  `'utf8'`
+
+Performs Unicode Normalization to the `buf` and returns a new `Buffer` instance
+containing the UTF-8 encoded results. Throws if the `form` does not specify a
+valid Normalization form or if the normalization cannot be successfully applied.
+
+## buffer.transcode(buf, from_enc, to_enc)
+
+* `buf` {Buffer} A `Buffer` instance
+* `from_enc` {string} The current encoding
+* `to_enc` {string} The target encoding
+
+Re-encodes the given `Buffer` from one character encoding to another. Returns
+a new `Buffer` instance.
+
 ## Class: SlowBuffer
 <!-- YAML
 deprecated: v6.0.0
diff --git a/doc/api/util.md b/doc/api/util.md
index 3ffefa3f87fe31..1d08dbf2601612 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -10,6 +10,10 @@ module developers as well. It can be accessed using:
 const util = require('util');
 ```
 
+## util.constants
+
+Constants for use with `util.getCharacterProperty()`.
+
 ## util.debuglog(section)
 <!-- YAML
 added: v0.11.3
@@ -133,6 +137,20 @@ Each argument is converted to a string using `util.inspect()`.
 util.format(1, 2, 3); // '1 2 3'
 ```
 
+## util.getCharacterProperty(codepoint, property)
+
+* `codepoint` {number} A Unicode codepoint value
+* `property` {number} A Unicode codepoint constant (from `util.constants.*`)
+
+Returns a specific Unicode codepoint property for the given codepoint value.
+
+## util.getColumnWidth(cp)
+
+* `cp` {number | String} A Unicode codepoint value or a String
+
+Returns the number of terminal columns to be used to display the given Unicode
+codepoint or string.
+
 ## util.inherits(constructor, superConstructor)
 <!-- YAML
 added: v0.3.0
diff --git a/lib/buffer.js b/lib/buffer.js
index 86aa2e512ea352..4651133621a823 100644
--- a/lib/buffer.js
+++ b/lib/buffer.js
@@ -5,6 +5,7 @@ const binding = process.binding('buffer');
 const { isArrayBuffer, isSharedArrayBuffer } = process.binding('util');
 const bindingObj = {};
 const internalUtil = require('internal/util');
+const internalBuffer = require('internal/buffer');
 
 class FastBuffer extends Uint8Array {
   constructor(arg1, arg2, arg3) {
@@ -19,6 +20,8 @@ exports.Buffer = Buffer;
 exports.SlowBuffer = SlowBuffer;
 exports.INSPECT_MAX_BYTES = 50;
 exports.kMaxLength = binding.kMaxLength;
+exports.transcode = internalBuffer.transcode;
+exports.normalize = internalBuffer.normalize;
 
 const kFromErrorMsg = 'First argument must be a string, Buffer, ' +
                       'ArrayBuffer, Array, or array-like object.';
diff --git a/lib/internal/buffer.js b/lib/internal/buffer.js
new file mode 100644
index 00000000000000..81823c8931d1a2
--- /dev/null
+++ b/lib/internal/buffer.js
@@ -0,0 +1,96 @@
+'use strict';
+
+const Buffer = require('buffer').Buffer;
+const normalizeEncoding = require('internal/util').normalizeEncoding;
+
+if (process.binding('config').hasIntl) {
+
+  const icu = process.binding('icu');
+
+  // Maps the supported transcoding conversions. The top key is the from_enc,
+  // the child key is the to_enc. The value is the transcoding function to.
+  const conversions = {
+    'ascii': {
+      'latin1': (source) => {
+        return Buffer.from(source);
+      },
+      'utf8': (source) => {
+        return Buffer.from(source);
+      },
+      'utf16le': (source) => {
+        return icu.convertToUcs2('us-ascii', source);
+      }
+    },
+    'latin1': {
+      'ascii': (source) => {
+        return icu.convert('us-ascii', 'iso8859-1', source);
+      },
+      'utf8': (source) => {
+        return icu.convert('utf-8', 'iso8859-1', source);
+      },
+      'utf16le': (source) => {
+        return icu.convertToUcs2('iso8859-1', source);
+      }
+    },
+    'utf8': {
+      'ascii': (source) => {
+        return icu.convert('us-ascii', 'utf-8', source);
+      },
+      'latin1': (source) => {
+        return icu.convert('iso-8859-1', 'utf-8', source);
+      },
+      'utf16le': icu.convertToUcs2FromUtf8,
+    },
+    'utf16le': {
+      'ascii': (source) => {
+        if (source.length % 2 !== 0)
+          throw new TypeError('Invalid UCS2 Buffer');
+        return icu.convertFromUcs2('us-ascii', source);
+      },
+      'latin1': (source) => {
+        if (source.length % 2 !== 0)
+          throw new TypeError('Invalid UCS2 Buffer');
+        return icu.convertFromUcs2('iso-8859-1', source);
+      },
+      'utf8': (source) => {
+        if (source.length % 2 !== 0)
+          throw new TypeError('Invalid UCS2 Buffer');
+        return icu.convertToUtf8FromUcs2(source);
+      }
+    }
+  };
+
+  // Transcodes the Buffer from one encoding to another, returning a new
+  // Buffer instance.
+  exports.transcode = function transcode(source, from_enc, to_enc) {
+    if (!source || !(source.buffer instanceof ArrayBuffer))
+      throw new TypeError('"source" argument must be a Buffer');
+    if (source.length === 0) return Buffer.alloc(0);
+
+    from_enc = normalizeEncoding(from_enc) || from_enc;
+    to_enc = normalizeEncoding(to_enc) || to_enc;
+
+    if (from_enc === to_enc)
+      return Buffer.from(source);
+
+    const cnv_from = conversions[from_enc];
+
+    if (cnv_from) {
+      const cnv_to = cnv_from[to_enc];
+      if (cnv_to)
+        return cnv_to(source);
+    }
+    throw new TypeError(`Unsupported conversion: ${from_enc} to ${to_enc}`);
+  };
+
+  // Perform Unicode Normalization on the Buffer.
+  exports.normalize = function normalize(buf, form, encoding) {
+    if (!buf || !(buf.buffer instanceof ArrayBuffer))
+      throw new TypeError('First argument must be a Buffer');
+    encoding = normalizeEncoding(encoding);
+    if (encoding === 'ascii')
+      encoding == 'us-ascii';
+    return icu.normalize(buf, encoding, String(form).toUpperCase());
+  };
+
+}
diff --git a/lib/internal/readline.js b/lib/internal/readline.js
index ce22fb9ffb33d8..7bbedccf416a5d 100644
--- a/lib/internal/readline.js
+++ b/lib/internal/readline.js
@@ -2,102 +2,128 @@
 
 // Regexes used for ansi escape code splitting
 // eslint-disable-next-line no-control-regex
-const metaKeyCodeReAnywhere = /(?:\x1b)([a-zA-Z0-9])/;
-const functionKeyCodeReAnywhere = new RegExp('(?:\x1b+)(O|N|\\[|\\[\\[)(?:' + [
-  '(\\d+)(?:;(\\d+))?([~^$])',
-  '(?:M([@ #!a`])(.)(.))', // mouse
-  '(?:1;)?(\\d+)?([a-zA-Z])'
-].join('|') + ')');
+// Adopted from https://github.com/chalk/ansi-regex/blob/master/index.js
+// License: MIT, authors: @sindresorhus, Qix-, and arjunmehta
+const ansi =
+  /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
 
-
-module.exports = {
+exports = module.exports = {
   emitKeys,
-  getStringWidth,
-  isFullWidthCodePoint,
   stripVTControlCharacters
 };
 
 
-/**
- * Returns the number of columns required to display the given string.
- */
-function getStringWidth(str) {
-  let width = 0;
-
-  str = stripVTControlCharacters(str);
-
-  for (let i = 0; i < str.length; i++) {
-    const code = str.codePointAt(i);
+if (process.binding('config').hasIntl) {
+  const util = require('util');
+  exports.getStringWidth = function getStringWidth(str) {
+    return util.getColumnWidth(stripVTControlCharacters(str));
+  };
+
+  exports.isFullWidthCodePoint = function isFullWidthCodePoint(code) {
+    // Defined here largely for legacy support reasons. Updated to
+    // use character properties rather than fixed ranges.
+    const eaw =
+      util.getCharacterProperty(code,
+                                util.constants.UCHAR_EAST_ASIAN_WIDTH);
+    const emoji =
+      util.getCharacterProperty(code,
+                                util.constants.UCHAR_EMOJI_PRESENTATION) &&
+      !util.getCharacterProperty(code,
+                                 util.constants.UCHAR_EMOJI_MODIFIER);
+    return eaw === util.constants.U_EA_FULLWIDTH ||
+           eaw === util.constants.U_EA_WIDE ||
+           emoji;
+  };
+
+} else {
+  // These old implementations are used as fallbacks only when Node.js
+  // is compiled without ICU. The getStringWidth implementation here is
+  // about 30% slower than the ICU based implementation and does not
+  // work properly for emoji and newer unicode characters. The new impl
+  // uses ICU's built in character properties data to provide more accurate
+  // results.
+  /**
+   * Returns the number of columns required to display the given string.
+   */
+  function getStringWidth(str) {
+    let width = 0;
+
+    str = stripVTControlCharacters(str);
+
+    for (let i = 0; i < str.length; i++) {
+      const code = str.codePointAt(i);
+
+      if (code >= 0x10000) { // surrogates
+        i++;
+      }
 
-    if (code >= 0x10000) { // surrogates
-      i++;
+      if (isFullWidthCodePoint(code)) {
+        width += 2;
+      } else {
+        width++;
+      }
     }
 
-    if (isFullWidthCodePoint(code)) {
-      width += 2;
-    } else {
-      width++;
-    }
+    return width;
   }
 
-  return width;
-}
 
+  /**
+   * Returns true if the character represented by a given
+   * Unicode code point is full-width. Otherwise returns false.
+   */
+  function isFullWidthCodePoint(code) {
+    if (isNaN(code)) {
+      return false;
+    }
 
-/**
- * Returns true if the character represented by a given
- * Unicode code point is full-width. Otherwise returns false.
- */
-function isFullWidthCodePoint(code) {
-  if (isNaN(code)) {
-    return false;
-  }
+    // Code points are derived from:
+    // http://www.unicode.org/Public/UNIDATA/EastAsianWidth.txt
+    if (code >= 0x1100 && (
+        code <= 0x115f ||  // Hangul Jamo
+        0x2329 === code || // LEFT-POINTING ANGLE BRACKET
+        0x232a === code || // RIGHT-POINTING ANGLE BRACKET
+        // CJK Radicals Supplement .. Enclosed CJK Letters and Months
+        (0x2e80 <= code && code <= 0x3247 && code !== 0x303f) ||
+        // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
+        0x3250 <= code && code <= 0x4dbf ||
+        // CJK Unified Ideographs .. Yi Radicals
+        0x4e00 <= code && code <= 0xa4c6 ||
+        // Hangul Jamo Extended-A
+        0xa960 <= code && code <= 0xa97c ||
+        // Hangul Syllables
+        0xac00 <= code && code <= 0xd7a3 ||
+        // CJK Compatibility Ideographs
+        0xf900 <= code && code <= 0xfaff ||
+        // Vertical Forms
+        0xfe10 <= code && code <= 0xfe19 ||
+        // CJK Compatibility Forms .. Small Form Variants
+        0xfe30 <= code && code <= 0xfe6b ||
+        // Halfwidth and Fullwidth Forms
+        0xff01 <= code && code <= 0xff60 ||
+        0xffe0 <= code && code <= 0xffe6 ||
+        // Kana Supplement
+        0x1b000 <= code && code <= 0x1b001 ||
+        // Enclosed Ideographic Supplement
+        0x1f200 <= code && code <= 0x1f251 ||
+        // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
+        0x20000 <= code && code <= 0x3fffd)) {
+      return true;
+    }
 
-  // Code points are derived from:
-  // http://www.unicode.org/Public/UNIDATA/EastAsianWidth.txt
-  if (code >= 0x1100 && (
-      code <= 0x115f ||  // Hangul Jamo
-      0x2329 === code || // LEFT-POINTING ANGLE BRACKET
-      0x232a === code || // RIGHT-POINTING ANGLE BRACKET
-      // CJK Radicals Supplement .. Enclosed CJK Letters and Months
-      (0x2e80 <= code && code <= 0x3247 && code !== 0x303f) ||
-      // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
-      0x3250 <= code && code <= 0x4dbf ||
-      // CJK Unified Ideographs .. Yi Radicals
-      0x4e00 <= code && code <= 0xa4c6 ||
-      // Hangul Jamo Extended-A
-      0xa960 <= code && code <= 0xa97c ||
-      // Hangul Syllables
-      0xac00 <= code && code <= 0xd7a3 ||
-      // CJK Compatibility Ideographs
-      0xf900 <= code && code <= 0xfaff ||
-      // Vertical Forms
-      0xfe10 <= code && code <= 0xfe19 ||
-      // CJK Compatibility Forms .. Small Form Variants
-      0xfe30 <= code && code <= 0xfe6b ||
-      // Halfwidth and Fullwidth Forms
-      0xff01 <= code && code <= 0xff60 ||
-      0xffe0 <= code && code <= 0xffe6 ||
-      // Kana Supplement
-      0x1b000 <= code && code <= 0x1b001 ||
-      // Enclosed Ideographic Supplement
-      0x1f200 <= code && code <= 0x1f251 ||
-      // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
-      0x20000 <= code && code <= 0x3fffd)) {
-    return true;
+    return false;
   }
 
-  return false;
+  exports.isFullWidthCodePoint = isFullWidthCodePoint;
+  exports.getStringWidth = getStringWidth;
 }
 
-
 /**
  * Tries to remove all VT control characters. Use to estimate displayed
  * string width. May be buggy due to not running a real state machine
  */
 function stripVTControlCharacters(str) {
-  str = str.replace(new RegExp(functionKeyCodeReAnywhere.source, 'g'), '');
-  return str.replace(new RegExp(metaKeyCodeReAnywhere.source, 'g'), '');
+  return str.replace(ansi, '');
 }
 
 
diff --git a/lib/util.js b/lib/util.js
index f742e38433927f..933f7395d2fc95 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -1053,3 +1053,15 @@ exports._exceptionWithHostPort = function(err,
   }
   return ex;
 };
+
+if (process.binding('config').hasIntl) {
+  const icu = process.binding('icu');
+  const constants = process.binding('constants').icu;
+  Object.defineProperty(exports, 'constants', {
+    configurable: false,
+    enumerable: true,
+    value: constants
+  });
+  exports.getCharacterProperty = icu.getCharacterProperty;
+  exports.getColumnWidth = icu.getColumnWidth;
+}
diff --git a/node.gyp b/node.gyp
index a998d8292613b1..cf446c413c6fb1 100644
--- a/node.gyp
+++ b/node.gyp
@@ -74,6 +74,7 @@
       'lib/v8.js',
       'lib/vm.js',
       'lib/zlib.js',
+      'lib/internal/buffer.js',
       'lib/internal/child_process.js',
       'lib/internal/cluster.js',
       'lib/internal/freelist.js',
diff --git a/src/node_buffer.cc b/src/node_buffer.cc
index 4baa8d9ac659b8..6d9deaad62a060 100644
--- a/src/node_buffer.cc
+++ b/src/node_buffer.cc
@@ -23,23 +23,6 @@
     if (!(r)) return env->ThrowRangeError("out of range index");            \
   } while (0)
 
-#define THROW_AND_RETURN_UNLESS_BUFFER(env, obj)                            \
-  do {                                                                      \
-    if (!HasInstance(obj))                                                  \
-      return env->ThrowTypeError("argument should be a Buffer");            \
-  } while (0)
-
-#define SPREAD_ARG(val, name)                                                 \
-  CHECK((val)->IsUint8Array());                                               \
-  Local<Uint8Array> name = (val).As<Uint8Array>();                            \
-  ArrayBuffer::Contents name##_c = name->Buffer()->GetContents();             \
-  const size_t name##_offset = name->ByteOffset();                            \
-  const size_t name##_length = name->ByteLength();                            \
-  char* const name##_data =                                                   \
-      static_cast<char*>(name##_c.Data()) + name##_offset;                    \
-  if (name##_length > 0)                                                      \
-    CHECK_NE(name##_data, nullptr);
-
 #define SLICE_START_END(start_arg, end_arg, end_max)                        \
   size_t start;                                                             \
   size_t end;                                                               \
diff --git a/src/node_constants.cc b/src/node_constants.cc
index 8aa65ee7e23c35..6959f054971b1c 100644
--- a/src/node_constants.cc
+++ b/src/node_constants.cc
@@ -23,6 +23,10 @@
 # endif  // !OPENSSL_NO_ENGINE
 #endif
 
+#if defined(NODE_HAVE_I18N_SUPPORT)
+#include <unicode/uchar.h>
+#endif
+
 namespace node {
 
 using v8::Local;
@@ -1223,6 +1227,163 @@ void DefineZlibConstants(Local<Object> target) {
   NODE_DEFINE_CONSTANT(target, Z_DEFAULT_LEVEL);
 }
 
+#if defined(NODE_HAVE_I18N_SUPPORT)
+void DefineICUConstants(Local<Object> target) {
+  // Character Property Constants
+  NODE_DEFINE_CONSTANT(target, UCHAR_ALPHABETIC);
+  NODE_DEFINE_CONSTANT(target, UCHAR_ASCII_HEX_DIGIT);
+  NODE_DEFINE_CONSTANT(target, UCHAR_BIDI_CONTROL);
+  NODE_DEFINE_CONSTANT(target, UCHAR_BIDI_MIRRORED);
+  NODE_DEFINE_CONSTANT(target, UCHAR_DASH);
+  NODE_DEFINE_CONSTANT(target, UCHAR_DEFAULT_IGNORABLE_CODE_POINT);
+  NODE_DEFINE_CONSTANT(target, UCHAR_DEPRECATED);
+  NODE_DEFINE_CONSTANT(target, UCHAR_DIACRITIC);
+  NODE_DEFINE_CONSTANT(target, UCHAR_EXTENDER);
+  NODE_DEFINE_CONSTANT(target, UCHAR_FULL_COMPOSITION_EXCLUSION);
+  NODE_DEFINE_CONSTANT(target, UCHAR_GRAPHEME_BASE);
+  NODE_DEFINE_CONSTANT(target, UCHAR_GRAPHEME_EXTEND);
+  NODE_DEFINE_CONSTANT(target, UCHAR_GRAPHEME_LINK);
+  NODE_DEFINE_CONSTANT(target, UCHAR_HEX_DIGIT);
+  NODE_DEFINE_CONSTANT(target, UCHAR_HYPHEN);
+  NODE_DEFINE_CONSTANT(target, UCHAR_ID_CONTINUE);
+  NODE_DEFINE_CONSTANT(target, UCHAR_ID_START);
+  NODE_DEFINE_CONSTANT(target, UCHAR_IDEOGRAPHIC);
+  NODE_DEFINE_CONSTANT(target, UCHAR_IDS_BINARY_OPERATOR);
+  NODE_DEFINE_CONSTANT(target, UCHAR_IDS_TRINARY_OPERATOR);
+  NODE_DEFINE_CONSTANT(target, UCHAR_JOIN_CONTROL);
+  NODE_DEFINE_CONSTANT(target, UCHAR_LOGICAL_ORDER_EXCEPTION);
+  NODE_DEFINE_CONSTANT(target, UCHAR_LOWERCASE);
+  NODE_DEFINE_CONSTANT(target, UCHAR_MATH);
+  NODE_DEFINE_CONSTANT(target, UCHAR_NONCHARACTER_CODE_POINT);
+  NODE_DEFINE_CONSTANT(target, UCHAR_QUOTATION_MARK);
+  NODE_DEFINE_CONSTANT(target, UCHAR_RADICAL);
+  NODE_DEFINE_CONSTANT(target, UCHAR_SOFT_DOTTED);
+  NODE_DEFINE_CONSTANT(target, UCHAR_TERMINAL_PUNCTUATION);
+  NODE_DEFINE_CONSTANT(target, UCHAR_UNIFIED_IDEOGRAPH);
+  NODE_DEFINE_CONSTANT(target, UCHAR_UPPERCASE);
+  NODE_DEFINE_CONSTANT(target, UCHAR_WHITE_SPACE);
+  NODE_DEFINE_CONSTANT(target, UCHAR_XID_CONTINUE);
+  NODE_DEFINE_CONSTANT(target, UCHAR_XID_START);
+  NODE_DEFINE_CONSTANT(target, UCHAR_CASE_SENSITIVE);
+  NODE_DEFINE_CONSTANT(target, UCHAR_S_TERM);
+  NODE_DEFINE_CONSTANT(target, UCHAR_VARIATION_SELECTOR);
+  NODE_DEFINE_CONSTANT(target, UCHAR_NFD_INERT);
+  NODE_DEFINE_CONSTANT(target, UCHAR_NFKD_INERT);
+  NODE_DEFINE_CONSTANT(target, UCHAR_NFC_INERT);
+  NODE_DEFINE_CONSTANT(target, UCHAR_NFKC_INERT);
+  NODE_DEFINE_CONSTANT(target, UCHAR_SEGMENT_STARTER);
+  NODE_DEFINE_CONSTANT(target, UCHAR_PATTERN_SYNTAX);
+  NODE_DEFINE_CONSTANT(target, UCHAR_PATTERN_WHITE_SPACE);
+  NODE_DEFINE_CONSTANT(target, UCHAR_POSIX_ALNUM);
+  NODE_DEFINE_CONSTANT(target, UCHAR_POSIX_BLANK);
+  NODE_DEFINE_CONSTANT(target, UCHAR_POSIX_GRAPH);
+  NODE_DEFINE_CONSTANT(target, UCHAR_POSIX_PRINT);
+  NODE_DEFINE_CONSTANT(target, UCHAR_POSIX_XDIGIT);
+  NODE_DEFINE_CONSTANT(target, UCHAR_CASED);
+  NODE_DEFINE_CONSTANT(target, UCHAR_CASE_IGNORABLE);
+  NODE_DEFINE_CONSTANT(target, UCHAR_CHANGES_WHEN_LOWERCASED);
+  NODE_DEFINE_CONSTANT(target, UCHAR_CHANGES_WHEN_UPPERCASED);
+  NODE_DEFINE_CONSTANT(target, UCHAR_CHANGES_WHEN_TITLECASED);
+  NODE_DEFINE_CONSTANT(target, UCHAR_CHANGES_WHEN_CASEFOLDED);
+  NODE_DEFINE_CONSTANT(target, UCHAR_CHANGES_WHEN_CASEMAPPED);
+  NODE_DEFINE_CONSTANT(target, UCHAR_CHANGES_WHEN_NFKC_CASEFOLDED);
+  NODE_DEFINE_CONSTANT(target, UCHAR_EMOJI);
+  NODE_DEFINE_CONSTANT(target, UCHAR_EMOJI_PRESENTATION);
+  NODE_DEFINE_CONSTANT(target, UCHAR_EMOJI_MODIFIER);
+  NODE_DEFINE_CONSTANT(target, UCHAR_EMOJI_MODIFIER_BASE);
+  NODE_DEFINE_CONSTANT(target, UCHAR_BIDI_CLASS);
+  NODE_DEFINE_CONSTANT(target, UCHAR_BLOCK);
+  NODE_DEFINE_CONSTANT(target, UCHAR_CANONICAL_COMBINING_CLASS);
+  NODE_DEFINE_CONSTANT(target, UCHAR_DECOMPOSITION_TYPE);
+  NODE_DEFINE_CONSTANT(target, UCHAR_EAST_ASIAN_WIDTH);
+  NODE_DEFINE_CONSTANT(target, UCHAR_GENERAL_CATEGORY);
+  NODE_DEFINE_CONSTANT(target, UCHAR_JOINING_GROUP);
+  NODE_DEFINE_CONSTANT(target, UCHAR_JOINING_TYPE);
+  NODE_DEFINE_CONSTANT(target, UCHAR_LINE_BREAK);
+  NODE_DEFINE_CONSTANT(target, UCHAR_NUMERIC_TYPE);
+  NODE_DEFINE_CONSTANT(target, UCHAR_SCRIPT);
+  NODE_DEFINE_CONSTANT(target, UCHAR_HANGUL_SYLLABLE_TYPE);
+  NODE_DEFINE_CONSTANT(target, UCHAR_NFD_QUICK_CHECK);
+  NODE_DEFINE_CONSTANT(target, UCHAR_NFKD_QUICK_CHECK);
+  NODE_DEFINE_CONSTANT(target, UCHAR_NFC_QUICK_CHECK);
+  NODE_DEFINE_CONSTANT(target, UCHAR_NFKC_QUICK_CHECK);
+  NODE_DEFINE_CONSTANT(target, UCHAR_LEAD_CANONICAL_COMBINING_CLASS);
+  NODE_DEFINE_CONSTANT(target, UCHAR_TRAIL_CANONICAL_COMBINING_CLASS);
+  NODE_DEFINE_CONSTANT(target, UCHAR_GRAPHEME_CLUSTER_BREAK);
+  NODE_DEFINE_CONSTANT(target, UCHAR_SENTENCE_BREAK);
+  NODE_DEFINE_CONSTANT(target, UCHAR_WORD_BREAK);
+  NODE_DEFINE_CONSTANT(target, UCHAR_BIDI_PAIRED_BRACKET_TYPE);
+  NODE_DEFINE_CONSTANT(target, UCHAR_GENERAL_CATEGORY_MASK);
+  NODE_DEFINE_CONSTANT(target, UCHAR_NUMERIC_VALUE);
+
+  // Char Category Constants
+  NODE_DEFINE_CONSTANT(target, U_UNASSIGNED);
+  NODE_DEFINE_CONSTANT(target, U_GENERAL_OTHER_TYPES);
+  NODE_DEFINE_CONSTANT(target, U_UPPERCASE_LETTER);
+  NODE_DEFINE_CONSTANT(target, U_LOWERCASE_LETTER);
+  NODE_DEFINE_CONSTANT(target, U_TITLECASE_LETTER);
+  NODE_DEFINE_CONSTANT(target, U_MODIFIER_LETTER);
+  NODE_DEFINE_CONSTANT(target, U_OTHER_LETTER);
+  NODE_DEFINE_CONSTANT(target, U_NON_SPACING_MARK);
+  NODE_DEFINE_CONSTANT(target, U_ENCLOSING_MARK);
+  NODE_DEFINE_CONSTANT(target, U_COMBINING_SPACING_MARK);
+  NODE_DEFINE_CONSTANT(target, U_DECIMAL_DIGIT_NUMBER);
+  NODE_DEFINE_CONSTANT(target, U_LETTER_NUMBER);
+  NODE_DEFINE_CONSTANT(target, U_OTHER_NUMBER);
+  NODE_DEFINE_CONSTANT(target, U_SPACE_SEPARATOR);
+  NODE_DEFINE_CONSTANT(target, U_LINE_SEPARATOR);
+  NODE_DEFINE_CONSTANT(target, U_PARAGRAPH_SEPARATOR);
+  NODE_DEFINE_CONSTANT(target, U_CONTROL_CHAR);
+  NODE_DEFINE_CONSTANT(target, U_FORMAT_CHAR);
+  NODE_DEFINE_CONSTANT(target, U_PRIVATE_USE_CHAR);
+  NODE_DEFINE_CONSTANT(target, U_SURROGATE);
+  NODE_DEFINE_CONSTANT(target, U_DASH_PUNCTUATION);
+  NODE_DEFINE_CONSTANT(target, U_START_PUNCTUATION);
+  NODE_DEFINE_CONSTANT(target, U_END_PUNCTUATION);
+  NODE_DEFINE_CONSTANT(target, U_CONNECTOR_PUNCTUATION);
+  NODE_DEFINE_CONSTANT(target, U_OTHER_PUNCTUATION);
+  NODE_DEFINE_CONSTANT(target, U_MATH_SYMBOL);
+  NODE_DEFINE_CONSTANT(target, U_CURRENCY_SYMBOL);
+  NODE_DEFINE_CONSTANT(target, U_MODIFIER_SYMBOL);
+  NODE_DEFINE_CONSTANT(target, U_OTHER_SYMBOL);
+  NODE_DEFINE_CONSTANT(target, U_INITIAL_PUNCTUATION);
+  NODE_DEFINE_CONSTANT(target, U_FINAL_PUNCTUATION);
+
+  // Direction Constants
+  NODE_DEFINE_CONSTANT(target, U_LEFT_TO_RIGHT);
+  NODE_DEFINE_CONSTANT(target, U_RIGHT_TO_LEFT);
+  NODE_DEFINE_CONSTANT(target, U_EUROPEAN_NUMBER);
+  NODE_DEFINE_CONSTANT(target, U_EUROPEAN_NUMBER_SEPARATOR);
+  NODE_DEFINE_CONSTANT(target, U_EUROPEAN_NUMBER_TERMINATOR);
+  NODE_DEFINE_CONSTANT(target, U_ARABIC_NUMBER);
+  NODE_DEFINE_CONSTANT(target, U_COMMON_NUMBER_SEPARATOR);
+  NODE_DEFINE_CONSTANT(target, U_BLOCK_SEPARATOR);
+  NODE_DEFINE_CONSTANT(target, U_SEGMENT_SEPARATOR);
+  NODE_DEFINE_CONSTANT(target, U_WHITE_SPACE_NEUTRAL);
+  NODE_DEFINE_CONSTANT(target, U_OTHER_NEUTRAL);
+  NODE_DEFINE_CONSTANT(target, U_LEFT_TO_RIGHT_EMBEDDING);
+  NODE_DEFINE_CONSTANT(target, U_LEFT_TO_RIGHT_OVERRIDE);
+  NODE_DEFINE_CONSTANT(target, U_RIGHT_TO_LEFT_ARABIC);
+  NODE_DEFINE_CONSTANT(target, U_RIGHT_TO_LEFT_EMBEDDING);
+  NODE_DEFINE_CONSTANT(target, U_RIGHT_TO_LEFT_OVERRIDE);
+  NODE_DEFINE_CONSTANT(target, U_POP_DIRECTIONAL_FORMAT);
+  NODE_DEFINE_CONSTANT(target, U_DIR_NON_SPACING_MARK);
+  NODE_DEFINE_CONSTANT(target, U_BOUNDARY_NEUTRAL);
+  NODE_DEFINE_CONSTANT(target, U_FIRST_STRONG_ISOLATE);
+  NODE_DEFINE_CONSTANT(target, U_LEFT_TO_RIGHT_ISOLATE);
+  NODE_DEFINE_CONSTANT(target, U_RIGHT_TO_LEFT_ISOLATE);
+  NODE_DEFINE_CONSTANT(target, U_POP_DIRECTIONAL_ISOLATE);
+
+  // Width Constants
+  NODE_DEFINE_CONSTANT(target, U_EA_NEUTRAL);
+  NODE_DEFINE_CONSTANT(target, U_EA_AMBIGUOUS);
+  NODE_DEFINE_CONSTANT(target, U_EA_HALFWIDTH);
+  NODE_DEFINE_CONSTANT(target, U_EA_FULLWIDTH);
+  NODE_DEFINE_CONSTANT(target, U_EA_NARROW);
+  NODE_DEFINE_CONSTANT(target, U_EA_WIDE);
+}
+#endif
+
 void DefineConstants(v8::Isolate* isolate, Local<Object> target) {
   Local<Object> os_constants = Object::New(isolate);
   Local<Object> err_constants = Object::New(isolate);
@@ -1246,6 +1407,12 @@ void DefineConstants(v8::Isolate* isolate, Local<Object> target) {
   target->Set(OneByteString(isolate, "fs"), fs_constants);
   target->Set(OneByteString(isolate, "crypto"), crypto_constants);
   target->Set(OneByteString(isolate, "zlib"), zlib_constants);
+
+  #if defined(NODE_HAVE_I18N_SUPPORT)
+    Local<Object> icu_constants = Object::New(isolate);
+    DefineICUConstants(icu_constants);
+    target->Set(OneByteString(isolate, "icu"), icu_constants);
+  #endif
 }
 
 }  // namespace node
diff --git a/src/node_i18n.cc b/src/node_i18n.cc
index 0f3b9b76e6959e..c5c7a66ab8e1a2 100644
--- a/src/node_i18n.cc
+++ b/src/node_i18n.cc
@@ -24,6 +24,7 @@
 #if defined(NODE_HAVE_I18N_SUPPORT)
 
 #include "node.h"
+#include "node_buffer.h"
 #include "env.h"
 #include "env-inl.h"
 #include "util.h"
@@ -33,6 +34,14 @@
 #include <unicode/putil.h>
 #include <unicode/udata.h>
 #include <unicode/uidna.h>
+#include <unicode/utypes.h>
+#include <unicode/ustring.h>
+#include <unicode/ucnv.h>
+#include <unicode/utf8.h>
+#include <unicode/utf16.h>
+#include <unicode/normalizer2.h>
+#include <unicode/unistr.h>
+#include <unicode/uchar.h>
 
 #ifdef NODE_HAVE_SMALL_ICU
 /* if this is defined, we have a 'secondary' entry point.
@@ -52,16 +61,91 @@ extern "C" const char U_DATA_API SMALL_ICUDATA_ENTRY_POINT[];
 namespace node {
 
 using v8::Context;
+using v8::Exception;
 using v8::FunctionCallbackInfo;
+using v8::HandleScope;
+using v8::Integer;
+using v8::Isolate;
 using v8::Local;
+using v8::MaybeLocal;
 using v8::Object;
 using v8::String;
+using v8::Uint32;
 using v8::Value;
 
 bool flag_icu_data_dir = false;
 
 namespace i18n {
 
+Local<Value> ICUException(Environment* env,
+                          UErrorCode status,
+                          const char* msg) {
+  Local<String> estring = OneByteString(env->isolate(), u_errorName(status));
+  if (msg == nullptr || msg[0] == '\0')
+    msg = "Unspecified ICU Exception";
+  Local<String> cons =
+      String::Concat(estring, FIXED_ONE_BYTE_STRING(env->isolate(), ", "));
+  cons = String::Concat(cons, OneByteString(env->isolate(), msg));
+
+  Local<Value> e = Exception::Error(cons);
+  Local<Object> obj = e->ToObject(env->isolate());
+  obj->Set(env->errno_string(), Integer::New(env->isolate(), status));
+  obj->Set(env->code_string(), estring);
+  return e;
+}
+
+#define THROW_ICU_ERROR(env, status, msg)                                     \
+  do {                                                                        \
+    v8::HandleScope scope(env->isolate());                                    \
+    env->isolate()->ThrowException(ICUException(env, status, msg));           \
+  }                                                                           \
+  while (0)
+
+MaybeLocal<Object> AsBuffer(Isolate* isolate,
+                            MaybeStackBuffer<char>* buf,
+                            size_t len) {
+  if (buf->IsAllocated()) {
+    MaybeLocal<Object> ret = Buffer::New(isolate, buf->out(), len);
+    buf->Release();
+    return ret;
+  }
+  return Buffer::Copy(isolate, buf->out(), len);
+}
+
+MaybeLocal<Object> AsBuffer(Isolate* isolate,
+                            MaybeStackBuffer<UChar>* buf,
+                            size_t len) {
+  if (IsBigEndian()) {
+    uint16_t* dst = reinterpret_cast<uint16_t*>(buf->out());
+    SwapBytes(dst, dst, len);
+  }
+  if (buf->IsAllocated()) {
+    MaybeLocal<Object> ret =
+        Buffer::New(isolate, reinterpret_cast<char*>(buf->out()), len);
+    buf->Release();
+    return ret;
+  }
+  return Buffer::Copy(isolate, reinterpret_cast<char*>(buf->out()), len);
+}
+
+struct Converter {
+  Converter(Environment* env, const char* name)
+      : conv(nullptr) {
+    UErrorCode status = U_ZERO_ERROR;
+    conv = ucnv_open(name, &status);
+    if (U_FAILURE(status)) {
+      THROW_ICU_ERROR(env, status, "Unable to create converter");
+    }
+  }
+
+  ~Converter() {
+    if (conv != nullptr)
+      ucnv_close(conv);
+  }
+
+  UConverter* conv;
+};
+
 bool InitializeICUDirectory(const char* icu_data_path) {
   if (icu_data_path != nullptr) {
     flag_icu_data_dir = true;
@@ -185,6 +269,384 @@ static void ToASCII(const FunctionCallbackInfo<Value>& args) {
                           len).ToLocalChecked());
 }
 
+// One-Shot Converters
+
+// Converts the Buffer from one named encoding to another.
+// args[0] is a string identifying the encoding we're converting to.
+// args[1] is a string identifying the encoding we're converting from.
+// args[2] must be a buffer instance
+void Convert(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  CHECK(args[0]->IsString());
+  CHECK(args[1]->IsString());
+  THROW_AND_RETURN_UNLESS_BUFFER(env, args[2]);
+
+  Utf8Value to_name(env->isolate(), args[0]);
+  Utf8Value from_name(env->isolate(), args[1]);
+
+  SPREAD_ARG(args[2], ts_obj);
+
+  UErrorCode status = U_ZERO_ERROR;
+
+  MaybeStackBuffer<char> buf;
+  uint32_t len, limit;
+  char* target;
+  const char* data = ts_obj_data;
+
+  Converter to(env, *to_name);
+  Converter from(env, *from_name);
+  if (to.conv == nullptr || from.conv == nullptr)
+    return;
+
+  ucnv_setSubstChars(to.conv, "?", 1, &status);
+  status = U_ZERO_ERROR;
+
+  limit = ts_obj_length * ucnv_getMaxCharSize(to.conv);
+  buf.AllocateSufficientStorage(ts_obj_length * ucnv_getMaxCharSize(to.conv));
+  target = *buf;
+
+  ucnv_convertEx(to.conv, from.conv,
+                 &target, target + limit,
+                 &data, ts_obj_data + ts_obj_length,
+                 NULL, NULL, NULL, NULL,
+                 true, true,
+                 &status);
+
+  if (U_SUCCESS(status)) {
+    len = target - *buf;
+    args.GetReturnValue().Set(
+      AsBuffer(env->isolate(), &buf, len).ToLocalChecked());
+  } else {
+    THROW_ICU_ERROR(env, status, "Unable to transcode buffer");
+  }
+}
+
+// Converts to UCS2 from ISO-8859-1 and US-ASCII
+// args[0] is the encoding to convert from
+// args[1] must be a buffer instance
+void ConvertToUcs2(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  CHECK(args[0]->IsString());
+  THROW_AND_RETURN_UNLESS_BUFFER(env, args[1]);
+
+  Utf8Value name(env->isolate(), args[0]);
+
+  SPREAD_ARG(args[1], ts_obj);
+
+  UErrorCode status = U_ZERO_ERROR;
+  size_t len;
+
+  MaybeStackBuffer<UChar> buf(ts_obj_length);
+
+  Converter from(env, *name);
+  if (from.conv == nullptr)
+    return;
+
+  len = ucnv_toUChars(from.conv,
+                      *buf, ts_obj_length << 1,
+                      ts_obj_data, ts_obj_length,
+                      &status);
+
+  if (U_FAILURE(status)) {
+    THROW_ICU_ERROR(env, status, "Unable to transcode buffer");
+    return;
+  }
+  args.GetReturnValue().Set(
+    AsBuffer(env->isolate(), &buf, ts_obj_length << 1).ToLocalChecked());
+}
+
+// Convert to a named encoding from UCS2
+// args[0] is the name of the encoding being converted to
+// args[1] must be a buffer instance
+void ConvertFromUcs2(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  CHECK(args[0]->IsString());
+  THROW_AND_RETURN_UNLESS_BUFFER(env, args[1]);
+
+  Utf8Value name(env->isolate(), args[0]);
+  SPREAD_ARG(args[1], ts_obj);
+
+  UErrorCode status = U_ZERO_ERROR;
+
+  UChar* source = nullptr;
+  MaybeStackBuffer<UChar> swapspace;
+  const size_t length = ts_obj_length >> 1;
+
+  if (IsLittleEndian()) {
+    source = reinterpret_cast<UChar*>(ts_obj_data);
+  } else {
+    swapspace.AllocateSufficientStorage(length);
+    for (size_t n = 0, i = 0; i < length; n += 2, i += 1) {
+      const uint8_t hi = static_cast<uint8_t>(ts_obj_data[n + 0]);
+      const uint8_t lo = static_cast<uint8_t>(ts_obj_data[n + 1]);
+      swapspace[i] = (hi << 8) | lo;
+    }
+    source = *swapspace;
+  }
+
+  uint32_t len;
+  MaybeStackBuffer<char> buf(length);
+
+  Converter to(env, *name);
+  if (to.conv == nullptr)
+    return;
+  ucnv_setSubstChars(to.conv, "?", 1, &status);
+  status = U_ZERO_ERROR;
+
+  len = ucnv_fromUChars(to.conv, *buf, length, source, length, &status);
+
+  if (U_SUCCESS(status)) {
+    args.GetReturnValue().Set(
+      AsBuffer(env->isolate(), &buf, len).ToLocalChecked());
+  } else {
+    THROW_ICU_ERROR(env, status, "Unable to transcode buffer");
+  }
+}
+
+// Converts from UTF-8 to UCS2
+// args[0] must be a buffer instance
+void Ucs2FromUtf8(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  THROW_AND_RETURN_UNLESS_BUFFER(env, args[0]);
+  SPREAD_ARG(args[0], ts_obj);
+
+  UErrorCode status = U_ZERO_ERROR;
+
+  MaybeStackBuffer<UChar> buf;
+  int32_t len;
+
+  u_strFromUTF8(*buf, 1024, &len, ts_obj_data, ts_obj_length, &status);
+
+  if (U_SUCCESS(status)) {
+    args.GetReturnValue().Set(
+        AsBuffer(env->isolate(), &buf, len * sizeof(UChar)).ToLocalChecked());
+  } else if (status == U_BUFFER_OVERFLOW_ERROR) {
+    status = U_ZERO_ERROR;
+    buf.AllocateSufficientStorage(len);
+    u_strFromUTF8(*buf, len, &len, ts_obj_data, ts_obj_length, &status);
+    if (U_FAILURE(status)) {
+      THROW_ICU_ERROR(env, status, "Unable to transcode buffer");
+      return;
+    }
+    args.GetReturnValue().Set(
+      AsBuffer(env->isolate(), &buf, len << 1).ToLocalChecked());
+  } else {
+    THROW_ICU_ERROR(env, status, "Unable to transcode buffer");
+  }
+}
+
+// Converts UCS2 into UTF-8
+// args[0] must be a buffer instance
+void Utf8FromUcs2(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  THROW_AND_RETURN_UNLESS_BUFFER(env, args[0]);
+  SPREAD_ARG(args[0], ts_obj);
+
+  const size_t length = ts_obj_length >> 1;
+
+  UChar* source = nullptr;
+  MaybeStackBuffer<UChar> swapspace;
+  if (IsLittleEndian()) {
+    source = reinterpret_cast<UChar*>(ts_obj_data);
+  } else {
+    swapspace.AllocateSufficientStorage(length);
+    for (size_t n = 0, i = 0; i < length; n += 2, i += 1) {
+      const uint8_t hi = static_cast<uint8_t>(ts_obj_data[n + 0]);
+      const uint8_t lo = static_cast<uint8_t>(ts_obj_data[n + 1]);
+      swapspace[i] = (hi << 8) | lo;
+    }
+    source = *swapspace;
+  }
+
+  UErrorCode status = U_ZERO_ERROR;
+
+  MaybeStackBuffer<char> buf;
+  int32_t len;
+
+  u_strToUTF8(*buf, 1024, &len, source, length, &status);
+  if (U_SUCCESS(status)) {
+    // Used the static buf, just copy it into the new Buffer instance.
+    args.GetReturnValue().Set(
+      AsBuffer(env->isolate(), &buf, len).ToLocalChecked());
+  } else if (status == U_BUFFER_OVERFLOW_ERROR) {
+    status = U_ZERO_ERROR;
+    buf.AllocateSufficientStorage(len);
+    u_strToUTF8(*buf, len, &len, source, length, &status);
+    if (U_FAILURE(status)) {
+      THROW_ICU_ERROR(env, status, "Unable to transcode buffer");
+      return;
+    }
+    args.GetReturnValue().Set(
+      Buffer::New(env->isolate(), *buf, len).ToLocalChecked());
+    buf.Release();
+  } else {
+    THROW_ICU_ERROR(env, status, "Unable to transcode buffer");
+  }
+}
+
+void NormalizeBuffer(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  THROW_AND_RETURN_UNLESS_BUFFER(env, args[0]);
+  SPREAD_ARG(args[0], ts_obj);
+
+  Utf8Value encoding(env->isolate(), args[1]);
+  Utf8Value form(env->isolate(), args[2]);
+
+  icu::UnicodeString input(ts_obj_data, ts_obj_length, *encoding);
+  icu::UnicodeString output;
+
+  UErrorCode status = U_ZERO_ERROR;
+  const icu::Normalizer2* normalizer = nullptr;
+
+  if (strcmp(*form, "NFC") == 0) {
+    normalizer = icu::Normalizer2::getNFCInstance(status);
+  } else if (strcmp(*form, "NFD") == 0) {
+    normalizer = icu::Normalizer2::getNFDInstance(status);
+  } else if (strcmp(*form, "NFKC") == 0) {
+    normalizer = icu::Normalizer2::getNFKCInstance(status);
+  } else if (strcmp(*form, "NFKD") == 0) {
+    normalizer = icu::Normalizer2::getNFKDInstance(status);
+  } else {
+    return env->ThrowTypeError("Unknown Unicode normalization form");
+  }
+  if (U_FAILURE(status)) {
+    THROW_ICU_ERROR(env, status, "Unable to initialize normalizer");
+    return;
+  }
+  status = U_ZERO_ERROR;
+  normalizer->normalize(input, output, status);
+  if (U_FAILURE(status)) {
+    THROW_ICU_ERROR(env, status, "Unable to normalize buffer");
+    return;
+  }
+  status = U_ZERO_ERROR;
+
+  MaybeStackBuffer<char> res;
+  int32_t len;
+  u_strToUTF8(*res, 1024, &len,
+              output.getTerminatedBuffer(),
+              output.length(),
+              &status);
+  if (status == U_BUFFER_OVERFLOW_ERROR) {
+    status = U_ZERO_ERROR;
+    res.AllocateSufficientStorage(len);
+    u_strToUTF8(*res, len, &len,
+                output.getTerminatedBuffer(),
+                output.length(),
+                &status);
+  }
+  if (U_FAILURE(status)) {
+    THROW_ICU_ERROR(env, status, "Unable to process normalized output");
+    return;
+  }
+
+  args.GetReturnValue().Set(
+    AsBuffer(env->isolate(), &res, len).ToLocalChecked());
+}
+
+static void GetCharacterProperty(const FunctionCallbackInfo<Value>& args) {
+  if (args.Length() < 2)
+    return;
+  UChar32 codepoint = args[0]->Uint32Value();
+  UProperty property = static_cast<UProperty>(args[1]->Int32Value());
+  if (!u_isdefined(codepoint))
+    return;
+  if (property < UCHAR_BINARY_LIMIT) {
+    args.GetReturnValue().Set(
+      static_cast<bool>(u_hasBinaryProperty(codepoint, property)));
+  } else if (property >= UCHAR_INT_START && property < UCHAR_MASK_LIMIT) {
+    args.GetReturnValue().Set(u_getIntPropertyValue(codepoint, property));
+  } else if (property == UCHAR_NUMERIC_VALUE) {
+    args.GetReturnValue().Set(u_getNumericValue(codepoint));
+  } else if (property >= UCHAR_STRING_START && property < UCHAR_STRING_LIMIT) {
+    switch (property) {
+      case UCHAR_BIDI_MIRRORING_GLYPH:
+        args.GetReturnValue().Set(u_charMirror(codepoint));
+        break;
+      case UCHAR_SIMPLE_LOWERCASE_MAPPING:
+        args.GetReturnValue().Set(u_tolower(codepoint));
+        break;
+      case UCHAR_SIMPLE_TITLECASE_MAPPING:
+        args.GetReturnValue().Set(u_totitle(codepoint));
+        break;
+      case UCHAR_SIMPLE_UPPERCASE_MAPPING:
+        args.GetReturnValue().Set(u_toupper(codepoint));
+        break;
+      case UCHAR_BIDI_PAIRED_BRACKET:
+        args.GetReturnValue().Set(u_getBidiPairedBracket(codepoint));
+        break;
+      default:
+        // Do nothing and fallthrough
+        break;
+    }
+  }
+}
+
+// This is similar to wcwidth except that it takes the current unicode
+// character properties database into consideration, allowing it to
+// correctly calculate the column widths of things like emoji's and
+// newer wide characters. wcwidth, on the other hand, uses a fixed
+// algorithm that does not take things like emoji into proper
+// consideration.
+static int GetColumnWidth(UChar32 codepoint, bool ambiguousFull = false) {
+  const int eaw = u_getIntPropertyValue(codepoint, UCHAR_EAST_ASIAN_WIDTH);
+  switch (eaw) {
+    case U_EA_FULLWIDTH:
+    case U_EA_WIDE:
+      return 2;
+    case U_EA_AMBIGUOUS:
+      if (ambiguousFull)
+        return 2;
+    case U_EA_NEUTRAL:
+      if (u_iscntrl(codepoint) ||
+          u_hasBinaryProperty(codepoint, UCHAR_EMOJI_MODIFIER) ||
+          u_getCombiningClass(codepoint) > 0)
+        return 0;
+      if (u_hasBinaryProperty(codepoint, UCHAR_EMOJI_PRESENTATION))
+        return 2;
+    case U_EA_HALFWIDTH:
+    case U_EA_NARROW:
+    default:
+      return 1;
+  }
+}
+
+// Returns the column width for the given String
+static void GetColumnWidth(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  if (args.Length() < 1)
+    return;
+
+  if (args[0]->IsNumber()) {
+    args.GetReturnValue().Set(GetColumnWidth(args[0]->Uint32Value()));
+    return;
+  }
+
+  bool ambiguousFull = args.Length() > 1 ? args[1]->BooleanValue() : false;
+
+  TwoByteValue value(env->isolate(), args[0].As<String>());
+  UChar* str = static_cast<UChar*>(*value);
+  UChar32 c;
+  size_t n = 0;
+  int width = 0;
+  while (n < value.length()) {
+    U16_NEXT(str, n, value.length(), c);
+    const int cols = GetColumnWidth(c, ambiguousFull);
+    if (cols < 0) {
+      width = -1;
+      break;
+    }
+    width += cols;
+  }
+  args.GetReturnValue().Set(width);
+}
+
 void Init(Local<Object> target,
           Local<Value> unused,
           Local<Context> context,
@@ -192,6 +654,17 @@ void Init(Local<Object> target,
   Environment* env = Environment::GetCurrent(context);
   env->SetMethod(target, "toUnicode", ToUnicode);
   env->SetMethod(target, "toASCII", ToASCII);
+
+  // One-Shot Converters.
+  env->SetMethod(target, "convert", Convert);
+  env->SetMethod(target, "convertFromUcs2", ConvertFromUcs2);
+  env->SetMethod(target, "convertToUcs2", ConvertToUcs2);
+  env->SetMethod(target, "convertToUcs2FromUtf8", Ucs2FromUtf8);
+  env->SetMethod(target, "convertToUtf8FromUcs2", Utf8FromUcs2);
+
+  env->SetMethod(target, "normalize", NormalizeBuffer);
+  env->SetMethod(target, "getCharacterProperty", GetCharacterProperty);
+  env->SetMethod(target, "getColumnWidth", GetColumnWidth);
 }
 
 }  // namespace i18n
diff --git a/src/util.h b/src/util.h
index eb99bb74e5d0de..355b9b091f68e4 100644
--- a/src/util.h
+++ b/src/util.h
@@ -320,6 +320,14 @@ class MaybeStackBuffer {
     buf_ = nullptr;
   }
 
+  bool IsAllocated() {
+    return buf_ != buf_st_;
+  }
+
+  void Release() {
+    buf_ = buf_st_;
+  }
+
   MaybeStackBuffer() : length_(0), buf_(buf_st_) {
     // Default to a zero-length, null-terminated buffer.
     buf_[0] = T();
@@ -355,6 +363,24 @@ class BufferValue : public MaybeStackBuffer<char> {
   explicit BufferValue(v8::Isolate* isolate, v8::Local<v8::Value> value);
 };
 
+#define THROW_AND_RETURN_UNLESS_BUFFER(env, obj)                              \
+  do {                                                                        \
+    if (!Buffer::HasInstance(obj))                                            \
+      return env->ThrowTypeError("argument should be a Buffer");              \
+  } while (0)
+
+#define SPREAD_ARG(val, name)                                                 \
+  CHECK((val)->IsUint8Array());                                               \
+  Local<v8::Uint8Array> name = (val).As<v8::Uint8Array>();                    \
+  v8::ArrayBuffer::Contents name##_c = name->Buffer()->GetContents();         \
+  const size_t name##_offset = name->ByteOffset();                            \
+  const size_t name##_length = name->ByteLength();                            \
+  char* const name##_data =                                                   \
+      static_cast<char*>(name##_c.Data()) + name##_offset;                    \
+  if (name##_length > 0)                                                      \
+    CHECK_NE(name##_data, nullptr);
+
+
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/test/parallel/test-icu.js b/test/parallel/test-icu.js
new file mode 100644
index 00000000000000..62f8b5a7903267
--- /dev/null
+++ b/test/parallel/test-icu.js
@@ -0,0 +1,123 @@
+'use strict';
+
+require('../common');
+const icu = require('icu');
+const assert = require('assert');
+
+const orig = Buffer.from('tést €', 'utf8');
+
+assert.strictEqual(orig.length, 9);
+assert.strictEqual(icu.utf8Length(orig), 6);
+
+assert.strictEqual(icu.charAt(orig, 1), 'é');
+assert.strictEqual(icu.codePointAt(orig, 1), 233);
+
+assert.strictEqual(icu.charAt(orig, 6), '€');
+assert.strictEqual(icu.charAt(orig, 7), '€');
+assert.strictEqual(icu.charAt(orig, 8), '€');
+assert.strictEqual(icu.charAt(orig, 9), undefined);
+assert.strictEqual(icu.codePointAt(orig, 6), 8364);
+assert.strictEqual(icu.codePointAt(orig, 7), 8364);
+assert.strictEqual(icu.codePointAt(orig, 8), 8364);
+assert.strictEqual(icu.codePointAt(orig, 9), undefined);
+
+
+var n;
+// Test Transcoding
+const tests = {
+  'latin1': [0x74, 0xe9, 0x73, 0x74, 0x20, 0x3f],
+  'ascii': [0x74, 0x3f, 0x73, 0x74, 0x20, 0x3f],
+  'ucs2': [0x74, 0x00, 0xe9, 0x00, 0x73,
+           0x00, 0x74, 0x00, 0x20, 0x00,
+           0xac, 0x20]
+};
+
+for (const test in tests) {
+  const dest = icu.transcode(orig, 'utf8', test);
+  assert.strictEqual(dest.length, tests[test].length);
+  for (n = 0; n < tests[test].length; n++)
+    assert.strictEqual(dest[n], tests[test][n]);
+}
+
+// Test UTF8 Slicing. The slicing needs to be aware of UTF-8 encoding
+// boundaries so that the slice does not include UTF-8 partials.
+const slice = [0xc3, 0xa9, 0x73, 0x74, 0x20, 0xe2, 0x82, 0xac];
+
+{
+  const sliced = icu.slice(orig, 'utf8', 1, 6);
+  for (n = 0; n < slice.length; n++)
+    assert.strictEqual(slice[n], sliced[n]);
+}
+
+{
+  const sliced = icu.slice(orig, 'utf8', 1, 7);
+  for (n = 0; n < slice.length; n++)
+    assert.strictEqual(slice[n], sliced[n]);
+}
+
+{
+  const sliced = icu.slice(orig, 'utf8', 1, 8);
+  for (n = 0; n < slice.length; n++)
+    assert.strictEqual(slice[n], sliced[n]);
+}
+
+// Test UCS2 Slicing. The slicing needs to be aware of UTF16 encoding
+// boundaries so that the slice does not include UTF16 partials. Surrogate
+// pairs are not considered.
+{
+  const sliced = icu.slice(Buffer.from('test', 'ucs2'), 'ucs2', 0, 2);
+  assert.strictEqual(sliced.length, 4);
+  assert.strictEqual(sliced[0], 0x74);
+  assert.strictEqual(sliced[1], 0x00);
+  assert.strictEqual(sliced[2], 0x65);
+  assert.strictEqual(sliced[3], 0x00);
+}
+
+// Test Buffer Normalization
+{
+  const buf = icu.normalize(Buffer.from('\u1E9B\u0323', 'utf8'), 'nfc');
+  assert.strictEqual(buf.length, 5);
+  const res = [0xe1, 0xba, 0x9b, 0xcc, 0xa3];
+  for (n = 0; n < buf.length; n++)
+    assert.strictEqual(res[n], buf[n]);
+}
+
+{
+  const buf = icu.normalize(Buffer.from('\u1E9B\u0323', 'utf8'), 'nfd');
+  assert.strictEqual(buf.length, 6);
+  const res = [0xc5, 0xbf, 0xcc, 0xa3, 0xcc, 0x87];
+  for (n = 0; n < buf.length; n++)
+    assert.strictEqual(res[n], buf[n]);
+}
+
+{
+  const buf = icu.normalize(Buffer.from('\u1E9B\u0323', 'utf8'), 'nfkd');
+  assert.strictEqual(buf.length, 5);
+  const res = [0x73, 0xcc, 0xa3, 0xcc, 0x87];
+  for (n = 0; n < buf.length; n++)
+    assert.strictEqual(res[n], buf[n]);
+}
+
+{
+  const buf = icu.normalize(Buffer.from('\u1E9B\u0323', 'utf8'), 'nfkc');
+  assert.strictEqual(buf.length, 3);
+  const res = [0xe1, 0xb9, 0xa9];
+  for (n = 0; n < buf.length; n++)
+    assert.strictEqual(res[n], buf[n]);
+}
+
+// Test column width
+{
+  assert.strictEqual(icu.getColumnWidth('a'), 1);
+  assert.strictEqual(icu.getColumnWidth('丁'), 2);
+  assert.strictEqual(icu.getColumnWidth('\ud83d\udc78\ud83c\udfff'), 2);
+  assert.strictEqual(icu.getColumnWidth('👅'), 2);
+  assert.strictEqual(icu.getColumnWidth('\n'), 0);
+  assert.strictEqual(icu.getColumnWidth('\u200Ef\u200F'), 1);
+  // Control chars and combining chars are zero
+  assert.strictEqual(icu.getColumnWidth('\u200E\n\u220A\u20D2'), 1);
+
+  // By default, ambiguous width codepoints are 1 column width
+  assert.strictEqual(icu.getColumnWidth('■'), 1);
+  assert.strictEqual(icu.getColumnWidth('■', true), 2);
+}
diff --git a/tools/icu/icu-generic.gyp b/tools/icu/icu-generic.gyp
index ecbf6d18c24ee3..ca79bd3c76b103 100644
--- a/tools/icu/icu-generic.gyp
+++ b/tools/icu/icu-generic.gyp
@@ -21,7 +21,7 @@
       'toolsets': [ 'target' ],
       'direct_dependent_settings': {
         'defines': [
-          'UCONFIG_NO_CONVERSION=1',
+          #'UCONFIG_NO_CONVERSION=1',
         ]
       },
     },
@@ -417,10 +417,10 @@
         [ 'icu_ver_major == 55', { 'sources!': [
 
           # bidi- not needed (yet!)
-          '<(icu_path)/source/common/ubidi.c',
-          '<(icu_path)/source/common/ubidiimp.h',
-          '<(icu_path)/source/common/ubidiln.c',
-          '<(icu_path)/source/common/ubidiwrt.c',
+          #'<(icu_path)/source/common/ubidi.c',
+          #'<(icu_path)/source/common/ubidiimp.h',
+          #'<(icu_path)/source/common/ubidiln.c',
+          #'<(icu_path)/source/common/ubidiwrt.c',
           #'<(icu_path)/source/common/ubidi_props.c',
           #'<(icu_path)/source/common/ubidi_props.h',
           #'<(icu_path)/source/common/ubidi_props_data.h',
@@ -433,10 +433,10 @@
           '<(icu_path)/source/common/cstr.cpp',
 
           # bidi- not needed (yet!)
-          '<(icu_path)/source/common/ubidi.c',
-          '<(icu_path)/source/common/ubidiimp.h',
-          '<(icu_path)/source/common/ubidiln.c',
-          '<(icu_path)/source/common/ubidiwrt.c',
+          #'<(icu_path)/source/common/ubidi.c',
+          #'<(icu_path)/source/common/ubidiimp.h',
+          #'<(icu_path)/source/common/ubidiln.c',
+          #'<(icu_path)/source/common/ubidiwrt.c',
           #'<(icu_path)/source/common/ubidi_props.c',
           #'<(icu_path)/source/common/ubidi_props.h',
           #'<(icu_path)/source/common/ubidi_props_data.h',