@ensdomains/ensjs 3.0.0-alpha.5 → 3.0.0-alpha.50

package/dist/cjs/utils/fuses.js

@@ -1,24 +1,302 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.testable = void 0;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fuses_exports = {};
+__export(fuses_exports, {
+  CHILD_CONTROLLED_FUSES: () => CHILD_CONTROLLED_FUSES,
+  PARENT_CONTROLLED_FUSES: () => PARENT_CONTROLLED_FUSES,
+  USER_SETTABLE_FUSES: () => USER_SETTABLE_FUSES,
+  checkPCCBurned: () => checkPCCBurned,
+  childFuseEnum: () => childFuseEnum,
+  childFuseKeys: () => childFuseKeys,
+  decodeFuses: () => decodeFuses,
+  default: () => fuses_default,
+  encodeFuses: () => encodeFuses,
+  fullFuseEnum: () => fullFuseEnum,
+  fullParentFuseEnum: () => fullParentFuseEnum,
+  fullParentFuseKeys: () => fullParentFuseKeys,
+  hasFuses: () => hasFuses,
+  parentFuseEnum: () => parentFuseEnum,
+  parentFuseKeys: () => parentFuseKeys,
+  unnamedChildFuses: () => unnamedChildFuses,
+  unnamedParentFuses: () => unnamedParentFuses,
+  unnamedUserSettableFuses: () => unnamedUserSettableFuses,
+  userSettableFuseEnum: () => userSettableFuseEnum,
+  userSettableFuseKeys: () => userSettableFuseKeys
+});
+module.exports = __toCommonJS(fuses_exports);
 const CANNOT_UNWRAP = 1;
 const CANNOT_BURN_FUSES = 2;
 const CANNOT_TRANSFER = 4;
 const CANNOT_SET_RESOLVER = 8;
 const CANNOT_SET_TTL = 16;
 const CANNOT_CREATE_SUBDOMAIN = 32;
-const PARENT_CANNOT_CONTROL = 64;
+const PARENT_CANNOT_CONTROL = 65536;
+const IS_DOT_ETH = 131072;
+const CAN_EXTEND_EXPIRY = 262144;
+const CHILD_CONTROLLED_FUSES = 65535;
+const PARENT_CONTROLLED_FUSES = 4294901760;
+const USER_SETTABLE_FUSES = 4294836223;
 const CAN_DO_EVERYTHING = 0;
