@polkadot/types-codec 6.12.2-10

package/utils/compareMap.cjs

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compareMap = compareMap;
+
+var _util = require("@polkadot/util");
+
+var _util2 = require("./util.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+function hasMismatch(a, b) {
+  return (0, _util.isUndefined)(a) || ((0, _util2.hasEq)(a) ? !a.eq(b) : a !== b);
+}
+
+function notEntry(value) {
+  return !Array.isArray(value) || value.length !== 2;
+}
+
+function compareMapArray(a, b) {
+  // equal number of entries and each entry in the array should match
+  return a.size === b.length && !b.some(e => notEntry(e) || hasMismatch(a.get(e[0]), e[1]));
+} // NOTE These are used internally and when comparing objects, expects that
+// when the second is an Map<string, Codec> that the first has to be as well
+
+
+function compareMap(a, b) {
+  if (Array.isArray(b)) {
+    return compareMapArray(a, b);
+  } else if (b instanceof Map) {
+    return compareMapArray(a, [...b.entries()]);
+  } else if ((0, _util.isObject)(b)) {
+    return compareMapArray(a, Object.entries(b));
+  }
+
+  return false;
+}

package/utils/compareMap.d.ts

@@ -0,0 +1 @@
+export declare function compareMap(a: Map<unknown, unknown>, b?: unknown): boolean;

package/utils/compareMap.js

@@ -0,0 +1,31 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { isObject, isUndefined } from '@polkadot/util';
+import { hasEq } from "./util.js";
+
+function hasMismatch(a, b) {
+  return isUndefined(a) || (hasEq(a) ? !a.eq(b) : a !== b);
+}
+
+function notEntry(value) {
+  return !Array.isArray(value) || value.length !== 2;
+}
+
+function compareMapArray(a, b) {
+  // equal number of entries and each entry in the array should match
+  return a.size === b.length && !b.some(e => notEntry(e) || hasMismatch(a.get(e[0]), e[1]));
+} // NOTE These are used internally and when comparing objects, expects that
+// when the second is an Map<string, Codec> that the first has to be as well
+
+
+export function compareMap(a, b) {
+  if (Array.isArray(b)) {
+    return compareMapArray(a, b);
+  } else if (b instanceof Map) {
+    return compareMapArray(a, [...b.entries()]);
+  } else if (isObject(b)) {
+    return compareMapArray(a, Object.entries(b));
+  }
+
+  return false;
+}

package/utils/compareSet.cjs

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compareSet = compareSet;
+
+var _util = require("@polkadot/util");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+function compareSetArray(a, b) {
+  // equal number of entries and each entry in the array should match
+  return a.size === b.length && !b.some(e => !a.has(e));
+} // NOTE These are used internally and when comparing objects, expects that
+// when the second is an Set<string, Codec> that the first has to be as well
+
+
+function compareSet(a, b) {
+  if (Array.isArray(b)) {
+    return compareSetArray(a, b);
+  } else if (b instanceof Set) {
+    return compareSetArray(a, [...b.values()]);
+  } else if ((0, _util.isObject)(b)) {
+    return compareSetArray(a, Object.values(b));
+  }
+
+  return false;
+}

package/utils/compareSet.d.ts

@@ -0,0 +1 @@
+export declare function compareSet(a: Set<unknown>, b?: unknown): boolean;

package/utils/compareSet.js

@@ -0,0 +1,22 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { isObject } from '@polkadot/util';
+
+function compareSetArray(a, b) {
+  // equal number of entries and each entry in the array should match
+  return a.size === b.length && !b.some(e => !a.has(e));
+} // NOTE These are used internally and when comparing objects, expects that
+// when the second is an Set<string, Codec> that the first has to be as well
+
+
+export function compareSet(a, b) {
+  if (Array.isArray(b)) {
+    return compareSetArray(a, b);
+  } else if (b instanceof Set) {
+    return compareSetArray(a, [...b.values()]);
+  } else if (isObject(b)) {
+    return compareSetArray(a, Object.values(b));
+  }
+
+  return false;
+}

