tedious 6.4.0 → 6.6.2

package/lib/value-parser.js

@@ -1,20 +1,21 @@
 "use strict";
 
-const iconv = require('iconv-lite');
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
 
-const sprintf = require('sprintf-js').sprintf;
+var _metadataParser = require("./metadata-parser");
 
-const TYPE = require('./data-type').TYPE;
+var _dataType = require("./data-type");
 
-const guidParser = require('./guid-parser');
+var _iconvLite = _interopRequireDefault(require("iconv-lite"));
 
-const readPrecision = require('./metadata-parser').readPrecision;
+var _sprintfJs = require("sprintf-js");
 
-const readScale = require('./metadata-parser').readScale;
+var _guidParser = require("./guid-parser");
 
-const readCollation = require('./metadata-parser').readCollation;
-
-const convertLEBytesToString = require('./tracking-buffer/bigint').convertLEBytesToString;
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 const NULL = (1 << 16) - 1;
 const MAX = (1 << 16) - 1;
@@ -24,228 +25,402 @@ const PLP_NULL = Buffer.from([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]);
 const UNKNOWN_PLP_LEN = Buffer.from([0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]);
 const DEFAULT_ENCODING = 'utf8';
 
-function readTextPointerNull(parser, type, callback) {
-  if (type.hasTextPointerAndTimestamp) {
-    parser.readUInt8(textPointerLength => {
-      if (textPointerLength !== 0) {
-        // Appear to be dummy values, so consume and discard them.
-        parser.readBuffer(textPointerLength, () => {
-          parser.readBuffer(8, () => {
-            callback(undefined);
-          });
-        });
-      } else {
-        callback(true);
-      }
+function readTinyInt(parser, callback) {
+  parser.readUInt8(callback);
+}
+
+function readSmallInt(parser, callback) {
+  parser.readInt16LE(callback);
+}
+
+function readInt(parser, callback) {
+  parser.readInt32LE(callback);
+}
+
+function readBigInt(parser, callback) {
+  parser.readBigInt64LE(value => {
+    callback(value.toString());
+  });
+}
+
+function readReal(parser, callback) {
+  parser.readFloatLE(callback);
+}
+
+function readFloat(parser, callback) {
+  parser.readDoubleLE(callback);
+}
+
+function readSmallMoney(parser, callback) {
+  parser.readInt32LE(value => {
+    callback(value / MONEY_DIVISOR);
+  });
+}
+
+function readMoney(parser, callback) {
+  parser.readInt32LE(high => {
+    parser.readUInt32LE(low => {
+      callback((low + 0x100000000 * high) / MONEY_DIVISOR);
     });
-  } else {
-    callback(undefined);
-  }
+  });
 }
 
-function readDataLength(parser, type, metaData, textPointerNull, callback) {
-  if (textPointerNull) {
-    return callback(0);
-  }
+function readBit(parser, callback) {
+  parser.readUInt8(value => {
+    callback(!!value);
+  });
+}
+
+function valueParse(parser, metadata, options, callback) {
+  const type = metadata.type;
+
+  switch (type.name) {
+    case 'Null':
+      return callback(null);
+
+    case 'TinyInt':
+      return readTinyInt(parser, callback);
 
-  if (metaData.isVariantValue) {
-    return callback(metaData.dataLength);
-  } // s2.2.4.2.1
+    case 'SmallInt':
+      return readSmallInt(parser, callback);
 
+    case 'Int':
+      return readInt(parser, callback);
 
-  switch (type.id & 0x30) {
-    case 0x10:
-      // xx01xxxx - s2.2.4.2.1.1
-      return callback(0);
+    case 'BigInt':
+      return readBigInt(parser, callback);
 
-    case 0x20:
-      // xx10xxxx - s2.2.4.2.1.3
-      // Variable length
-      if (metaData.dataLength !== MAX) {
-        switch (type.dataLengthLength) {
+    case 'IntN':
+      return parser.readUInt8(dataLength => {
+        switch (dataLength) {
           case 0:
-            return callback(undefined);
+            return callback(null);
 
           case 1:
-            return parser.readUInt8(callback);
+            return readTinyInt(parser, callback);
 
           case 2:
-            return parser.readUInt16LE(callback);
+            return readSmallInt(parser, callback);
 
           case 4:
-            return parser.readUInt32LE(callback);
+            return readInt(parser, callback);
+
+          case 8:
+            return readBigInt(parser, callback);
 
           default:
-            return parser.emit('error', new Error('Unsupported dataLengthLength ' + type.dataLengthLength + ' for data type ' + type.name));
+            return parser.emit('error', new Error('Unsupported dataLength ' + dataLength + ' for IntN'));
         }
-      } else {
-        return callback(undefined);
-      }
+      });
 
-    case 0x30:
-      return callback(1 << ((type.id & 0x0C) >> 2));
-  }
-}
+    case 'Real':
+      return readReal(parser, callback);
 
-module.exports = valueParse;
+    case 'Float':
+      return readFloat(parser, callback);
 
-function valueParse(parser, metaData, options, callback) {
-  const type = metaData.type;
-  readTextPointerNull(parser, type, textPointerNull => {
-    readDataLength(parser, type, metaData, textPointerNull, dataLength => {
-      switch (type.name) {
-        case 'Null':
-          return callback(null);
+    case 'FloatN':
+      return parser.readUInt8(dataLength => {
+        switch (dataLength) {
+          case 0:
+            return callback(null);
 
-        case 'TinyInt':
-          return parser.readUInt8(callback);
+          case 4:
+            return readReal(parser, callback);
 
-        case 'Int':
-          return parser.readInt32LE(callback);
+          case 8:
+            return readFloat(parser, callback);
 
-        case 'SmallInt':
-          return parser.readInt16LE(callback);
+          default:
+            return parser.emit('error', new Error('Unsupported dataLength ' + dataLength + ' for FloatN'));
+        }
+      });
 
-        case 'BigInt':
-          return parser.readBuffer(8, buffer => {
-            callback(convertLEBytesToString(buffer));
-          });
+    case 'SmallMoney':
+      return readSmallMoney(parser, callback);
 
-        case 'IntN':
-          switch (dataLength) {
-            case 0:
-              return callback(null);
+    case 'Money':
+      return readMoney(parser, callback);
 
-            case 1:
-              return parser.readUInt8(callback);
+    case 'MoneyN':
+      return parser.readUInt8(dataLength => {
+        switch (dataLength) {
+          case 0:
+            return callback(null);
 
-            case 2:
-              return parser.readInt16LE(callback);
+          case 4:
+            return readSmallMoney(parser, callback);
 
-            case 4:
-              return parser.readInt32LE(callback);
+          case 8:
+            return readMoney(parser, callback);
 
-            case 8:
-              return parser.readBuffer(8, buffer => {
-                callback(convertLEBytesToString(buffer));
-              });
+          default:
+            return parser.emit('error', new Error('Unsupported dataLength ' + dataLength + ' for MoneyN'));
+        }
+      });
 
-            default:
-              return parser.emit('error', new Error('Unsupported dataLength ' + dataLength + ' for IntN'));
-          }
+    case 'Bit':
+      return readBit(parser, callback);
 
-        case 'Real':
-          return parser.readFloatLE(callback);
+    case 'BitN':
+      return parser.readUInt8(dataLength => {
+        switch (dataLength) {
+          case 0:
+            return callback(null);
 
-        case 'Float':
-          return parser.readDoubleLE(callback);
+          case 1:
+            return readBit(parser, callback);
 
-        case 'FloatN':
-          switch (dataLength) {
-            case 0:
-              return callback(null);
+          default:
+            return parser.emit('error', new Error('Unsupported dataLength ' + dataLength + ' for BitN'));
+        }
+      });
 
-            case 4:
-              return parser.readFloatLE(callback);
+    case 'VarChar':
+    case 'Char':
+      const codepage = metadata.collation.codepage;
 
-            case 8:
-              return parser.readDoubleLE(callback);
+      if (metadata.dataLength === MAX) {
+        return readMaxChars(parser, codepage, callback);
+      } else {
+        return parser.readUInt16LE(dataLength => {
+          if (dataLength === NULL) {
+            return callback(null);
+          }
+
+          readChars(parser, dataLength, codepage, callback);
+        });
+      }
 
-            default:
-              return parser.emit('error', new Error('Unsupported dataLength ' + dataLength + ' for FloatN'));
+    case 'NVarChar':
+    case 'NChar':
+      if (metadata.dataLength === MAX) {
+        return readMaxNChars(parser, callback);
+      } else {
+        return parser.readUInt16LE(dataLength => {
+          if (dataLength === NULL) {
+            return callback(null);
           }
 
-        case 'Money':
-        case 'SmallMoney':
-        case 'MoneyN':
-          switch (dataLength) {
-            case 0:
-              return callback(null);
-
-            case 4:
-              return parser.readInt32LE(value => {
-                callback(value / MONEY_DIVISOR);
-              });
-
-            case 8:
-              return parser.readInt32LE(high => {
-                parser.readUInt32LE(low => {
-                  callback((low + 0x100000000 * high) / MONEY_DIVISOR);
-                });
-              });
-
-            default:
-              return parser.emit('error', new Error('Unsupported dataLength ' + dataLength + ' for MoneyN'));
+          readNChars(parser, dataLength, callback);
+        });
+      }
+
+    case 'VarBinary':
+    case 'Binary':
+      if (metadata.dataLength === MAX) {
+        return readMaxBinary(parser, callback);
+      } else {
+        return parser.readUInt16LE(dataLength => {
+          if (dataLength === NULL) {
+            return callback(null);
           }
 
-        case 'Bit':
-          return parser.readUInt8(value => {
-            callback(!!value);
+          readBinary(parser, dataLength, callback);
+        });
+      }
+
+    case 'Text':
+      return parser.readUInt8(textPointerLength => {
+        if (textPointerLength === 0) {
+          return callback(null);
+        }
+
+        parser.readBuffer(textPointerLength, _textPointer => {
+          parser.readBuffer(8, _timestamp => {
+            parser.readUInt32LE(dataLength => {
+              readChars(parser, dataLength, metadata.collation.codepage, callback);
+            });
           });
+        });
+      });
 
-        case 'BitN':
-          switch (dataLength) {
-            case 0:
-              return callback(null);
+    case 'NText':
+      return parser.readUInt8(textPointerLength => {
+        if (textPointerLength === 0) {
+          return callback(null);
+        }
 
-            case 1:
-              return parser.readUInt8(value => {
-                callback(!!value);
-              });
+        parser.readBuffer(textPointerLength, _textPointer => {
+          parser.readBuffer(8, _timestamp => {
+            parser.readUInt32LE(dataLength => {
+              readNChars(parser, dataLength, callback);
+            });
+          });
+        });
+      });
 
-            default:
-              return parser.emit('error', new Error('Unsupported dataLength ' + dataLength + ' for BitN'));
-          }
+    case 'Image':
+      return parser.readUInt8(textPointerLength => {
+        if (textPointerLength === 0) {
+          return callback(null);
+        }
 
-        case 'VarChar':
-        case 'Char':
-          const codepage = metaData.collation.codepage;
+        parser.readBuffer(textPointerLength, _textPointer => {
+          parser.readBuffer(8, _timestamp => {
+            parser.readUInt32LE(dataLength => {
+              readBinary(parser, dataLength, callback);
+            });
+          });
+        });
+      });
 
-          if (metaData.dataLength === MAX) {
-            return readMaxChars(parser, codepage, callback);
-          } else {
-            return readChars(parser, dataLength, codepage, NULL, callback);
-          }
+    case 'Xml':
+      return readMaxNChars(parser, callback);
 
-        case 'NVarChar':
-        case 'NChar':
-          if (metaData.dataLength === MAX) {
-            return readMaxNChars(parser, callback);
-          } else {
-            return readNChars(parser, dataLength, NULL, callback);
-          }
+    case 'SmallDateTime':
+      return readSmallDateTime(parser, options.useUTC, callback);
 
-        case 'VarBinary':
-        case 'Binary':
-          if (metaData.dataLength === MAX) {
-            return readMaxBinary(parser, callback);
-          } else {
-            return readBinary(parser, dataLength, NULL, callback);
-          }
+    case 'DateTime':
+      return readDateTime(parser, options.useUTC, callback);
 
-        case 'Text':
-          if (textPointerNull) {
+    case 'DateTimeN':
+      return parser.readUInt8(dataLength => {
+        switch (dataLength) {
+          case 0:
             return callback(null);
-          } else {
-            return readChars(parser, dataLength, metaData.collation.codepage, PLP_NULL, callback);
-          }
 
-        case 'NText':
-          if (textPointerNull) {
-            return callback(null);
-          } else {
-            return readNChars(parser, dataLength, PLP_NULL, callback);
-          }
+          case 4:
+            return readSmallDateTime(parser, options.useUTC, callback);
+
+          case 8:
+            return readDateTime(parser, options.useUTC, callback);
 
-        case 'Image':
-          if (textPointerNull) {
+          default:
+            return parser.emit('error', new Error('Unsupported dataLength ' + dataLength + ' for DateTimeN'));
+        }
+      });
+
+    case 'Time':
+      return parser.readUInt8(dataLength => {
+        if (dataLength === 0) {
+          return callback(null);
+        } else {
+          return readTime(parser, dataLength, metadata.scale, options.useUTC, callback);
+        }
+      });
+
+    case 'Date':
+      return parser.readUInt8(dataLength => {
+        if (dataLength === 0) {
+          return callback(null);
+        } else {
+          return readDate(parser, options.useUTC, callback);
+        }
+      });
+
+    case 'DateTime2':
+      return parser.readUInt8(dataLength => {
+        if (dataLength === 0) {
+          return callback(null);
+        } else {
+          return readDateTime2(parser, dataLength, metadata.scale, options.useUTC, callback);
+        }
+      });
+
+    case 'DateTimeOffset':
+      return parser.readUInt8(dataLength => {
+        if (dataLength === 0) {
+          return callback(null);
+        } else {
+          return readDateTimeOffset(parser, dataLength, metadata.scale, callback);
+        }
+      });
+
+    case 'NumericN':
+    case 'DecimalN':
+      return parser.readUInt8(dataLength => {
+        if (dataLength === 0) {
+          return callback(null);
+        } else {
+          return readNumeric(parser, dataLength, metadata.precision, metadata.scale, callback);
+        }
+      });
+
+    case 'UniqueIdentifier':
+      return parser.readUInt8(dataLength => {
+        switch (dataLength) {
+          case 0:
             return callback(null);
-          } else {
-            return readBinary(parser, dataLength, PLP_NULL, callback);
-          }
 
-        case 'Xml':
-          return readMaxNChars(parser, callback);
+          case 0x10:
+            return readUniqueIdentifier(parser, options, callback);
+
+          default:
+            return parser.emit('error', new Error((0, _sprintfJs.sprintf)('Unsupported guid size %d', dataLength - 1)));
+        }
+      });
+
+    case 'UDT':
+      return readMaxBinary(parser, callback);
+
+    case 'Variant':
+      return parser.readUInt32LE(dataLength => {
+        if (dataLength === 0) {
+          return callback(null);
+        }
+
+        readVariant(parser, options, dataLength, callback);
+      });
+
+    default:
+      parser.emit('error', new Error((0, _sprintfJs.sprintf)('Unrecognised type %s', type.name)));
+  }
+}
+
+function readUniqueIdentifier(parser, options, callback) {
+  parser.readBuffer(0x10, data => {
+    callback(options.lowerCaseGuids ? (0, _guidParser.bufferToLowerCaseGuid)(data) : (0, _guidParser.bufferToUpperCaseGuid)(data));
+  });
+}
+
+function readNumeric(parser, dataLength, _precision, scale, callback) {
+  parser.readUInt8(sign => {
+    sign = sign === 1 ? 1 : -1;
+    let readValue;
+
+    if (dataLength === 5) {
+      readValue = parser.readUInt32LE;
+    } else if (dataLength === 9) {
+      readValue = parser.readUNumeric64LE;
+    } else if (dataLength === 13) {
+      readValue = parser.readUNumeric96LE;
+    } else if (dataLength === 17) {
+      readValue = parser.readUNumeric128LE;
+    } else {
+      return parser.emit('error', new Error((0, _sprintfJs.sprintf)('Unsupported numeric dataLength %d', dataLength)));
+    }
+
+    readValue.call(parser, value => {
+      callback(value * sign / Math.pow(10, scale));
+    });
+  });
+}
+
+function readVariant(parser, options, dataLength, callback) {
+  return parser.readUInt8(baseType => {
+    const type = _dataType.TYPE[baseType];
+    return parser.readUInt8(propBytes => {
+      dataLength = dataLength - propBytes - 2;
+
+      switch (type.name) {
+        case 'UniqueIdentifier':
+          return readUniqueIdentifier(parser, options, callback);
+
+        case 'Bit':
+          return readBit(parser, callback);
+
+        case 'TinyInt':
+          return readTinyInt(parser, callback);
+
+        case 'SmallInt':
+          return readSmallInt(parser, callback);
+
+        case 'Int':
+          return readInt(parser, callback);
+
+        case 'BigInt':
+          return readBigInt(parser, callback);
 
         case 'SmallDateTime':
           return readSmallDateTime(parser, options.useUTC, callback);
@@ -253,174 +428,91 @@ function valueParse(parser, metaData, options, callback) {
         case 'DateTime':
           return readDateTime(parser, options.useUTC, callback);
 
-        case 'DateTimeN':
-          switch (dataLength) {
-            case 0:
-              return callback(null);
-
-            case 4:
-              return readSmallDateTime(parser, options.useUTC, callback);
+        case 'Real':
+          return readReal(parser, callback);
 
-            case 8:
-              return readDateTime(parser, options.useUTC, callback);
+        case 'Float':
+          return readFloat(parser, callback);
 
-            default:
-              return parser.emit('error', new Error('Unsupported dataLength ' + dataLength + ' for DateTimeN'));
-          }
+        case 'SmallMoney':
+          return readSmallMoney(parser, callback);
 
-        case 'Time':
-          if (dataLength === 0) {
-            return callback(null);
-          } else {
-            return readTime(parser, dataLength, metaData.scale, options.useUTC, callback);
-          }
+        case 'Money':
+          return readMoney(parser, callback);
 
         case 'Date':
-          if (dataLength === 0) {
-            return callback(null);
-          } else {
-            return readDate(parser, options.useUTC, callback);
-          }
+          return readDate(parser, options.useUTC, callback);
+
+        case 'Time':
+          return parser.readUInt8(scale => {
+            return readTime(parser, dataLength, scale, options.useUTC, callback);
+          });
 
         case 'DateTime2':
-          if (dataLength === 0) {
-            return callback(null);
-          } else {
-            return readDateTime2(parser, dataLength, metaData.scale, options.useUTC, callback);
-          }
+          return parser.readUInt8(scale => {
+            return readDateTime2(parser, dataLength, scale, options.useUTC, callback);
+          });
 
         case 'DateTimeOffset':
-          if (dataLength === 0) {
-            return callback(null);
-          } else {
-            return readDateTimeOffset(parser, dataLength, metaData.scale, callback);
-          }
+          return parser.readUInt8(scale => {
+            return readDateTimeOffset(parser, dataLength, scale, callback);
+          });
+
+        case 'VarBinary':
+        case 'Binary':
+          return parser.readUInt16LE(_maxLength => {
+            readBinary(parser, dataLength, callback);
+          });
 
         case 'NumericN':
         case 'DecimalN':
-          if (dataLength === 0) {
-            return callback(null);
-          } else {
-            return parser.readUInt8(sign => {
-              sign = sign === 1 ? 1 : -1;
-              let readValue;
-
-              switch (dataLength - 1) {
-                case 4:
-                  readValue = parser.readUInt32LE;
-                  break;
-
-                case 8:
-                  readValue = parser.readUNumeric64LE;
-                  break;
-
-                case 12:
-                  readValue = parser.readUNumeric96LE;
-                  break;
-
-                case 16:
-                  readValue = parser.readUNumeric128LE;
-                  break;
-
-                default:
-                  return parser.emit('error', new Error(sprintf('Unsupported numeric size %d', dataLength - 1)));
-              }
-
-              readValue.call(parser, value => {
-                callback(value * sign / Math.pow(10, metaData.scale));
-              });
+          return parser.readUInt8(precision => {
+            parser.readUInt8(scale => {
+              readNumeric(parser, dataLength, precision, scale, callback);
             });
-          }
-
-        case 'UniqueIdentifier':
-          switch (dataLength) {
-            case 0:
-              return callback(null);
-
-            case 0x10:
-              return parser.readBuffer(0x10, data => {
-                callback(options.lowerCaseGuids ? guidParser.arrayToLowerCaseGuid(data) : guidParser.arrayToUpperCaseGuid(data));
-              });
-
-            default:
-              return parser.emit('error', new Error(sprintf('Unsupported guid size %d', dataLength - 1)));
-          }
-
-        case 'UDT':
-          return readMaxBinary(parser, callback);
-
-        case 'Variant':
-          if (dataLength === 0) {
-            return callback(null);
-          }
+          });
 
-          const valueMetaData = metaData.valueMetaData = {};
-          Object.defineProperty(valueMetaData, 'isVariantValue', {
-            value: true
+        case 'VarChar':
+        case 'Char':
+          return parser.readUInt16LE(_maxLength => {
+            (0, _metadataParser.readCollation)(parser, collation => {
+              readChars(parser, dataLength, collation.codepage, callback);
+            });
           });
-          return parser.readUInt8(baseType => {
-            return parser.readUInt8(propBytes => {
-              valueMetaData.dataLength = dataLength - propBytes - 2;
-              valueMetaData.type = TYPE[baseType];
-              return readPrecision(parser, valueMetaData.type, precision => {
-                valueMetaData.precision = precision;
-                return readScale(parser, valueMetaData.type, scale => {
-                  valueMetaData.scale = scale;
-                  return readCollation(parser, valueMetaData.type, collation => {
-                    valueMetaData.collation = collation;
-
-                    if (baseType === 0xA5 || baseType === 0xAD || baseType === 0xA7 || baseType === 0xAF || baseType === 0xE7 || baseType === 0xEF) {
-                      return readDataLength(parser, valueMetaData.type, {}, null, maxDataLength => {
-                        // skip the 2-byte max length sent for BIGVARCHRTYPE, BIGCHARTYPE, NVARCHARTYPE, NCHARTYPE, BIGVARBINTYPE and BIGBINARYTYPE types
-                        // and parse based on the length of actual data
-                        return valueParse(parser, valueMetaData, options, callback);
-                      });
-                    } else {
-                      return valueParse(parser, valueMetaData, options, callback);
-                    }
-                  });
-                });
-              });
+
+        case 'NVarChar':
+        case 'NChar':
+          return parser.readUInt16LE(_maxLength => {
+            (0, _metadataParser.readCollation)(parser, _collation => {
+              readNChars(parser, dataLength, callback);
             });
           });
 
         default:
-          return parser.emit('error', new Error(sprintf('Unrecognised type %s', type.name)));
+          throw new Error('Invalid type!');
       }
     });
   });
 }
 
-function readBinary(parser, dataLength, nullValue, callback) {
-  if (dataLength === nullValue) {
-    return callback(null);
-  } else {
-    return parser.readBuffer(dataLength, callback);
-  }
+function readBinary(parser, dataLength, callback) {
+  return parser.readBuffer(dataLength, callback);
 }
 
-function readChars(parser, dataLength, codepage, nullValue, callback) {
+function readChars(parser, dataLength, codepage, callback) {
   if (codepage == null) {
     codepage = DEFAULT_ENCODING;
   }
 
-  if (dataLength === nullValue) {
-    return callback(null);
-  } else {
-    return parser.readBuffer(dataLength, data => {
-      callback(iconv.decode(data, codepage));
-    });
-  }
+  return parser.readBuffer(dataLength, data => {
+    callback(_iconvLite.default.decode(data, codepage));
+  });
 }
 
-function readNChars(parser, dataLength, nullValue, callback) {
-  if (dataLength === nullValue) {
-    return callback(null);
-  } else {
-    return parser.readBuffer(dataLength, data => {
-      callback(data.toString('ucs2'));
-    });
-  }
+function readNChars(parser, dataLength, callback) {
+  parser.readBuffer(dataLength, data => {
+    callback(data.toString('ucs2'));
+  });
 }
 
 function readMaxBinary(parser, callback) {
@@ -434,7 +526,7 @@ function readMaxChars(parser, codepage, callback) {
 
   readMax(parser, data => {
     if (data) {
-      callback(iconv.decode(data, codepage));
+      callback(_iconvLite.default.decode(data, codepage));
     } else {
       callback(null);
     }
@@ -605,6 +697,7 @@ function readDate(parser, useUTC, callback) {
 
 function readDateTime2(parser, dataLength, scale, useUTC, callback) {
   readTime(parser, dataLength - 3, scale, useUTC, time => {
+    // TODO: 'input' is 'time', but TypeScript cannot find "time.nanosecondsDelta";
     parser.readUInt24LE(days => {
       let date;
 
@@ -637,4 +730,8 @@ function readDateTimeOffset(parser, dataLength, scale, callback) {
       });
     });
   });
-}
+}
+
+var _default = valueParse;
+exports.default = _default;
+module.exports = valueParse;