-exports.testable = {
-    CANNOT_UNWRAP,
-    CANNOT_BURN_FUSES,
-    CANNOT_TRANSFER,
-    CANNOT_SET_RESOLVER,
-    CANNOT_SET_TTL,
-    CANNOT_CREATE_SUBDOMAIN,
-    PARENT_CANNOT_CONTROL,
-};
-exports.default = {
-    ...exports.testable,
-    CAN_DO_EVERYTHING,
+const childFuseEnum = {
+  CANNOT_UNWRAP,
+  CANNOT_BURN_FUSES,
+  CANNOT_TRANSFER,
+  CANNOT_SET_RESOLVER,
+  CANNOT_SET_TTL,
+  CANNOT_CREATE_SUBDOMAIN
+};
+const parentFuseEnum = {
+  PARENT_CANNOT_CONTROL,
+  CAN_EXTEND_EXPIRY
+};
+const fullParentFuseEnum = {
+  ...parentFuseEnum,
+  IS_DOT_ETH
+};
+const userSettableFuseEnum = {
+  ...childFuseEnum,
+  ...parentFuseEnum
+};
+const fullFuseEnum = {
+  ...userSettableFuseEnum,
+  ...fullParentFuseEnum,
+  CAN_DO_EVERYTHING
+};
+const unnamedChildFuses = [
+  64,
+  128,
+  256,
+  512,
+  1024,
+  2048,
+  4096,
+  8192,
+  16384,
+  32768
+];
+const unnamedParentFuses = [
+  524288,
+  1048576,
+  2097152,
+  4194304,
+  8388608,
+  16777216,
+  33554432,
+  67108864,
+  134217728,
+  268435456,
+  536870912,
+  1073741824,
+  2147483648
+];
+const unnamedUserSettableFuses = [
+  ...unnamedChildFuses,
+  ...unnamedParentFuses
+];
+const childFuseKeys = Object.keys(
+  childFuseEnum
+);
+const parentFuseKeys = Object.keys(
+  parentFuseEnum
+);
+const fullParentFuseKeys = Object.keys(
+  fullParentFuseEnum
+);
+const userSettableFuseKeys = Object.keys(
+  userSettableFuseEnum
+);
+const checkNumber = (fuses) => {
+  if (fuses > 2 ** 32 || fuses < 1) {
+    throw new Error(
+      `Fuse number must be limited to uint32, ${fuses} was too ${fuses < 1 ? "low" : "high"}.`
+    );
+  } else if (fuses % 1 !== 0) {
+    throw new Error(`Fuse number must be an integer, ${fuses} was not.`);
+  } else if ((fuses & USER_SETTABLE_FUSES) !== fuses) {
+    throw new Error(
+      `Fuse number must be limited to user settable fuses, ${fuses} was not.`
+    );
+  }
+};
+const testFuses = (fuses) => {
+  if ("named" in fuses && fuses.named.length > 0) {
+    return true;
+  }
+  if ("unnamed" in fuses && fuses.unnamed.length > 0) {
+    return true;
+  }
+  if ("number" in fuses && fuses.number !== 0) {
+    return true;
+  }
+  return false;
+};
+const hasFuses = (fuses) => {
+  if (typeof fuses === "number") {
+    return fuses !== 0;
+  }
+  if (typeof fuses === "object") {
+    if ("child" in fuses && testFuses(fuses.child)) {
+      return true;
+    }
+    if ("parent" in fuses && testFuses(fuses.parent)) {
+      return true;
+    }
+    if (testFuses(fuses)) {
+      return true;
+    }
+  }
+  return false;
+};
+function encodeFuses(fuses, restrictTo) {
+  let encodedFuses = 0;
+  if (typeof fuses === "number") {
+    if (restrictTo) {
+      throw new Error("Cannot specify an exact fuse value when restricted.");
+    }
+    checkNumber(fuses);
+    encodedFuses = fuses;
+  } else {
+    let fusesRef = fuses;
+    let allowedNamed = [];
+    let allowedUnnamed = [];
+    let namedArray = [];
+    let unnamedArray = [];
+    if (restrictTo) {
+      if ("parent" in fuses || "child" in fuses) {
+        throw new Error("Can't specify fuse category when restricted.");
+      }
+      allowedNamed = restrictTo === "child" ? childFuseKeys : parentFuseKeys;
+      allowedUnnamed = restrictTo === "child" ? unnamedChildFuses : unnamedParentFuses;
+      fusesRef = { [restrictTo]: fuses };
+    } else {
+      allowedNamed = userSettableFuseKeys;
+      allowedUnnamed = unnamedUserSettableFuses;
+    }
+    if ("parent" in fusesRef) {
+      if ("named" in fusesRef.parent)
+        namedArray = fusesRef.parent.named;
+      if ("unnamed" in fusesRef.parent)
+        unnamedArray = fusesRef.parent.unnamed;
+      if ("number" in fusesRef.parent) {
+        if ("named" in fusesRef.parent || "unnamed" in fusesRef.parent) {
+          throw new Error(
+            "Cannot specify both a fuse number and named/unnamed fuses."
+          );
+        }
+        checkNumber(fusesRef.parent.number);
+        if ((fusesRef.parent.number & PARENT_CONTROLLED_FUSES) !== fusesRef.parent.number) {
+          throw new Error(
+            "Cannot specify a fuse value to set that is outside of the parent's control."
+          );
+        }
+        encodedFuses |= fusesRef.parent.number;
+      }
+    }
+    if ("child" in fusesRef) {
+      if ("named" in fusesRef.child)
+        namedArray = [...namedArray, ...fusesRef.child.named];
+      if ("unnamed" in fusesRef.child)
+        unnamedArray = [...unnamedArray, ...fusesRef.child.unnamed];
+      if ("number" in fusesRef.child) {
+        if ("named" in fusesRef.child || "unnamed" in fusesRef.child) {
+          throw new Error(
+            "Cannot specify both a fuse number and named/unnamed fuses."
+          );
+        }
+        checkNumber(fusesRef.child.number);
+        if ((fusesRef.child.number & CHILD_CONTROLLED_FUSES) !== fusesRef.child.number) {
+          throw new Error(
+            "Cannot specify a fuse value to set that is outside of the owner's control."
+          );
+        }
+        encodedFuses |= fusesRef.child.number;
+      }
+    }
+    if (!namedArray.length && !unnamedArray.length && !encodedFuses) {
+      throw new Error("Must specify at least one fuse.");
+    }
+    for (const fuse of namedArray) {
+      if (!allowedNamed.includes(fuse)) {
+        if (!userSettableFuseKeys.includes(fuse)) {
+          throw new Error(`${fuse} is not a valid named fuse.`);
+        }
+        throw new Error(`Fuse ${fuse} is not allowed for this operation.`);
+      }
+      encodedFuses |= userSettableFuseEnum[fuse];
+    }
+    for (const fuse of unnamedArray) {
+      if (!allowedUnnamed.includes(fuse)) {
+        if (!unnamedUserSettableFuses.includes(fuse)) {
+          throw new Error(
+            `${fuse} is not a valid unnamed fuse. If you are trying to set a named fuse, use the named property.`
+          );
+        }
+        throw new Error(`Fuse ${fuse} is not allowed for this operation.`);
+      }
+      encodedFuses |= fuse;
+    }
+  }
+  return encodedFuses;
+}
+const decodeNamedFuses = (fuses, arr) => {
+  const fuseObj = Object.fromEntries(
+    arr.map((fuse) => [
+      fuse,
+      (fuses & fullFuseEnum[fuse]) === fullFuseEnum[fuse]
+    ])
+  );
+  return fuseObj;
+};
+const decodeUnnamedFuses = (fuses, arr) => {
+  const fuseObj = Object.fromEntries(
+    arr.map((fuse) => [fuse, (fuses & fuse) === fuse])
+  );
+  return fuseObj;
+};
+const decodeFuses = (fuses) => {
+  const parentNamedFuses = decodeNamedFuses(
+    fuses,
+    fullParentFuseKeys
+  );
+  const parentUnnamedFuses = decodeUnnamedFuses(
+    fuses,
+    unnamedParentFuses
+  );
+  const childNamedFuses = decodeNamedFuses(
+    fuses,
+    childFuseKeys
+  );
+  const childUnnamedFuses = decodeUnnamedFuses(
+    fuses,
+    unnamedChildFuses
+  );
+  return {
+    parent: {
+      ...parentNamedFuses,
+      unnamed: parentUnnamedFuses
+    },
+    child: {
+      ...childNamedFuses,
+      CAN_DO_EVERYTHING: (fuses & CHILD_CONTROLLED_FUSES) === 0,
+      unnamed: childUnnamedFuses
+    }
+  };
 };
+const checkPCCBurned = (fuses) => (fuses & PARENT_CANNOT_CONTROL) === PARENT_CANNOT_CONTROL;
+var fuses_default = fullFuseEnum;

package/dist/cjs/utils/hexEncodedName.js

@@ -1,9 +1,33 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hexEncodeName = void 0;
-const dns_packet_1 = __importDefault(require("dns-packet"));
-const hexEncodeName = (name) => `0x${dns_packet_1.default.name.encode(name).toString('hex')}`;
-exports.hexEncodeName = hexEncodeName;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hexEncodedName_exports = {};
+__export(hexEncodedName_exports, {
+  hexDecodeName: () => hexDecodeName,
+  hexEncodeName: () => hexEncodeName
+});
+module.exports = __toCommonJS(hexEncodedName_exports);
+var import_dns_packet = __toESM(require("dns-packet"));
+const hexEncodeName = (name) => `0x${import_dns_packet.default.name.encode(name).toString("hex")}`;
+const hexDecodeName = (hex) => import_dns_packet.default.name.decode(Buffer.from(hex.slice(2), "hex")).toString();

package/dist/cjs/utils/labels.js

@@ -1,112 +1,134 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkLocalStorageSize = exports.truncateUndecryptedName = exports.decryptName = exports.checkIsDecrypted = exports.parseName = exports.encodeLabel = exports.checkLabel = exports.saveName = exports.saveLabel = exports.isEncodedLabelhash = exports.encodeLabelhash = exports.decodeLabelhash = exports.keccakFromString = exports.labelhash = void 0;
-const utils_1 = require("ethers/lib/utils");
-const format_1 = require("./format");
-const labelhash = (input) => (0, utils_1.solidityKeccak256)(['string'], [input]);
-exports.labelhash = labelhash;
-const keccakFromString = (input) => (0, exports.labelhash)(input);
-exports.keccakFromString = keccakFromString;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var labels_exports = {};
+__export(labels_exports, {
+  checkIsDecrypted: () => checkIsDecrypted,
+  checkLabel: () => checkLabel,
+  checkLocalStorageSize: () => checkLocalStorageSize,
+  decodeLabelhash: () => decodeLabelhash,
+  decryptName: () => decryptName,
+  encodeLabel: () => encodeLabel,
+  encodeLabelhash: () => encodeLabelhash,
+  getEncryptedLabelAmount: () => getEncryptedLabelAmount,
+  isEncodedLabelhash: () => isEncodedLabelhash,
+  keccakFromString: () => keccakFromString,
+  labelhash: () => labelhash,
+  parseName: () => parseName,
+  saveLabel: () => saveLabel,
+  saveName: () => saveName,
+  truncateUndecryptedName: () => truncateUndecryptedName
+});
+module.exports = __toCommonJS(labels_exports);
+var import_solidity = require("@ethersproject/solidity");
+var import_format = require("./format");
+const hasLocalStorage = typeof localStorage !== "undefined";
+const labelhash = (input) => (0, import_solidity.keccak256)(["string"], [input]);
+const keccakFromString = (input) => labelhash(input);
 function decodeLabelhash(hash) {
-    if (!(hash.startsWith('[') && hash.endsWith(']'))) {
-        throw Error('Expected encoded labelhash to start and end with square brackets');
-    }
-    if (hash.length !== 66) {
-        throw Error('Expected encoded labelhash to have a length of 66');
-    }
-    return `${hash.slice(1, -1)}`;
+  if (!(hash.startsWith("[") && hash.endsWith("]"))) {
+    throw Error(
+      "Expected encoded labelhash to start and end with square brackets"
+    );
+  }
+  if (hash.length !== 66) {
+    throw Error("Expected encoded labelhash to have a length of 66");
+  }
+  return `0x${hash.slice(1, -1)}`;
 }
-exports.decodeLabelhash = decodeLabelhash;
 function encodeLabelhash(hash) {
-    if (!hash.startsWith('0x')) {
-        throw new Error('Expected label hash to start with 0x');
-    }
-    if (hash.length !== 66) {
-        throw new Error('Expected label hash to have a length of 66');
-    }
-    return `[${hash.slice(2)}]`;
+  if (!hash.startsWith("0x")) {
+    throw new Error("Expected label hash to start with 0x");
+  }
+  if (hash.length !== 66) {
+    throw new Error("Expected label hash to have a length of 66");
+  }
+  return `[${hash.slice(2)}]`;
 }
-exports.encodeLabelhash = encodeLabelhash;
 function isEncodedLabelhash(hash) {
-    return hash.startsWith('[') && hash.endsWith(']') && hash.length === 66;
+  return hash.startsWith("[") && hash.endsWith("]") && hash.length === 66;
 }
-exports.isEncodedLabelhash = isEncodedLabelhash;
 function getLabels() {
-    return localStorage
-        ? JSON.parse(localStorage.getItem('ensjs:labels')) || {}
-        : {};
+  return hasLocalStorage ? JSON.parse(localStorage.getItem("ensjs:labels")) || {} : {};
 }
 function _saveLabel(hash, label) {
-    if (!localStorage)
-        return hash;
-    const labels = getLabels();
-    localStorage.setItem('ensjs:labels', JSON.stringify({
-        ...labels,
-        [hash]: label,
-    }));
+  if (!hasLocalStorage)
     return hash;
+  const labels = getLabels();
+  localStorage.setItem(
+    "ensjs:labels",
+    JSON.stringify({
+      ...labels,
+      [hash]: label
+    })
+  );
+  return hash;
 }
 function saveLabel(label) {
-    const hash = `${(0, exports.labelhash)(label.toLowerCase())}`;
-    return _saveLabel(hash, label);
+  const hash = `${labelhash(label.toLowerCase())}`;
+  return _saveLabel(hash, label);
 }
-exports.saveLabel = saveLabel;
 function saveName(name) {
-    const nameArray = name.split('.');
-    nameArray.forEach((label) => {
-        saveLabel(label);
-    });
+  const nameArray = name.split(".");
+  for (const label of nameArray) {
+    if (!isEncodedLabelhash(label)) {
+      saveLabel(label);
+    }
+  }
 }
-exports.saveName = saveName;
-// eslint-disable-next-line consistent-return
 function checkLabel(hash) {
-    const labels = getLabels();
-    if (isEncodedLabelhash(hash)) {
-        return labels[decodeLabelhash(hash)];
-    }
-    if (hash.startsWith('0x')) {
-        return labels[`${hash.slice(2)}`];
-    }
+  const labels = getLabels();
+  if (isEncodedLabelhash(hash)) {
+    return labels[decodeLabelhash(hash)] || hash;
+  }
+  return hash;
 }
-exports.checkLabel = checkLabel;
 function encodeLabel(label) {
-    try {
-        return encodeLabelhash(label);
-    }
-    catch {
-        return label;
-    }
+  try {
+    return encodeLabelhash(label);
+  } catch {
+    return label;
+  }
 }
-exports.encodeLabel = encodeLabel;
 function parseName(name) {
-    const nameArray = name.split('.');
-    return nameArray.map((label) => encodeLabel(label)).join('.');
+  const nameArray = name.split(".");
+  return nameArray.map((label) => encodeLabel(label)).join(".");
 }
-exports.parseName = parseName;
 function checkIsDecrypted(string) {
-    return !string?.includes('[');
+  return !(string == null ? void 0 : string.includes("["));
 }
-exports.checkIsDecrypted = checkIsDecrypted;
 function decryptName(name) {
-    return name
-        .split('.')
-        .map((label) => checkLabel(label) || label)
-        .join('.');
+  return name.split(".").map((label) => checkLabel(label)).join(".");
 }
-exports.decryptName = decryptName;
-const truncateUndecryptedName = (name) => (0, format_1.truncateFormat)(name);
-exports.truncateUndecryptedName = truncateUndecryptedName;
+const truncateUndecryptedName = (name) => (0, import_format.truncateFormat)(name);
 function checkLocalStorageSize() {
-    if (!localStorage)
-        return 'Empty (0 KB)';
-    let allStrings = '';
-    for (const key in window.localStorage) {
-        if (Object.prototype.hasOwnProperty.call(window.localStorage, key)) {
-            allStrings += window.localStorage[key];
-        }
+  if (!hasLocalStorage)
+    return "Empty (0 KB)";
+  let allStrings = "";
+  for (const key in window.localStorage) {
+    if (Object.prototype.hasOwnProperty.call(window.localStorage, key)) {
+      allStrings += window.localStorage[key];
     }
-    return allStrings
-        ? `${3 + (allStrings.length * 16) / (8 * 1024)} KB`
-        : 'Empty (0 KB)';
+  }
+  return allStrings ? `${3 + allStrings.length * 16 / (8 * 1024)} KB` : "Empty (0 KB)";
 }
-exports.checkLocalStorageSize = checkLocalStorageSize;
+const encodedLabelRegex = /\[[a-fA-F0-9]{64}\]/g;
+const getEncryptedLabelAmount = (name) => {
+  var _a;
+  return ((_a = name.match(encodedLabelRegex)) == null ? void 0 : _a.length) || 0;
+};

package/dist/cjs/utils/makeHashIndexes.js

@@ -1,8 +1,29 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeNamehashIndexes = exports.makeOtherIndexes = void 0;
-const normalise_1 = require("./normalise");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var makeHashIndexes_exports = {};
+__export(makeHashIndexes_exports, {
+  makeNamehashIndexes: () => makeNamehashIndexes,
+  makeOtherIndexes: () => makeOtherIndexes
+});
+module.exports = __toCommonJS(makeHashIndexes_exports);
+var import_normalise = require("./normalise");
 const makeOtherIndexes = (data, findStr) => Array.from(data.matchAll(findStr)).map((x) => x.index / 2 - 1);
-exports.makeOtherIndexes = makeOtherIndexes;
-const makeNamehashIndexes = (data, name) => Array.from(data.matchAll((0, normalise_1.namehash)(name).substring(2))).map((x) => x.index / 2 - 1);
-exports.makeNamehashIndexes = makeNamehashIndexes;
+const makeNamehashIndexes = (data, name) => Array.from(data.matchAll((0, import_normalise.namehash)(name).substring(2))).map(
+  (x) => x.index / 2 - 1
+);