@effect/sql-pg 4.0.0-rc.112 → 4.0.0-rc.114

package/dist/PgTypes.js

@@ -18,6 +18,9 @@
  */
 import * as Data from "effect/Data";
 import * as Result from "effect/Result";
+import * as IpInterface from "effect/unstable/net/IpInterface";
+import * as IpNetwork from "effect/unstable/net/IpNetwork";
+import * as NetAddress from "effect/unstable/net/NetAddress";
 /**
  * Failure returned when a value cannot be encoded or decoded for its OID.
  *
@@ -293,7 +296,7 @@ const elementToArray = /*#__PURE__*/new Map(/*#__PURE__*/Array.from(arrayToEleme
  * @category getters
  * @since 4.0.0
  */
-export const arrayOidFor = elementOid => elementToArray.get(elementOid);
+export const arrayOidFor = (elementOid, registry) => registry === undefined ? elementToArray.get(elementOid) : getRegistryState(registry).elementToArray.get(elementOid);
 // -----------------------------------------------------------------------------
 // calendar helpers
 // -----------------------------------------------------------------------------
@@ -533,112 +536,26 @@ const decodeNumeric = (bytes, offset, size) => {
 // -----------------------------------------------------------------------------
 const PGSQL_AF_INET = 2;
 const PGSQL_AF_INET6 = 3;
-const parseIPv4 = text => {
-  const parts = text.split(".");
-  if (parts.length !== 4) return undefined;
-  const bytes = new Uint8Array(4);
-  for (let i = 0; i < 4; i++) {
-    if (!/^\d{1,3}$/.test(parts[i])) return undefined;
-    const value = Number(parts[i]);
-    if (value > 255) return undefined;
-    bytes[i] = value;
-  }
-  return bytes;
-};
-const parseIPv6 = text => {
-  const halves = text.split("::");
-  if (halves.length > 2) return undefined;
-  const toGroups = part => part === "" ? [] : part.split(":");
-  const head = toGroups(halves[0]);
-  const tail = halves.length === 2 ? toGroups(halves[1]) : [];
-  const bytes = new Uint8Array(16);
-  const trailing = tail.length > 0 ? tail[tail.length - 1] : head.length > 0 ? head[head.length - 1] : "";
-  const embedded = trailing.includes(".") ? parseIPv4(trailing) : undefined;
-  if (trailing.includes(".") && embedded === undefined) return undefined;
-  if (embedded !== undefined) {
-    if (tail.length > 0) tail.pop();else head.pop();
-  }
-  const groupCount = embedded === undefined ? 8 : 6;
-  if (head.length + tail.length > groupCount) return undefined;
-  if (halves.length === 1 && head.length !== groupCount) return undefined;
-  const writeGroup = (group, offset) => {
-    if (!/^[0-9a-fA-F]{1,4}$/.test(group)) return false;
-    const value = Number.parseInt(group, 16);
-    bytes[offset] = value >> 8;
-    bytes[offset + 1] = value & 0xff;
-    return true;
-  };
-  for (let i = 0; i < head.length; i++) {
-    if (!writeGroup(head[i], i * 2)) return undefined;
-  }
-  for (let i = 0; i < tail.length; i++) {
-    if (!writeGroup(tail[i], (groupCount - tail.length + i) * 2)) return undefined;
-  }
-  if (embedded !== undefined) bytes.set(embedded, 12);
-  return bytes;
-};
-const formatIPv4 = (bytes, offset) => `${bytes[offset]}.${bytes[offset + 1]}.${bytes[offset + 2]}.${bytes[offset + 3]}`;
-const formatIPv6 = (bytes, offset) => {
-  let isV4Mapped = bytes[offset + 10] === 0xff && bytes[offset + 11] === 0xff;
-  for (let i = 0; isV4Mapped && i < 10; i++) isV4Mapped = bytes[offset + i] === 0;
-  if (isV4Mapped) return `::ffff:${formatIPv4(bytes, offset + 12)}`;
-  const groups = [];
-  for (let i = 0; i < 8; i++) groups.push(readUint16(bytes, offset + i * 2));
-  let bestStart = -1;
-  let bestLength = 0;
-  let start = -1;
-  for (let i = 0; i <= 8; i++) {
-    if (i < 8 && groups[i] === 0) {
-      if (start === -1) start = i;
-    } else if (start !== -1) {
-      if (i - start > bestLength) {
-        bestStart = start;
-        bestLength = i - start;
-      }
-      start = -1;
-    }
-  }
-  if (bestLength < 2) {
-    return groups.map(group => group.toString(16)).join(":");
-  }
-  const head = groups.slice(0, bestStart).map(group => group.toString(16)).join(":");
-  const tail = groups.slice(bestStart + bestLength).map(group => group.toString(16)).join(":");
-  return `${head}::${tail}`;
-};
-const hasHostBits = (bytes, offset, length, bits) => {
-  const wholeBytes = Math.floor(bits / 8);
-  const partialBits = bits % 8;
-  if (partialBits !== 0 && (bytes[offset + wholeBytes] & (1 << 8 - partialBits) - 1) !== 0) {
-    return true;
-  }
-  for (let index = wholeBytes + (partialBits === 0 ? 0 : 1); index < length; index++) {
-    if (bytes[offset + index] !== 0) return true;
-  }
-  return false;
-};
 const encodeInet = (value, isCidr) => {
-  const text = requireString(value, isCidr ? "cidr" : "inet");
-  const slash = text.lastIndexOf("/");
-  const address = slash === -1 ? text : text.slice(0, slash);
-  const v4 = parseIPv4(address);
-  const bytes = v4 ?? parseIPv6(address);
-  if (bytes === undefined) {
-    return fail(`Expected an IP address, received "${text}"`);
-  }
-  const fullBits = bytes.length * 8;
-  const bits = slash === -1 ? fullBits : Number(text.slice(slash + 1));
-  if (!Number.isInteger(bits) || bits < 0 || bits > fullBits) {
-    return fail(`Invalid netmask length in "${text}"`);
-  }
-  if (isCidr && hasHostBits(bytes, 0, bytes.length, bits)) {
-    return fail(`CIDR address has host bits set in "${text}"`);
+  const type = isCidr ? "cidr" : "inet";
+  const text = requireString(value, type);
+  const parsed = IpInterface.fromString(text);
+  if (Result.isFailure(parsed)) return fail(`Invalid ${type} value ${JSON.stringify(text)}: ${parsed.failure.message}`);
+  const address = parsed.success.address;
+  const bits = parsed.success.prefixLength;
+  if (isCidr) {
+    const network = IpNetwork.make(address, bits);
+    if (Result.isFailure(network)) {
+      return fail(`Invalid ${type} value ${JSON.stringify(text)}: ${network.failure.message}`);
+    }
   }
-  const result = new Uint8Array(4 + bytes.length);
-  result[0] = v4 === undefined ? PGSQL_AF_INET6 : PGSQL_AF_INET;
+  const octets = NetAddress.isIpv4Address(address) ? NetAddress.ipv4ToOctets(address) : NetAddress.ipv6ToOctets(address);
+  const result = new Uint8Array(4 + octets.length);
+  result[0] = NetAddress.isIpv4Address(address) ? PGSQL_AF_INET : PGSQL_AF_INET6;
   result[1] = bits;
   result[2] = isCidr ? 1 : 0;
-  result[3] = bytes.length;
-  result.set(bytes, 4);
+  result[3] = octets.length;
+  result.set(octets, 4);
   return result;
 };
 const decodeInet = (bytes, offset, size) => {
@@ -655,11 +572,14 @@ const decodeInet = (bytes, offset, size) => {
   }
   requireSize(size, 4 + addressSize, "inet");
   if (bits > addressSize * 8) return fail(`Invalid inet netmask length: ${bits}`);
-  if (isCidr && hasHostBits(bytes, offset + 4, addressSize, bits)) {
-    return fail("CIDR address has host bits set");
+  const addressBytes = bytes.slice(offset + 4, offset + 4 + addressSize);
+  const address = family === PGSQL_AF_INET ? NetAddress.ipv4FromBytesUnsafe(addressBytes) : NetAddress.ipv6FromBytesUnsafe(addressBytes);
+  if (isCidr) {
+    const network = IpNetwork.make(address, bits);
+    if (Result.isFailure(network)) return fail(network.failure.message);
+    return IpNetwork.format(network.success);
   }
-  const text = family === PGSQL_AF_INET ? formatIPv4(bytes, offset + 4) : formatIPv6(bytes, offset + 4);
-  return isCidr || bits !== addressSize * 8 ? `${text}/${bits}` : text;
+  return bits === addressSize * 8 ? NetAddress.formatIp(address) : IpInterface.format(IpInterface.makeUnsafe(address, bits));
 };
 // -----------------------------------------------------------------------------
 // uuid
@@ -762,6 +682,31 @@ const decodeUuid = (bytes, offset, size) => {
   const b15 = bytes[offset + 15];
   return String.fromCharCode(hexHigh[b0], hexLow[b0], hexHigh[b1], hexLow[b1], hexHigh[b2], hexLow[b2], hexHigh[b3], hexLow[b3], 45, hexHigh[b4], hexLow[b4], hexHigh[b5], hexLow[b5], 45, hexHigh[b6], hexLow[b6], hexHigh[b7], hexLow[b7], 45, hexHigh[b8], hexLow[b8], hexHigh[b9], hexLow[b9], 45, hexHigh[b10], hexLow[b10], hexHigh[b11], hexLow[b11], hexHigh[b12], hexLow[b12], hexHigh[b13], hexLow[b13], hexHigh[b14], hexLow[b14], hexHigh[b15], hexLow[b15]);
 };
+const toUnsafeCodec = codec => ({
+  encode(value) {
+    const encoded = codec.encode(value);
+    if (Result.isFailure(encoded)) throw encoded.failure;
+    return encoded.success;
+  },
+  decode(bytes) {
+    const decoded = codec.decode(bytes);
+    if (Result.isFailure(decoded)) throw decoded.failure;
+    return decoded.success;
+  },
+  ...(codec.write === undefined ? undefined : {
+    write(sink, value) {
+      const written = codec.write(sink, value);
+      if (Result.isFailure(written)) throw written.failure;
+    }
+  }),
+  ...(codec.read === undefined ? undefined : {
+    read(bytes, offset, size) {
+      const decoded = codec.read(bytes, offset, size);
+      if (Result.isFailure(decoded)) throw decoded.failure;
+      return decoded.success;
+    }
+  })
+});
 /** A codec whose `decode` is its `read` over the whole of its bytes. */
 const codecOf = (read, encode, write) => {
   const decode = bytes => read(bytes, 0, bytes.length);
@@ -954,7 +899,7 @@ const jsonbCodec = /*#__PURE__*/codecOf((bytes, offset, size) => {
   sink.uint8(1);
   sink.utf8(text);
 });
-const builtins = /*#__PURE__*/new Map([[OID.bool, /*#__PURE__*/codecOf((bytes, offset, size) => {
+const builtinScalars = /*#__PURE__*/new Map([[OID.bool, /*#__PURE__*/codecOf((bytes, offset, size) => {
   requireSize(size, 1, "bool");
   return bytes[offset] !== 0;
 }, value => {
@@ -1025,9 +970,8 @@ const builtins = /*#__PURE__*/new Map([[OID.bool, /*#__PURE__*/codecOf((bytes, o
   scratchView8.setBigInt64(0, timeValue(value));
   return takeScratch8();
 }, (sink, value) => sink.bigInt64(timeValue(value)))], [OID.numeric, /*#__PURE__*/codecOf(decodeNumeric, encodeNumeric)], [OID.text, utf8Codec], [OID.varchar, utf8Codec], [OID.bpchar, utf8Codec], [OID.name, utf8Codec], [OID.json, jsonCodec], [OID.jsonb, jsonbCodec], [OID.uuid, /*#__PURE__*/codecOf(decodeUuid, encodeUuid, writeUuid)], [OID.inet, /*#__PURE__*/codecOf(decodeInet, value => encodeInet(value, false))], [OID.cidr, /*#__PURE__*/codecOf(decodeInet, value => encodeInet(value, true))], [OID.date, dateCodec], [OID.timetz, timetzCodec], [OID.timestamp, timestampCodec], [OID.timestamptz, timestampCodec]]);
-for (const [arrayOid, elementOid] of arrayToElement) {
-  builtins.set(arrayOid, codecOf((bytes, offset, size) => decodeArray(bytes, offset, size, elementOid), value => encodeArray(value, elementOid), (sink, value) => writeArray(sink, value, elementOid)));
-}
+const makeArrayCodec = (elementOid, lookup) => codecOf((bytes, offset, size) => decodeArray(bytes, offset, size, elementOid, lookup), value => encodeArray(value, elementOid, lookup), (sink, value) => writeArray(sink, value, elementOid, lookup));
+const builtins = /*#__PURE__*/new Map(builtinScalars);
 /**
  * Built-ins with registered codecs layered over them, so `encode` and `decode`
  * resolve an OID with a single lookup.
@@ -1040,8 +984,49 @@ const codecs = /*#__PURE__*/new Map(builtins);
  */
 const tableSize = 4096;
 const table = /*#__PURE__*/new Array(tableSize);
-for (const [oid, codec] of codecs) table[oid] = codec;
 const lookup = oid => oid >= 0 && oid < tableSize ? table[oid] : codecs.get(oid);
+for (const [arrayOid, elementOid] of arrayToElement) {
+  const codec = /*#__PURE__*/makeArrayCodec(elementOid, lookup);
+  builtins.set(arrayOid, codec);
+  codecs.set(arrayOid, codec);
+}
+for (const [oid, codec] of codecs) table[oid] = codec;
+const registryStates = /*#__PURE__*/new WeakMap();
+const getRegistryState = registry => {
+  const state = registryStates.get(registry);
+  if (state === undefined) return fail("Invalid PgTypes Registry");
+  return state;
+};
+const registerInState = (state, oid, codec, options) => {
+  state.codecs.set(oid, toUnsafeCodec(codec));
+  if (options?.arrayOid !== undefined) {
+    state.elementToArray.set(oid, options.arrayOid);
+    state.codecs.set(options.arrayOid, makeArrayCodec(oid, state.lookup));
+  }
+};
+/**
+ * Creates a client-specific registry containing the built-in codecs.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const makeRegistry = () => {
+  const codecs = new Map(builtinScalars);
+  const state = {
+    codecs,
+    elementToArray: new Map(elementToArray),
+    lookup: oid => codecs.get(oid)
+  };
+  for (const [arrayOid, elementOid] of arrayToElement) {
+    codecs.set(arrayOid, makeArrayCodec(elementOid, state.lookup));
+  }
+  const registry = {
+    register: (oid, codec, options) => registerInState(state, oid, codec, options)
+  };
+  registryStates.set(registry, state);
+  return registry;
+};
+const lookupFor = registry => registry === undefined ? lookup : getRegistryState(registry).lookup;
 /**
  * Registers a binary codec for an OID the built-in catalogue does not cover,
  * or overrides a built-in one. Registered codecs take precedence.
@@ -1050,31 +1035,7 @@ const lookup = oid => oid >= 0 && oid < tableSize ? table[oid] : codecs.get(oid)
  * @since 4.0.0
  */
 export const register = (oid, codec) => {
-  const unsafe = {
-    encode(value) {
-      const encoded = codec.encode(value);
-      if (Result.isFailure(encoded)) throw encoded.failure;
-      return encoded.success;
-    },
-    decode(bytes) {
-      const decoded = codec.decode(bytes);
-      if (Result.isFailure(decoded)) throw decoded.failure;
-      return decoded.success;
-    },
-    ...(codec.write === undefined ? undefined : {
-      write(sink, value) {
-        const written = codec.write(sink, value);
-        if (Result.isFailure(written)) throw written.failure;
-      }
-    }),
-    ...(codec.read === undefined ? undefined : {
-      read(bytes, offset, size) {
-        const decoded = codec.read(bytes, offset, size);
-        if (Result.isFailure(decoded)) throw decoded.failure;
-        return decoded.success;
-      }
-    })
-  };
+  const unsafe = toUnsafeCodec(codec);
   codecs.set(oid, unsafe);
   if (oid >= 0 && oid < tableSize) table[oid] = unsafe;
 };
@@ -1092,7 +1053,7 @@ export const unregister = oid => {
 // -----------------------------------------------------------------------------
 // arrays
 // -----------------------------------------------------------------------------
-const encodeArray = (value, elementOid) => {
+const encodeArray = (value, elementOid, lookup) => {
   if (!Array.isArray(value)) {
     return fail("Expected an array");
   }
@@ -1143,7 +1104,7 @@ const encodeArray = (value, elementOid) => {
  * and written in place, so neither the elements nor the array itself needs an
  * array of bytes of its own.
  */
-const writeArray = (sink, value, elementOid) => {
+const writeArray = (sink, value, elementOid, lookup) => {
   if (!Array.isArray(value)) {
     return fail("Expected an array");
   }
@@ -1174,7 +1135,7 @@ const writeArray = (sink, value, elementOid) => {
       sink.int32(-1);
     } else {
       const token = sink.beginLength();
-      if (write === undefined) writeValue(sink, element, elementOid);else write(sink, element);
+      if (write === undefined) writeValue(sink, element, elementOid, lookup);else write(sink, element);
       sink.endLength(token);
     }
   }
@@ -1184,7 +1145,7 @@ const writeArray = (sink, value, elementOid) => {
  * where it can be, so a thousand elements cost a thousand reads rather than a
  * thousand lookups and a thousand views.
  */
-const decodeArray = (bytes, start, size, elementOid) => {
+const decodeArray = (bytes, start, size, elementOid, lookup) => {
   if (size < 12) return fail("Truncated array value");
   const dimensions = readInt32(bytes, start);
   const wireElementOid = readUint32(bytes, start + 8);
@@ -1225,18 +1186,15 @@ const decodeArray = (bytes, start, size, elementOid) => {
   return values;
 };
 /**
- * Builds a field reader for `PgProtocol.makeParser`, so a result's rows decode
- * as they are parsed rather than through a view per column.
+ * Creates a field reader for `PgProtocol.makeParser`.
+ *
+ * **Details**
  *
- * Every column is resolved once here rather than once per row, and a codec that
- * can read in place does; the rest are handed a view. SQL NULL reads as `null`,
- * and a column whose OID has no codec reads as a copy of its bytes.
+ * Codecs are resolved once per column. SQL `NULL` becomes `null`, and columns
+ * without a registered codec return a copy of their bytes. Text-format columns
+ * fail with `CodecError`.
  *
- * Only the binary format is supported, and a text column returns a
- * `CodecError` failure here rather than once per row. A successful result
- * contains the parser's internal throwing fast path; its failures are terminal
- * for that parser. The standalone `encode` and `decode` APIs remain typed
- * `Result` values.
+ * **Example** (Updating the reader after `RowDescription`)
  *
  * ```ts
  * import { PgProtocol, PgTypes } from "@effect/sql-pg"
@@ -1250,7 +1208,8 @@ const decodeArray = (bytes, start, size, elementOid) => {
  * @category decoding
  * @since 4.0.0
  */
-export const makeFieldReader = columns => result(() => {
+export const makeFieldReader = (columns, registry) => result(() => {
+  const lookup = lookupFor(registry);
   const codecs = columns.map((column, index) => {
     if (column.format !== 1) {
       return fail(`Only the binary format is supported, column ${index} has format ${column.format}`);
@@ -1268,45 +1227,75 @@ export const makeFieldReader = columns => result(() => {
 /**
  * Encodes a JavaScript value as the binary representation of the given OID.
  *
+ * **Details**
+ *
  * Returns a `CodecError` failure when the value has the wrong JavaScript type,
  * or when the OID is neither built in nor registered.
  *
  * @category encoding
  * @since 4.0.0
  */
-export const encode = (value, oid) => result(() => {
-  const codec = lookup(oid);
+export const encode = (value, oid, registry) => result(() => {
+  const codec = lookupFor(registry)(oid);
   if (codec === undefined) return fail(`No codec registered for OID ${oid}`);
   return codec.encode(value);
 });
 /**
  * Decodes the binary representation of the given OID.
  *
+ * **Details**
+ *
  * `format` must be `1`; the text format is not implemented. An OID that is
  * neither built in nor registered decodes to the raw bytes.
  *
  * @category decoding
  * @since 4.0.0
  */
-export const decode = (bytes, oid, format) => result(() => {
+export const decode = (bytes, oid, format, registry) => result(() => {
   if (format !== 1) {
     return fail(`Only the binary format is supported, received format ${format}`);
   }
-  const codec = lookup(oid);
+  const codec = lookupFor(registry)(oid);
   return codec === undefined ? bytes : codec.decode(bytes);
 });
+// -----------------------------------------------------------------------------
+// parameter constructors
+// -----------------------------------------------------------------------------
+/**
+ * The runtime type identifier for PostgreSQL parameters.
+ *
+ * @category type IDs
+ * @since 4.0.0
+ */
+export const ParameterTypeId = "~@effect/sql-pg/PgTypes/Parameter";
+/**
+ * Returns whether a value is a parameter created by this module.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+export const isParameter = value => typeof value === "object" && value !== null && value[ParameterTypeId] === ParameterTypeId;
 /**
  * Encodes a parameter for a `Bind` message. SQL NULL stays `null`.
  *
  * @category encoding
  * @since 4.0.0
  */
-export const encodeParameter = parameter => parameter.value === null ? Result.succeed(null) : encode(parameter.value, parameter.oid);
-const writeValue = (sink, value, oid) => {
+export const encodeParameter = (parameter, registry) => parameter.value === null ? Result.succeed(null) : encode(parameter.value, parameter.oid, registry);
+const writeValue = (sink, value, oid, lookup) => {
   const codec = lookup(oid);
   if (codec === undefined) return fail(`No codec registered for OID ${oid}`);
   if (codec.write === undefined) sink.raw(codec.encode(value));else codec.write(sink, value);
 };
+/**
+ * Returns whether a parameter uses the text format in a `Bind` message.
+ * Untyped parameters (OID `0`) use text so PostgreSQL can infer their type;
+ * typed parameters use the binary format.
+ *
+ * @category encoding
+ * @since 4.0.0
+ */
+export const isTextFormat = parameter => parameter.oid === 0;
 /**
  * Writes a parameter into a `Bind` frame, for `PgProtocol.makeBindEncoder`.
  * Codecs that can write their bytes in place do; the rest fall back to
@@ -1315,10 +1304,19 @@ const writeValue = (sink, value, oid) => {
  * @category encoding
  * @since 4.0.0
  */
-const writeParameterUnsafe = (sink, parameter) => parameter.value === null ? sink.sqlNull() : writeValue(sink, parameter.value, parameter.oid);
-export const writeParameter = (sink, parameter) => {
+const writeParameterUnsafe = (sink, parameter, lookup) => parameter.value === null ? sink.sqlNull()
+// An untyped parameter is the value's text representation; see
+// `isTextFormat`.
+: parameter.oid === 0 ? sink.utf8(String(parameter.value)) : writeValue(sink, parameter.value, parameter.oid, lookup);
+/**
+ * Writes a parameter into a `Bind` frame.
+ *
+ * @category encoding
+ * @since 4.0.0
+ */
+export const writeParameter = (sink, parameter, registry) => {
   try {
-    writeParameterUnsafe(sink, parameter);
+    writeParameterUnsafe(sink, parameter, lookupFor(registry));
     return Result.void;
   } catch (error) {
     if (error instanceof CodecError) return Result.fail(error);
@@ -1327,12 +1325,14 @@ export const writeParameter = (sink, parameter) => {
 };
 const valueWriterUnsafe = /*#__PURE__*/Symbol.for("@effect/sql-pg/PgProtocol/ValueWriter/unsafe");
 Object.defineProperty(writeParameter, valueWriterUnsafe, {
-  value: writeParameterUnsafe
+  value: (sink, parameter) => writeParameterUnsafe(sink, parameter, lookup)
 });
-const parameter = oid => value => ({
+const makeParameter = (oid, value) => ({
+  [ParameterTypeId]: ParameterTypeId,
   oid,
   value
 });
+const parameter = oid => value => makeParameter(oid, value);
 /**
  * A `bool` parameter.
  *
@@ -1501,14 +1501,11 @@ export const timestamptz = /*#__PURE__*/parameter(OID.timestamptz);
  * @category constructors
  * @since 4.0.0
  */
-export const array = (values, elementOid) => result(() => {
-  const arrayOid = elementToArray.get(elementOid);
+export const array = (values, elementOid, registry) => result(() => {
+  const arrayOid = arrayOidFor(elementOid, registry);
   if (arrayOid === undefined) {
     return fail(`No array type known for element OID ${elementOid}`);
   }
-  return {
-    oid: arrayOid,
-    value: values
-  };
+  return makeParameter(arrayOid, values);
 });
 //# sourceMappingURL=PgTypes.js.map