package/utils/decodeU8a.cjs

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decodeU8a = decodeU8a;
+exports.decodeU8aVec = decodeU8aVec;
+
+var _util = require("@polkadot/util");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+function formatFailure(error, type, u8a, key) {
+  return `decodeU8a: failed at ${(0, _util.u8aToHex)(u8a)}…${key ? ` on ${key}` : ''}${type ? `: ${type}` : ''}:: ${error.message}`;
+}
+
+function getRawType(registry, Type) {
+  try {
+    return new Type(registry).toRawType();
+  } catch {
+    return null;
+  }
+}
+/**
+ * Given an u8a, and an array of Type constructors, decode the u8a against the
+ * types, and return an array of decoded values.
+ *
+ * @param u8a - The u8a to decode.
+ * @param result - The result array (will be returned with values pushed)
+ * @param types - The array of CodecClass to decode the U8a against.
+ */
+
+
+function decodeU8a(registry, u8a, types, withZip) {
+  const [Types, keys] = Array.isArray(types) ? [types, []] : [Object.values(types), Object.keys(types)];
+  const result = new Array(Types.length);
+  let offset = 0;
+
+  for (let i = 0; i < Types.length; i++) {
+    try {
+      const value = new Types[i](registry, u8a.subarray(offset));
+      offset += value.initialU8aLength || value.encodedLength;
+      result[i] = withZip ? [keys[i], value] : value;
+    } catch (error) {
+      throw new Error(formatFailure(error, getRawType(registry, Types[i]), u8a.subarray(offset, offset + 16), keys[i]));
+    }
+  }
+
+  return [result, offset];
+} // Split from decodeU8a since this is specialized to 1 instance ... yes duplication, but
+// since we have to do less checks (and these are intensive anyway), much faster
+
+
+function decodeU8aVec(registry, u8a, start, Type, count) {
+  const result = new Array(count);
+  let offset = start;
+
+  for (let i = 0; i < count; i++) {
+    try {
+      const value = new Type(registry, u8a.subarray(offset));
+      offset += value.initialU8aLength || value.encodedLength;
+      result[i] = value;
+    } catch (error) {
+      throw new Error(formatFailure(error, getRawType(registry, Type), u8a.subarray(offset, offset + 16)));
+    }
+  }
+
+  return [result, offset, offset - start];
+}

package/utils/decodeU8a.d.ts

@@ -0,0 +1,13 @@
+import type { Codec, CodecClass, CodecRegistry } from '../types';
+/**
+ * Given an u8a, and an array of Type constructors, decode the u8a against the
+ * types, and return an array of decoded values.
+ *
+ * @param u8a - The u8a to decode.
+ * @param result - The result array (will be returned with values pushed)
+ * @param types - The array of CodecClass to decode the U8a against.
+ */
+export declare function decodeU8a<T extends Codec = Codec, E = T>(registry: CodecRegistry, u8a: Uint8Array, types: CodecClass[] | {
+    [index: string]: CodecClass;
+}, withZip?: boolean): [E[], number];
+export declare function decodeU8aVec<T extends Codec = Codec>(registry: CodecRegistry, u8a: Uint8Array, start: number, Type: CodecClass<T>, count: number): [T[], number, number];

package/utils/decodeU8a.js

