obsidian-dev-utils 66.0.1 → 68.0.0

package/dist/lib/cjs/script-utils/linters/eslint-rules/require-method-template.cjs

@@ -0,0 +1,222 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= name;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return '/';
+        },
+        env: {},
+        platform: 'android'
+      };
+      return browserProcess;
+    }
+  };
+
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+
+  function name(obj) {
+    return obj;
+  }
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  'obsidian',
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/lr',
+  '@lezer/highlight'];
+
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip'];
+
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+        return globalThis.process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+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 require_method_template_exports = {};
+__export(require_method_template_exports, {
+  MESSAGE_ID_MISSING_TEMPLATE: () => MESSAGE_ID_MISSING_TEMPLATE,
+  MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION: () => MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION,
+  requireMethodTemplate: () => requireMethodTemplate
+});
+module.exports = __toCommonJS(require_method_template_exports);
+var import_type_guards = require('../../../type-guards.cjs');
+const TAG_NAME = "typeParam";
+const MESSAGE_ID_MISSING_TEMPLATE = "missingTemplate";
+const MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION = "missingTemplateDescription";
+const requireMethodTemplate = {
+  create(context) {
+    const settings = context.settings["jsdoc"];
+    const preferredTagName = settings?.tagNamePreference?.["template"] ?? TAG_NAME;
+    return {
+      "MethodDefinition"(node) {
+        const methodNode = node;
+        const functionExpr = methodNode.value;
+        const typeParams = functionExpr.typeParameters?.params;
+        if (!typeParams || typeParams.length === 0) {
+          return;
+        }
+        const sourceCode = context.sourceCode;
+        const comments = sourceCode.getCommentsBefore(node);
+        const jsdocComment = findJsdocComment(comments);
+        if (!jsdocComment) {
+          return;
+        }
+        const parsedTags = parseTypeParamTags(jsdocComment.value, preferredTagName);
+        for (const typeParam of typeParams) {
+          const paramName = typeParam.name.name;
+          const matchingTag = parsedTags.find((tag) => tag.name === paramName);
+          if (!matchingTag) {
+            context.report({
+              data: {
+                paramName,
+                tagName: preferredTagName
+              },
+              messageId: MESSAGE_ID_MISSING_TEMPLATE,
+              node
+            });
+          } else if (!matchingTag.hasDescription) {
+            context.report({
+              data: {
+                paramName,
+                tagName: preferredTagName
+              },
+              messageId: MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION,
+              node
+            });
+          }
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Require `@typeParam` tags with descriptions for generic method type parameters"
+    },
+    messages: {
+      [MESSAGE_ID_MISSING_TEMPLATE]: "Missing @{{ tagName }} {{ paramName }}",
+      [MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION]: "@{{ tagName }} {{ paramName }} is missing a description"
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
+function findJsdocComment(comments) {
+  for (let i = comments.length - 1; i >= 0; i--) {
+    const comment = comments[i];
+    if (comment?.type === "Block" && comment.value.startsWith("*")) {
+      return comment;
+    }
+  }
+  return void 0;
+}
+function parseTypeParamTags(commentBody, tagName) {
+  const tags = [];
+  const tagPattern = new RegExp(`@(?:${tagName}|template|typeParam)\\s+(?<typeName>\\w+)(?<rest>.*)`, "g");
+  let match;
+  while ((match = tagPattern.exec(commentBody)) !== null) {
+    const groups = (0, import_type_guards.ensureNonNullable)(match.groups);
+    const name = (0, import_type_guards.ensureNonNullable)(groups["typeName"]);
+    const rest = (0, import_type_guards.ensureNonNullable)(groups["rest"]).trim();
+    const hasDescription = rest.length > 0 && rest !== "-";
+    tags.push({ hasDescription, name });
+  }
+  return tags;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MESSAGE_ID_MISSING_TEMPLATE,
+  MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION,
+  requireMethodTemplate
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../../src/script-utils/linters/eslint-rules/require-method-template.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: require-method-template\n *\n * Requires that generic methods (methods with type parameters) have\n * corresponding `@typeParam` (or `@template`) JSDoc tags for each type parameter.\n *\n * This fills a gap in `eslint-plugin-jsdoc`'s `require-template` rule, which\n * only checks top-level declarations (functions, classes, interfaces, type aliases)\n * but not methods within classes.\n *\n * @see {@link https://github.com/gajus/eslint-plugin-jsdoc/issues/1386}\n */\nimport type { TSESTree } from '@typescript-eslint/utils';\nimport type { Rule } from 'eslint';\nimport type { Comment } from 'estree';\n\nimport { ensureNonNullable } from '../../../type-guards.ts';\n\ninterface JsdocSettings {\n  tagNamePreference?: Record<string, string>;\n}\n\nconst TAG_NAME = 'typeParam';\n\nexport const MESSAGE_ID_MISSING_TEMPLATE = 'missingTemplate';\nexport const MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION = 'missingTemplateDescription';\n\nexport const requireMethodTemplate: Rule.RuleModule = {\n  create(context) {\n    const settings = context.settings['jsdoc'] as JsdocSettings | undefined;\n    const preferredTagName = settings?.tagNamePreference?.['template'] ?? TAG_NAME;\n\n    return {\n      'MethodDefinition'(node: Rule.Node): void {\n        const methodNode = node as TSESTree.MethodDefinition;\n        const functionExpr = methodNode.value;\n\n        const typeParams = functionExpr.typeParameters?.params;\n        if (!typeParams || typeParams.length === 0) {\n          return;\n        }\n\n        const sourceCode = context.sourceCode;\n        const comments = sourceCode.getCommentsBefore(node);\n        const jsdocComment = findJsdocComment(comments);\n\n        if (!jsdocComment) {\n          return;\n        }\n\n        const parsedTags = parseTypeParamTags(jsdocComment.value, preferredTagName);\n\n        for (const typeParam of typeParams) {\n          const paramName = typeParam.name.name;\n          const matchingTag = parsedTags.find((tag) => tag.name === paramName);\n\n          if (!matchingTag) {\n            context.report({\n              data: {\n                paramName,\n                tagName: preferredTagName\n              },\n              messageId: MESSAGE_ID_MISSING_TEMPLATE,\n              node\n            });\n          } else if (!matchingTag.hasDescription) {\n            context.report({\n              data: {\n                paramName,\n                tagName: preferredTagName\n              },\n              messageId: MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION,\n              node\n            });\n          }\n        }\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Require `@typeParam` tags with descriptions for generic method type parameters'\n    },\n    messages: {\n      [MESSAGE_ID_MISSING_TEMPLATE]: 'Missing @{{ tagName }} {{ paramName }}',\n      [MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION]: '@{{ tagName }} {{ paramName }} is missing a description'\n    },\n    schema: [],\n    type: 'suggestion'\n  }\n};\n\ninterface ParsedTag {\n  hasDescription: boolean;\n  name: string;\n}\n\n/**\n * Finds the JSDoc block comment from a list of comments.\n *\n * @param comments - The comments before the node.\n * @returns The JSDoc block comment, or `undefined` if none found.\n */\nfunction findJsdocComment(comments: readonly Comment[]): Comment | undefined {\n  for (let i = comments.length - 1; i >= 0; i--) {\n    const comment = comments[i];\n    if (comment?.type === 'Block' && comment.value.startsWith('*')) {\n      return comment;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Parses `@typeParam` / `@template` tags from a JSDoc comment body.\n *\n * @param commentBody - The raw comment body (without the leading and trailing comment delimiters).\n * @param tagName - The preferred tag name (`typeParam` or `template`).\n * @returns An array of parsed tag entries.\n */\nfunction parseTypeParamTags(commentBody: string, tagName: string): ParsedTag[] {\n  const tags: ParsedTag[] = [];\n  const tagPattern = new RegExp(`@(?:${tagName}|template|typeParam)\\\\s+(?<typeName>\\\\w+)(?<rest>.*)`, 'g');\n\n  let match;\n  while ((match = tagPattern.exec(commentBody)) !== null) {\n    const groups = ensureNonNullable(match.groups);\n    const name = ensureNonNullable(groups['typeName']);\n    const rest = ensureNonNullable(groups['rest']).trim();\n    const hasDescription = rest.length > 0 && rest !== '-';\n    tags.push({ hasDescription, name });\n  }\n\n  return tags;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBA,yBAAkC;AAMlC,MAAM,WAAW;AAEV,MAAM,8BAA8B;AACpC,MAAM,0CAA0C;AAEhD,MAAM,wBAAyC;AAAA,EACpD,OAAO,SAAS;AACd,UAAM,WAAW,QAAQ,SAAS,OAAO;AACzC,UAAM,mBAAmB,UAAU,oBAAoB,UAAU,KAAK;AAEtE,WAAO;AAAA,MACL,mBAAmB,MAAuB;AACxC,cAAM,aAAa;AACnB,cAAM,eAAe,WAAW;AAEhC,cAAM,aAAa,aAAa,gBAAgB;AAChD,YAAI,CAAC,cAAc,WAAW,WAAW,GAAG;AAC1C;AAAA,QACF;AAEA,cAAM,aAAa,QAAQ;AAC3B,cAAM,WAAW,WAAW,kBAAkB,IAAI;AAClD,cAAM,eAAe,iBAAiB,QAAQ;AAE9C,YAAI,CAAC,cAAc;AACjB;AAAA,QACF;AAEA,cAAM,aAAa,mBAAmB,aAAa,OAAO,gBAAgB;AAE1E,mBAAW,aAAa,YAAY;AAClC,gBAAM,YAAY,UAAU,KAAK;AACjC,gBAAM,cAAc,WAAW,KAAK,CAAC,QAAQ,IAAI,SAAS,SAAS;AAEnE,cAAI,CAAC,aAAa;AAChB,oBAAQ,OAAO;AAAA,cACb,MAAM;AAAA,gBACJ;AAAA,gBACA,SAAS;AAAA,cACX;AAAA,cACA,WAAW;AAAA,cACX;AAAA,YACF,CAAC;AAAA,UACH,WAAW,CAAC,YAAY,gBAAgB;AACtC,oBAAQ,OAAO;AAAA,cACb,MAAM;AAAA,gBACJ;AAAA,gBACA,SAAS;AAAA,cACX;AAAA,cACA,WAAW;AAAA,cACX;AAAA,YACF,CAAC;AAAA,UACH;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA,EACA,MAAM;AAAA,IACJ,MAAM;AAAA,MACJ,aAAa;AAAA,IACf;AAAA,IACA,UAAU;AAAA,MACR,CAAC,2BAA2B,GAAG;AAAA,MAC/B,CAAC,uCAAuC,GAAG;AAAA,IAC7C;AAAA,IACA,QAAQ,CAAC;AAAA,IACT,MAAM;AAAA,EACR;AACF;AAaA,SAAS,iBAAiB,UAAmD;AAC3E,WAAS,IAAI,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK;AAC7C,UAAM,UAAU,SAAS,CAAC;AAC1B,QAAI,SAAS,SAAS,WAAW,QAAQ,MAAM,WAAW,GAAG,GAAG;AAC9D,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;AASA,SAAS,mBAAmB,aAAqB,SAA8B;AAC7E,QAAM,OAAoB,CAAC;AAC3B,QAAM,aAAa,IAAI,OAAO,OAAO,OAAO,wDAAwD,GAAG;AAEvG,MAAI;AACJ,UAAQ,QAAQ,WAAW,KAAK,WAAW,OAAO,MAAM;AACtD,UAAM,aAAS,sCAAkB,MAAM,MAAM;AAC7C,UAAM,WAAO,sCAAkB,OAAO,UAAU,CAAC;AACjD,UAAM,WAAO,sCAAkB,OAAO,MAAM,CAAC,EAAE,KAAK;AACpD,UAAM,iBAAiB,KAAK,SAAS,KAAK,SAAS;AACnD,SAAK,KAAK,EAAE,gBAAgB,KAAK,CAAC;AAAA,EACpC;AAEA,SAAO;AACT;",
  "names": []
}


package/dist/lib/cjs/script-utils/linters/eslint-rules/require-method-template.d.cts

@@ -0,0 +1,4 @@
+import type { Rule } from 'eslint';
+export declare const MESSAGE_ID_MISSING_TEMPLATE = "missingTemplate";
+export declare const MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION = "missingTemplateDescription";
+export declare const requireMethodTemplate: Rule.RuleModule;

package/dist/lib/cjs/transformers/group-transformer.cjs

@@ -165,7 +165,6 @@ class GroupTransformer extends import_transformer.Transformer {
    * @param transformerId - The id of the transformer to get.
    * @returns The transformer with the given id.
    */
-  // eslint-disable-next-line obsidian-dev-utils/require-super-call -- Intentionally replaces parent lookup with search across child transformers.
   getTransformer(transformerId) {
     return (0, import_type_guards.ensureNonNullable)(this.transformers.find((t) => t.id === transformerId), `No transformer with id ${transformerId} found`);
   }
@@ -188,7 +187,6 @@ class GroupTransformer extends import_transformer.Transformer {
    * @param key - The key of the value to get the transformer id for.
    * @returns The id of the transformer that can transform the given value.
    */
-  // eslint-disable-next-line obsidian-dev-utils/require-super-call -- Intentionally replaces parent lookup with composite transformer search.
   getTransformerId(value, key) {
     const transformer = this.getFirstTransformerThatCanTransform(value, key);
     if (transformer === null) {
@@ -219,4 +217,4 @@ class GroupTransformer extends import_transformer.Transformer {
 0 && (module.exports = {
   GroupTransformer
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3RyYW5zZm9ybWVycy9ncm91cC10cmFuc2Zvcm1lci50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEEgdHJhbnNmb3JtZXIgdGhhdCBjb21iaW5lcyBtdWx0aXBsZSB0cmFuc2Zvcm1lcnMuXG4gKi9cblxuaW1wb3J0IHtcbiAgYXNzZXJ0Tm9uTnVsbGFibGUsXG4gIGVuc3VyZU5vbk51bGxhYmxlXG59IGZyb20gJy4uL3R5cGUtZ3VhcmRzLnRzJztcbmltcG9ydCB7IFRyYW5zZm9ybWVyIH0gZnJvbSAnLi90cmFuc2Zvcm1lci50cyc7XG5cbi8qKlxuICogQSB0cmFuc2Zvcm1lciB0aGF0IGNvbWJpbmVzIG11bHRpcGxlIHRyYW5zZm9ybWVycy5cbiAqL1xuZXhwb3J0IGNsYXNzIEdyb3VwVHJhbnNmb3JtZXIgZXh0ZW5kcyBUcmFuc2Zvcm1lciB7XG4gIC8qKlxuICAgKiBBbiBpZCBvZiB0aGUgdHJhbnNmb3JtZXIuXG4gICAqXG4gICAqIEByZXR1cm5zIGBncm91cGAuXG4gICAqL1xuICBwdWJsaWMgb3ZlcnJpZGUgZ2V0IGlkKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuICdncm91cCc7XG4gIH1cblxuICAvKipcbiAgICogVHJhbnNmb3JtZXJzIHRvIGNvbWJpbmUuXG4gICAqXG4gICAqIEBwYXJhbSB0cmFuc2Zvcm1lcnMgLSBUaGUgdHJhbnNmb3JtZXJzIHRvIGNvbWJpbmUuXG4gICAqL1xuICBwdWJsaWMgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSB0cmFuc2Zvcm1lcnM6IFRyYW5zZm9ybWVyW10pIHtcbiAgICBzdXBlcigpO1xuICB9XG5cbiAgLyoqXG4gICAqIERldGVybWluZXMgaWYgdGhlIHZhbHVlIGNhbiBiZSB0cmFuc2Zvcm1lZCBieSBhbnkgb2YgdGhlIHRyYW5zZm9ybWVycy5cbiAgICpcbiAgICogQHBhcmFtIHZhbHVlIC0gVGhlIHZhbHVlIHRvIGNoZWNrLlxuICAgKiBAcGFyYW0ga2V5IC0gVGhlIGtleSBvZiB0aGUgdmFsdWUgdG8gY2hlY2suXG4gICAqIEByZXR1cm5zIEEgYm9vbGVhbiBpbmRpY2F0aW5nIGlmIHRoZSB2YWx1ZSBjYW4gYmUgdHJhbnNmb3JtZWQuXG4gICAqL1xuICBwdWJsaWMgb3ZlcnJpZGUgY2FuVHJhbnNmb3JtKHZhbHVlOiB1bmtub3duLCBrZXk6IHN0cmluZyk6IGJvb2xlYW4ge1xuICAgIHJldHVybiB0aGlzLmdldEZpcnN0VHJhbnNmb3JtZXJUaGF0Q2FuVHJhbnNmb3JtKHZhbHVlLCBrZXkpICE9PSBudWxsO1xuICB9XG5cbiAgLyoqXG4gICAqIEdldHMgdGhlIHRyYW5zZm9ybWVyIHdpdGggdGhlIGdpdmVuIGlkLlxuICAgKlxuICAgKiBAcGFyYW0gdHJhbnNmb3JtZXJJZCAtIFRoZSBpZCBvZiB0aGUgdHJhbnNmb3JtZXIgdG8gZ2V0LlxuICAgKiBAcmV0dXJucyBUaGUgdHJhbnNmb3JtZXIgd2l0aCB0aGUgZ2l2ZW4gaWQuXG4gICAqL1xuICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgb2JzaWRpYW4tZGV2LXV0aWxzL3JlcXVpcmUtc3VwZXItY2FsbCAtLSBJbnRlbnRpb25hbGx5IHJlcGxhY2VzIHBhcmVudCBsb29rdXAgd2l0aCBzZWFyY2ggYWNyb3NzIGNoaWxkIHRyYW5zZm9ybWVycy5cbiAgcHVibGljIG92ZXJyaWRlIGdldFRyYW5zZm9ybWVyKHRyYW5zZm9ybWVySWQ6IHN0cmluZyk6IFRyYW5zZm9ybWVyIHtcbiAgICByZXR1cm4gZW5zdXJlTm9uTnVsbGFibGUodGhpcy50cmFuc2Zvcm1lcnMuZmluZCgodCkgPT4gdC5pZCA9PT0gdHJhbnNmb3JtZXJJZCksIGBObyB0cmFuc2Zvcm1lciB3aXRoIGlkICR7dHJhbnNmb3JtZXJJZH0gZm91bmRgKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBUcmFuc2Zvcm1zIHRoZSB2YWx1ZSB1c2luZyB0aGUgZmlyc3QgdHJhbnNmb3JtZXIgdGhhdCBjYW4gdHJhbnNmb3JtIGl0LlxuICAgKlxuICAgKiBAcGFyYW0gdmFsdWUgLSBUaGUgdmFsdWUgdG8gdHJhbnNmb3JtLlxuICAgKiBAcGFyYW0ga2V5IC0gVGhlIGtleSBvZiB0aGUgdmFsdWUgdG8gdHJhbnNmb3JtLlxuICAgKiBAcmV0dXJucyBUaGUgdHJhbnNmb3JtZWQgdmFsdWUuXG4gICAqL1xuICBwdWJsaWMgb3ZlcnJpZGUgdHJhbnNmb3JtVmFsdWUodmFsdWU6IHVua25vd24sIGtleTogc3RyaW5nKTogdW5rbm93biB7XG4gICAgY29uc3QgdHJhbnNmb3JtZXIgPSB0aGlzLmdldEZpcnN0VHJhbnNmb3JtZXJUaGF0Q2FuVHJhbnNmb3JtKHZhbHVlLCBrZXkpO1xuICAgIGFzc2VydE5vbk51bGxhYmxlKHRyYW5zZm9ybWVyLCAnTm8gdHJhbnNmb3JtZXIgY2FuIHRyYW5zZm9ybSB0aGUgdmFsdWUnKTtcblxuICAgIHJldHVybiB0cmFuc2Zvcm1lci50cmFuc2Zvcm1WYWx1ZSh2YWx1ZSwga2V5KTtcbiAgfVxuXG4gIC8qKlxuICAgKiBHZXRzIHRoZSBpZCBvZiB0aGUgdHJhbnNmb3JtZXIgdGhhdCBjYW4gdHJhbnNmb3JtIHRoZSBnaXZlbiB2YWx1ZS5cbiAgICpcbiAgICogQHBhcmFtIHZhbHVlIC0gVGhlIHZhbHVlIHRvIGdldCB0aGUgdHJhbnNmb3JtZXIgaWQgZm9yLlxuICAgKiBAcGFyYW0ga2V5IC0gVGhlIGtleSBvZiB0aGUgdmFsdWUgdG8gZ2V0IHRoZSB0cmFuc2Zvcm1lciBpZCBmb3IuXG4gICAqIEByZXR1cm5zIFRoZSBpZCBvZiB0aGUgdHJhbnNmb3JtZXIgdGhhdCBjYW4gdHJhbnNmb3JtIHRoZSBnaXZlbiB2YWx1ZS5cbiAgICovXG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBvYnNpZGlhbi1kZXYtdXRpbHMvcmVxdWlyZS1zdXBlci1jYWxsIC0tIEludGVudGlvbmFsbHkgcmVwbGFjZXMgcGFyZW50IGxvb2t1cCB3aXRoIGNvbXBvc2l0ZSB0cmFuc2Zvcm1lciBzZWFyY2guXG4gIHByb3RlY3RlZCBvdmVycmlkZSBnZXRUcmFuc2Zvcm1lcklkKHZhbHVlOiB1bmtub3duLCBrZXk6IHN0cmluZyk6IG51bGwgfCBzdHJpbmcge1xuICAgIGNvbnN0IHRyYW5zZm9ybWVyID0gdGhpcy5nZXRGaXJzdFRyYW5zZm9ybWVyVGhhdENhblRyYW5zZm9ybSh2YWx1ZSwga2V5KTtcbiAgICBpZiAodHJhbnNmb3JtZXIgPT09IG51bGwpIHtcbiAgICAgIHJldHVybiBudWxsO1xuICAgIH1cblxuICAgIHJldHVybiB0cmFuc2Zvcm1lci5pZDtcbiAgfVxuXG4gIC8qKlxuICAgKiBUaGlzIHRyYW5zZm9ybWVyIGRvZXMgbm90IHN1cHBvcnQgcmVzdG9yaW5nIHZhbHVlcy5cbiAgICpcbiAgICogQHRocm93c1xuICAgKi9cbiAgcHJvdGVjdGVkIG92ZXJyaWRlIHJlc3RvcmVWYWx1ZSgpOiBuZXZlciB7XG4gICAgdGhyb3cgbmV3IEVycm9yKCdHcm91cFRyYW5zZm9ybWVyIGRvZXMgbm90IHN1cHBvcnQgcmVzdG9yaW5nIHZhbHVlcycpO1xuICB9XG5cbiAgLyoqXG4gICAqIEdldHMgdGhlIGZpcnN0IHRyYW5zZm9ybWVyIHRoYXQgY2FuIHRyYW5zZm9ybSB0aGUgZ2l2ZW4gdmFsdWUuXG4gICAqXG4gICAqIEBwYXJhbSB2YWx1ZSAtIFRoZSB2YWx1ZSB0byBnZXQgdGhlIGZpcnN0IHRyYW5zZm9ybWVyIGZvci5cbiAgICogQHBhcmFtIGtleSAtIFRoZSBrZXkgb2YgdGhlIHZhbHVlIHRvIGdldCB0aGUgZmlyc3QgdHJhbnNmb3JtZXIgZm9yLlxuICAgKiBAcmV0dXJucyBUaGUgZmlyc3QgdHJhbnNmb3JtZXIgdGhhdCBjYW4gdHJhbnNmb3JtIHRoZSBnaXZlbiB2YWx1ZS5cbiAgICovXG4gIHByaXZhdGUgZ2V0Rmlyc3RUcmFuc2Zvcm1lclRoYXRDYW5UcmFuc2Zvcm0odmFsdWU6IHVua25vd24sIGtleTogc3RyaW5nKTogbnVsbCB8IFRyYW5zZm9ybWVyIHtcbiAgICByZXR1cm4gdGhpcy50cmFuc2Zvcm1lcnMuZmluZCgodCkgPT4gdC5jYW5UcmFuc2Zvcm0odmFsdWUsIGtleSkpID8/IG51bGw7XG4gIH1cbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQU1BLHlCQUdPO0FBQ1AseUJBQTRCO0FBS3JCLE1BQU0seUJBQXlCLCtCQUFZO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBZXpDLFlBQTZCLGNBQTZCO0FBQy9ELFVBQU07QUFENEI7QUFBQSxFQUVwQztBQUFBLEVBRm9DO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBVHBDLElBQW9CLEtBQWE7QUFDL0IsV0FBTztBQUFBLEVBQ1Q7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBa0JnQixhQUFhLE9BQWdCLEtBQXNCO0FBQ2pFLFdBQU8sS0FBSyxvQ0FBb0MsT0FBTyxHQUFHLE1BQU07QUFBQSxFQUNsRTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFTZ0IsZUFBZSxlQUFvQztBQUNqRSxlQUFPLHNDQUFrQixLQUFLLGFBQWEsS0FBSyxDQUFDLE1BQU0sRUFBRSxPQUFPLGFBQWEsR0FBRywwQkFBMEIsYUFBYSxRQUFRO0FBQUEsRUFDakk7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBU2dCLGVBQWUsT0FBZ0IsS0FBc0I7QUFDbkUsVUFBTSxjQUFjLEtBQUssb0NBQW9DLE9BQU8sR0FBRztBQUN2RSw4Q0FBa0IsYUFBYSx3Q0FBd0M7QUFFdkUsV0FBTyxZQUFZLGVBQWUsT0FBTyxHQUFHO0FBQUEsRUFDOUM7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFVbUIsaUJBQWlCLE9BQWdCLEtBQTRCO0FBQzlFLFVBQU0sY0FBYyxLQUFLLG9DQUFvQyxPQUFPLEdBQUc7QUFDdkUsUUFBSSxnQkFBZ0IsTUFBTTtBQUN4QixhQUFPO0FBQUEsSUFDVDtBQUVBLFdBQU8sWUFBWTtBQUFBLEVBQ3JCO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBT21CLGVBQXNCO0FBQ3ZDLFVBQU0sSUFBSSxNQUFNLG9EQUFvRDtBQUFBLEVBQ3RFO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQVNRLG9DQUFvQyxPQUFnQixLQUFpQztBQUMzRixXQUFPLEtBQUssYUFBYSxLQUFLLENBQUMsTUFBTSxFQUFFLGFBQWEsT0FBTyxHQUFHLENBQUMsS0FBSztBQUFBLEVBQ3RFO0FBQ0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==
+//# sourceMappingURL=data:application/json;base64,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