@@ -0,0 +1,60 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { u8aToHex } from '@polkadot/util';
+
+function formatFailure(error, type, u8a, key) {
+  return `decodeU8a: failed at ${u8aToHex(u8a)}…${key ? ` on ${key}` : ''}${type ? `: ${type}` : ''}:: ${error.message}`;
+}
+
+function getRawType(registry, Type) {
+  try {
+    return new Type(registry).toRawType();
+  } catch {
+    return null;
+  }
+}
+/**
+ * Given an u8a, and an array of Type constructors, decode the u8a against the
+ * types, and return an array of decoded values.
+ *
+ * @param u8a - The u8a to decode.
+ * @param result - The result array (will be returned with values pushed)
+ * @param types - The array of CodecClass to decode the U8a against.
+ */
+
+
+export function decodeU8a(registry, u8a, types, withZip) {
+  const [Types, keys] = Array.isArray(types) ? [types, []] : [Object.values(types), Object.keys(types)];
+  const result = new Array(Types.length);
+  let offset = 0;
+
+  for (let i = 0; i < Types.length; i++) {
+    try {
+      const value = new Types[i](registry, u8a.subarray(offset));
+      offset += value.initialU8aLength || value.encodedLength;
+      result[i] = withZip ? [keys[i], value] : value;
+    } catch (error) {
+      throw new Error(formatFailure(error, getRawType(registry, Types[i]), u8a.subarray(offset, offset + 16), keys[i]));
+    }
+  }
+
+  return [result, offset];
+} // Split from decodeU8a since this is specialized to 1 instance ... yes duplication, but
+// since we have to do less checks (and these are intensive anyway), much faster
+
+export function decodeU8aVec(registry, u8a, start, Type, count) {
+  const result = new Array(count);
+  let offset = start;
+
+  for (let i = 0; i < count; i++) {
+    try {
+      const value = new Type(registry, u8a.subarray(offset));
+      offset += value.initialU8aLength || value.encodedLength;
+      result[i] = value;
+    } catch (error) {
+      throw new Error(formatFailure(error, getRawType(registry, Type), u8a.subarray(offset, offset + 16)));
+    }
+  }
+
+  return [result, offset, offset - start];
+}

package/utils/index.cjs

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "compareArray", {
+  enumerable: true,
+  get: function () {
+    return _compareArray.compareArray;
+  }
+});
+Object.defineProperty(exports, "compareMap", {
+  enumerable: true,
+  get: function () {
+    return _compareMap.compareMap;
+  }
+});
+Object.defineProperty(exports, "compareSet", {
+  enumerable: true,
+  get: function () {
+    return _compareSet.compareSet;
+  }
+});
+Object.defineProperty(exports, "decodeU8a", {
+  enumerable: true,
+  get: function () {
+    return _decodeU8a.decodeU8a;
+  }
+});
+Object.defineProperty(exports, "decodeU8aVec", {
+  enumerable: true,
+  get: function () {
+    return _decodeU8a.decodeU8aVec;
+  }
+});
+Object.defineProperty(exports, "mapToTypeMap", {
+  enumerable: true,
+  get: function () {
+    return _mapToTypeMap.mapToTypeMap;
+  }
+});
+Object.defineProperty(exports, "sanitize", {
+  enumerable: true,
+  get: function () {
+    return _sanitize.sanitize;
+  }
+});
+Object.defineProperty(exports, "sortAsc", {
+  enumerable: true,
+  get: function () {
+    return _sortValues.sortAsc;
+  }
+});
+Object.defineProperty(exports, "sortMap", {
+  enumerable: true,
+  get: function () {
+    return _sortValues.sortMap;
+  }
+});
+Object.defineProperty(exports, "sortSet", {
+  enumerable: true,
+  get: function () {
+    return _sortValues.sortSet;
+  }
+});
+Object.defineProperty(exports, "typeToConstructor", {
+  enumerable: true,
+  get: function () {
+    return _typeToConstructor.typeToConstructor;
+  }
+});
+Object.defineProperty(exports, "typesToMap", {
+  enumerable: true,
+  get: function () {
+    return _typesToMap.typesToMap;
+  }
+});
+
+var _compareArray = require("./compareArray.cjs");
+
+var _compareMap = require("./compareMap.cjs");
+
+var _compareSet = require("./compareSet.cjs");
+
+var _decodeU8a = require("./decodeU8a.cjs");
+
+var _mapToTypeMap = require("./mapToTypeMap.cjs");
+
+var _typeToConstructor = require("./typeToConstructor.cjs");
+
+var _sanitize = require("./sanitize.cjs");
+
+var _sortValues = require("./sortValues.cjs");
+
+var _typesToMap = require("./typesToMap.cjs");

package/utils/index.d.ts

@@ -0,0 +1,9 @@
+export { compareArray } from './compareArray';
+export { compareMap } from './compareMap';
+export { compareSet } from './compareSet';
+export { decodeU8a, decodeU8aVec } from './decodeU8a';
+export { mapToTypeMap } from './mapToTypeMap';
+export { typeToConstructor } from './typeToConstructor';
+export { sanitize } from './sanitize';
+export { sortAsc, sortSet, sortMap } from './sortValues';
+export { typesToMap } from './typesToMap';

package/utils/index.js

@@ -0,0 +1,11 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export { compareArray } from "./compareArray.js";
+export { compareMap } from "./compareMap.js";
+export { compareSet } from "./compareSet.js";
+export { decodeU8a, decodeU8aVec } from "./decodeU8a.js";
+export { mapToTypeMap } from "./mapToTypeMap.js";
+export { typeToConstructor } from "./typeToConstructor.js";
+export { sanitize } from "./sanitize.js";
+export { sortAsc, sortSet, sortMap } from "./sortValues.js";
+export { typesToMap } from "./typesToMap.js";

package/utils/mapToTypeMap.cjs

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mapToTypeMap = mapToTypeMap;
+
+var _typeToConstructor = require("./typeToConstructor.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @description takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
+ */
+function mapToTypeMap(registry, input) {
+  const entries = Object.entries(input);
+  const output = {};
+
+  for (let i = 0; i < entries.length; i++) {
+    output[entries[i][0]] = (0, _typeToConstructor.typeToConstructor)(registry, entries[i][1]);
+  }
+
+  return output;
+}

package/utils/mapToTypeMap.d.ts

@@ -0,0 +1,5 @@
+import type { CodecClass, CodecRegistry } from '../types';
+/**
+ * @description takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
+ */
+export declare function mapToTypeMap(registry: CodecRegistry, input: Record<string, string | CodecClass>): Record<string, CodecClass>;

package/utils/mapToTypeMap.js

@@ -0,0 +1,17 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { typeToConstructor } from "./typeToConstructor.js";
+/**
+ * @description takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
+ */
+
+export function mapToTypeMap(registry, input) {
+  const entries = Object.entries(input);
+  const output = {};
+
+  for (let i = 0; i < entries.length; i++) {
+    output[entries[i][0]] = typeToConstructor(registry, entries[i][1]);
+  }
+
+  return output;
+}

package/utils/sanitize.cjs

@@ -0,0 +1,242 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.alias = alias;
+exports.cleanupCompact = cleanupCompact;
+exports.findClosing = findClosing;
+exports.flattenSingleTuple = flattenSingleTuple;
+exports.removeColons = removeColons;
+exports.removeExtensions = removeExtensions;
+exports.removeGenerics = removeGenerics;
+exports.removePairOf = removePairOf;
+exports.removeTraits = removeTraits;
+exports.removeWrap = removeWrap;
+exports.sanitize = sanitize;
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+const BOUNDED = ['BTreeMap', 'BTreeSet', 'HashMap', 'Vec'];
+const ALLOWED_BOXES = BOUNDED.concat(['Compact', 'DoNotConstruct', 'Int', 'Linkage', 'Range', 'RangeInclusive', 'Result', 'Option', 'UInt', 'WrapperOpaque']);
+const BOX_PRECEDING = ['<', '(', '[', '"', ',', ' ']; // start of vec, tuple, fixed array, part of struct def or in tuple
+
+const mappings = [// alias <T::InherentOfflineReport as InherentOfflineReport>::Inherent -> InherentOfflineReport
+alias('<T::InherentOfflineReport as InherentOfflineReport>::Inherent', 'InherentOfflineReport', false), alias('VecDeque<', 'Vec<', false), // <T::Balance as HasCompact>
+cleanupCompact(), // Change BoundedVec<Type, Size> to Vec<Type>
+removeExtensions('Bounded', true), // Change WeakVec<Type> to Vec<Type>
+removeExtensions('Weak', false), // Remove all the trait prefixes
+removeTraits(), // remove PairOf<T> -> (T, T)
+removePairOf(), // remove boxing, `Box<Proposal>` -> `Proposal`
+removeWrap('Box<'), // remove generics, `MisbehaviorReport<Hash, BlockNumber>` -> `MisbehaviorReport`
+removeGenerics(), // alias String -> Text (compat with jsonrpc methods)
+alias('String', 'Text'), // alias Vec<u8> -> Bytes
+alias('Vec<u8>', 'Bytes'), alias('&\\[u8\\]', 'Bytes'), alias("&'static\\[u8\\]", 'Bytes'), // alias RawAddress -> Address
+alias('RawAddress', 'Address'), // lookups, mapped to Address/AccountId as appropriate in runtime
+alias('Lookup::Source', 'LookupSource'), alias('Lookup::Target', 'LookupTarget'), // HACK duplication between contracts & primitives, however contracts prefixed with exec
+alias('exec::StorageKey', 'ContractStorageKey'), // flattens tuples with one value, `(AccountId)` -> `AccountId`
+flattenSingleTuple(), // converts ::Type to Type, <T as Trait<I>>::Proposal -> Proposal
+removeColons()]; // given a starting index, find the closing >
+
+function findClosing(value, start) {
+  let depth = 0;
+
+  for (let index = start; index < value.length; index++) {
+    if (value[index] === '>') {
+      if (!depth) {
+        return index;
+      }
+
+      depth--;
+    } else if (value[index] === '<') {
+      depth++;
+    }
+  }
+
+  throw new Error(`Unable to find closing matching <> on '${value}' (start ${start})`);
+}
+
+function alias(src, dest) {
+  let withChecks = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  const from = new RegExp(`(^${src}|${BOX_PRECEDING.map(box => `\\${box}${src}`).join('|')})`, 'g');
+
+  const to = src => {
+    from.lastIndex = 0;
+    return withChecks && BOX_PRECEDING.includes(src[0]) ? `${src[0]}${dest}` : dest;
+  };
+
+  return value => value.replace(from, to);
+}
+
+function cleanupCompact() {
+  return value => {
+    for (let index = 0; index < value.length; index++) {
+      if (value[index] === '<') {
+        const end = findClosing(value, index + 1) - 14;
+
+        if (value.substr(end, 14) === ' as HasCompact') {
+          value = `Compact<${value.substr(index + 1, end - index - 1)}>`;
+        }
+      }
+    }
+
+    return value;
+  };
+}
+
+function flattenSingleTuple() {
+  const from1 = /,\)/g;
+  const from2 = /\(([^,]+)\)/;
+  return value => {
+    from1.lastIndex = 0;
+    return value // tuples may have trailing commas, e.g. (u32, BlockNumber, )
+    .replace(from1, ')') // change (u32) -> u32
+    .replace(from2, '$1');
+  };
+}
+
+function replaceTagWith(value, matcher, replacer) {
+  let index = -1;
+
+  while (true) {
+    index = value.indexOf(matcher, index + 1);
+
+    if (index === -1) {
+      return value;
+    }
+
+    const start = index + matcher.length;
+    const end = findClosing(value, start);
+    value = `${value.substr(0, index)}${replacer(value.substr(start, end - start))}${value.substr(end + 1)}`;
+  }
+} // remove the Bounded* or Weak* wrappers
+
+
+function removeExtensions(type, isSized) {
+  return value => BOUNDED.reduce((value, tag) => replaceTagWith(value, `${type}${tag}<`, inner => {
+    const parts = inner.split(',').map(s => s.trim()).filter(s => s);
+
+    if (isSized) {
+      parts.pop();
+    }
+
+    return `${tag}<${parts.join(',')}>`;
+  }), value);
+}
+
+function removeColons() {
+  return function (value) {
+    let {
+      allowNamespaces
+    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    let index = 0;
+
+    while (index !== -1) {
+      index = value.indexOf('::');
+
+      if (index === 0) {
+        value = value.substr(2);
+      } else if (index !== -1) {
+        if (allowNamespaces) {
+          return value;
+        }
+
+        let start = index;
+
+        while (start !== -1 && !BOX_PRECEDING.includes(value[start])) {
+          start--;
+        }
+
+        value = `${value.substr(0, start + 1)}${value.substr(index + 2)}`;
+      }
+    }
+
+    return value;
+  };
+}
+
+function removeGenerics() {
+  return value => {
+    for (let index = 0; index < value.length; index++) {
+      if (value[index] === '<') {
+        // check against the allowed wrappers, be it Vec<..>, Option<...> ...
+        const box = ALLOWED_BOXES.find(box => {
+          const start = index - box.length;
+          return start >= 0 && value.substr(start, box.length) === box && ( // make sure it is stand-alone, i.e. don't catch ElectionResult<...> as Result<...>
+          start === 0 || BOX_PRECEDING.includes(value[start - 1]));
+        }); // we have not found anything, unwrap generic innards
+
+        if (!box) {
+          const end = findClosing(value, index + 1);
+          value = `${value.substr(0, index)}${value.substr(end + 1)}`;
+        }
+      }
+    }
+
+    return value;
+  };
+} // remove the PairOf wrappers
+
+
+function removePairOf() {
+  const replacer = inner => `(${inner},${inner})`;
+
+  return value => replaceTagWith(value, 'PairOf<', replacer);
+} // remove the type traits
+
+
+function removeTraits() {
+  const from1 = /\s/g;
+  const from2 = /(T|Self)::/g;
+  const from3 = /<(T|Self)asTrait>::/g;
+  const from4 = /<Tas[a-z]+::Trait>::/g;
+  const from5 = /<LookupasStaticLookup>/g;
+  const from6 = /::Type/g;
+  return value => {
+    from1.lastIndex = 0;
+    from2.lastIndex = 0;
+    from3.lastIndex = 0;
+    from4.lastIndex = 0;
+    from5.lastIndex = 0;
+    from6.lastIndex = 0;
+    return value // remove all whitespaces
+    .replace(from1, '') // anything `T::<type>` to end up as `<type>`
+    .replace(from2, '') // replace `<T as Trait>::` (whitespaces were removed above)
+    .replace(from3, '') // replace `<T as something::Trait>::` (whitespaces were removed above)
+    .replace(from4, '') // replace <Lookup as StaticLookup>
+    .replace(from5, 'Lookup') // replace `<...>::Type`
+    .replace(from6, '');
+  };
+} // remove wrapping values, i.e. Box<Proposal> -> Proposal
+
+
+function removeWrap(check) {
+  const replacer = inner => inner;
+
+  return value => replaceTagWith(value, check, replacer);
+}
+
+const sanitizeMap = new Map(); // eslint-disable-next-line @typescript-eslint/ban-types
+
+function sanitize(value, options) {
+  let result = value.toString();
+
+  if (!options) {
+    const memoized = sanitizeMap.get(result);
+
+    if (memoized) {
+      return memoized;
+    }
+  }
+
+  for (let i = 0; i < mappings.length; i++) {
+    result = mappings[i](result, options);
+  }
+
+  result = result.trim();
+
+  if (!options) {
+    sanitizeMap.set(value.toString(), result);
+  }
+
+  return result;
+}