|
|
eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */ convert: () => (/* binding */ convert),\n/* harmony export */ is: () => (/* binding */ is)\n/* harmony export */ });\n/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n */ /**\n * @typedef {Record<string, unknown>} Props\n * @typedef {null | undefined | string | Props | TestFunctionAnything | Array<string | Props | TestFunctionAnything>} Test\n * Check for an arbitrary node, unaware of TypeScript inferral.\n *\n * @callback TestFunctionAnything\n * Check if a node passes a test, unaware of TypeScript inferral.\n * @param {unknown} this\n * The given context.\n * @param {Node} node\n * A node.\n * @param {number | null | undefined} [index]\n * The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n * The node’s parent.\n * @returns {boolean | void}\n * Whether this node passes the test.\n */ /**\n * @template {Node} Kind\n * Node type.\n * @typedef {Kind['type'] | Partial<Kind> | TestFunctionPredicate<Kind> | Array<Kind['type'] | Partial<Kind> | TestFunctionPredicate<Kind>>} PredicateTest\n * Check for a node that can be inferred by TypeScript.\n */ /**\n * Check if a node passes a certain test.\n *\n * @template {Node} Kind\n * Node type.\n * @callback TestFunctionPredicate\n * Complex test function for a node that can be inferred by TypeScript.\n * @param {Node} node\n * A node.\n * @param {number | null | undefined} [index]\n * The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n * The node’s parent.\n * @returns {node is Kind}\n * Whether this node passes the test.\n */ /**\n * @callback AssertAnything\n * Check that an arbitrary value is a node, unaware of TypeScript inferral.\n * @param {unknown} [node]\n * Anything (typically a node).\n * @param {number | null | undefined} [index]\n * The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n * The node’s parent.\n * @returns {boolean}\n * Whether this is a node and passes a test.\n */ /**\n * Check if a node is a node and passes a certain node test.\n *\n * @template {Node} Kind\n * Node type.\n * @callback AssertPredicate\n * Check that an arbitrary value is a specific node, aware of TypeScript.\n * @param {unknown} [node]\n * Anything (typically a node).\n * @param {number | null | undefined} [index]\n * The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n * The node’s parent.\n * @returns {node is Kind}\n * Whether this is a node and passes a test.\n */ /**\n * Check if `node` is a `Node` and whether it passes the given test.\n *\n * @param node\n * Thing to check, typically `Node`.\n * @param test\n * A check for a specific node.\n * @param index\n * The node’s position in its parent.\n * @param parent\n * The node’s parent.\n * @returns\n * Whether `node` is a node and passes a test.\n */ const is = /**\n * @type {(\n * (() => false) &\n * (<Kind extends Node = Node>(node: unknown, test: PredicateTest<Kind>, index: number, parent: Parent, context?: unknown) => node is Kind) &\n * (<Kind extends Node = Node>(node: unknown, test: PredicateTest<Kind>, index?: null | undefined, parent?: null | undefined, context?: unknown) => node is Kind) &\n * ((node: unknown, test: Test, index: number, parent: Parent, context?: unknown) => boolean) &\n * ((node: unknown, test?: Test, index?: null | undefined, parent?: null | undefined, context?: unknown) => boolean)\n * )}\n */ /**\n * @param {unknown} [node]\n * @param {Test} [test]\n * @param {number | null | undefined} [index]\n * @param {Parent | null | undefined} [parent]\n * @param {unknown} [context]\n * @returns {boolean}\n */ // eslint-disable-next-line max-params\nfunction is(node, test, index, parent, context) {\n const check = convert(test);\n if (index !== undefined && index !== null && (typeof index !== \"number\" || index < 0 || index === Number.POSITIVE_INFINITY)) {\n throw new Error(\"Expected positive finite index\");\n }\n if (parent !== undefined && parent !== null && (!is(parent) || !parent.children)) {\n throw new Error(\"Expected parent node\");\n }\n if ((parent === undefined || parent === null) !== (index === undefined || index === null)) {\n throw new Error(\"Expected both parent and index\");\n }\n // @ts-expect-error Looks like a node.\n return node && node.type && typeof node.type === \"string\" ? Boolean(check.call(context, node, index, parent)) : false;\n};\n/**\n * Generate an assertion from a test.\n *\n * Useful if you’re going to test many nodes, for example when creating a\n * utility where something else passes a compatible test.\n *\n * The created function is a bit faster because it expects valid input only:\n * a `node`, `index`, and `parent`.\n *\n * @param test\n * * when nullish, checks if `node` is a `Node`.\n * * when `string`, works like passing `(node) => node.type === test`.\n * * when `function` checks if function passed the node is true.\n * * when `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n * * when `array`, checks if any one of the subtests pass.\n * @returns\n * An assertion.\n */ const convert = /**\n * @type {(\n * (<Kind extends Node>(test: PredicateTest<Kind>) => AssertPredicate<Kind>) &\n * ((test?: Test) => AssertAnything)\n * )}\n */ /**\n * @param {Test} [test]\n * @returns {AssertAnything}\n */ function(test) {\n if (test === undefined || test === null) {\n return ok;\n }\n if (typeof test === \"string\") {\n return typeFactory(test);\n }\n if (typeof test === \"object\") {\n return Array.isArray(test) ? anyFactory(test) : propsFactory(test);\n }\n if (typeof test === \"function\") {\n return castFactory(test);\n }\n throw new Error(\"Expected function, string, or object as test\");\n};\n/**\n * @param {Array<string | Props | TestFunctionAnything>} tests\n * @returns {AssertAnything}\n */ function anyFactory(tests) {\n /** @type {Array<AssertAnything>} */ const checks = [];\n let index = -1;\n while(++index < tests.length){\n checks[index] = convert(tests[index]);\n }\n return castFactory(any);\n /**\n * @this {unknown}\n * @param {Array<unknown>} parameters\n * @returns {boolean}\n */ function any(...parameters) {\n let index = -1;\n while(++index < checks.length){\n if (checks[index].call(this, ...parameters)) return true;\n }\n return false;\n }\n}\n/**\n * Turn an object into a test for a node with a certain fields.\n *\n * @param {Props} check\n * @returns {AssertAnything}\n */ function propsFactory(check) {\n return castFactory(all);\n /**\n * @param {Node} node\n * @returns {boolean}\n */ function all(node) {\n /** @type {string} */ let key;\n for(key in check){\n // @ts-expect-error: hush, it sure works as an index.\n if (node[key] !== check[key]) return false;\n }\n return true;\n }\n}\n/**\n * Turn a string into a test for a node with a certain type.\n *\n * @param {string} check\n * @returns {AssertAnything}\n */ function typeFactory(check) {\n return castFactory(type);\n /**\n * @param {Node} node\n */ function type(node) {\n return node && node.type === check;\n }\n}\n/**\n * Turn a custom test into a test for a node that passes that test.\n *\n * @param {TestFunctionAnything} check\n * @returns {AssertAnything}\n */ function castFactory(check) {\n return assertion;\n /**\n * @this {unknown}\n * @param {unknown} node\n * @param {Array<unknown>} parameters\n * @returns {boolean}\n */ function assertion(node, ...parameters) {\n return Boolean(node && typeof node === \"object\" && \"type\" in node && // @ts-expect-error: fine.\n Boolean(check.call(this, node, ...parameters)));\n }\n}\nfunction ok() {\n return true;\n}\n//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"(ssr)/./node_modules/unist-util-is/lib/index.js","mappings":"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","sources":["webpack://nextchat/./node_modules/unist-util-is/lib/index.js?5135"],"sourcesContent":["/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n */\n\n/**\n * @typedef {Record<string, unknown>} Props\n * @typedef {null | undefined | string | Props | TestFunctionAnything | Array<string | Props | TestFunctionAnything>} Test\n *   Check for an arbitrary node, unaware of TypeScript inferral.\n *\n * @callback TestFunctionAnything\n *   Check if a node passes a test, unaware of TypeScript inferral.\n * @param {unknown} this\n *   The given context.\n * @param {Node} node\n *   A node.\n * @param {number | null | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean | void}\n *   Whether this node passes the test.\n */\n\n/**\n * @template {Node} Kind\n *   Node type.\n * @typedef {Kind['type'] | Partial<Kind> | TestFunctionPredicate<Kind> | Array<Kind['type'] | Partial<Kind> | TestFunctionPredicate<Kind>>} PredicateTest\n *   Check for a node that can be inferred by TypeScript.\n */\n\n/**\n * Check if a node passes a certain test.\n *\n * @template {Node} Kind\n *   Node type.\n * @callback TestFunctionPredicate\n *   Complex test function for a node that can be inferred by TypeScript.\n * @param {Node} node\n *   A node.\n * @param {number | null | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n *   The node’s parent.\n * @returns {node is Kind}\n *   Whether this node passes the test.\n */\n\n/**\n * @callback AssertAnything\n *   Check that an arbitrary value is a node, unaware of TypeScript inferral.\n * @param {unknown} [node]\n *   Anything (typically a node).\n * @param {number | null | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean}\n *   Whether this is a node and passes a test.\n */\n\n/**\n * Check if a node is a node and passes a certain node test.\n *\n * @template {Node} Kind\n *   Node type.\n * @callback AssertPredicate\n *   Check that an arbitrary value is a specific node, aware of TypeScript.\n * @param {unknown} [node]\n *   Anything (typically a node).\n * @param {number | null | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n *   The node’s parent.\n * @returns {node is Kind}\n *   Whether this is a node and passes a test.\n */\n\n/**\n * Check if `node` is a `Node` and whether it passes the given test.\n *\n * @param node\n *   Thing to check, typically `Node`.\n * @param test\n *   A check for a specific node.\n * @param index\n *   The node’s position in its parent.\n * @param parent\n *   The node’s parent.\n * @returns\n *   Whether `node` is a node and passes a test.\n */\nexport const is =\n  /**\n   * @type {(\n   *   (() => false) &\n   *   (<Kind extends Node = Node>(node: unknown, test: PredicateTest<Kind>, index: number, parent: Parent, context?: unknown) => node is Kind) &\n   *   (<Kind extends Node = Node>(node: unknown, test: PredicateTest<Kind>, index?: null | undefined, parent?: null | undefined, context?: unknown) => node is Kind) &\n   *   ((node: unknown, test: Test, index: number, parent: Parent, context?: unknown) => boolean) &\n   *   ((node: unknown, test?: Test, index?: null | undefined, parent?: null | undefined, context?: unknown) => boolean)\n   * )}\n   */\n  (\n    /**\n     * @param {unknown} [node]\n     * @param {Test} [test]\n     * @param {number | null | undefined} [index]\n     * @param {Parent | null | undefined} [parent]\n     * @param {unknown} [context]\n     * @returns {boolean}\n     */\n    // eslint-disable-next-line max-params\n    function is(node, test, index, parent, context) {\n      const check = convert(test)\n\n      if (\n        index !== undefined &&\n        index !== null &&\n        (typeof index !== 'number' ||\n          index < 0 ||\n          index === Number.POSITIVE_INFINITY)\n      ) {\n        throw new Error('Expected positive finite index')\n      }\n\n      if (\n        parent !== undefined &&\n        parent !== null &&\n        (!is(parent) || !parent.children)\n      ) {\n        throw new Error('Expected parent node')\n      }\n\n      if (\n        (parent === undefined || parent === null) !==\n        (index === undefined || index === null)\n      ) {\n        throw new Error('Expected both parent and index')\n      }\n\n      // @ts-expect-error Looks like a node.\n      return node && node.type && typeof node.type === 'string'\n        ? Boolean(check.call(context, node, index, parent))\n        : false\n    }\n  )\n\n/**\n * Generate an assertion from a test.\n *\n * Useful if you’re going to test many nodes, for example when creating a\n * utility where something else passes a compatible test.\n *\n * The created function is a bit faster because it expects valid input only:\n * a `node`, `index`, and `parent`.\n *\n * @param test\n *   *   when nullish, checks if `node` is a `Node`.\n *   *   when `string`, works like passing `(node) => node.type === test`.\n *   *   when `function` checks if function passed the node is true.\n *   *   when `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n *   *   when `array`, checks if any one of the subtests pass.\n * @returns\n *   An assertion.\n */\nexport const convert =\n  /**\n   * @type {(\n   *   (<Kind extends Node>(test: PredicateTest<Kind>) => AssertPredicate<Kind>) &\n   *   ((test?: Test) => AssertAnything)\n   * )}\n   */\n  (\n    /**\n     * @param {Test} [test]\n     * @returns {AssertAnything}\n     */\n    function (test) {\n      if (test === undefined || test === null) {\n        return ok\n      }\n\n      if (typeof test === 'string') {\n        return typeFactory(test)\n      }\n\n      if (typeof test === 'object') {\n        return Array.isArray(test) ? anyFactory(test) : propsFactory(test)\n      }\n\n      if (typeof test === 'function') {\n        return castFactory(test)\n      }\n\n      throw new Error('Expected function, string, or object as test')\n    }\n  )\n\n/**\n * @param {Array<string | Props | TestFunctionAnything>} tests\n * @returns {AssertAnything}\n */\nfunction anyFactory(tests) {\n  /** @type {Array<AssertAnything>} */\n  const checks = []\n  let index = -1\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index])\n  }\n\n  return castFactory(any)\n\n  /**\n   * @this {unknown}\n   * @param {Array<unknown>} parameters\n   * @returns {boolean}\n   */\n  function any(...parameters) {\n    let index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].call(this, ...parameters)) return true\n    }\n\n    return false\n  }\n}\n\n/**\n * Turn an object into a test for a node with a certain fields.\n *\n * @param {Props} check\n * @returns {AssertAnything}\n */\nfunction propsFactory(check) {\n  return castFactory(all)\n\n  /**\n   * @param {Node} node\n   * @returns {boolean}\n   */\n  function all(node) {\n    /** @type {string} */\n    let key\n\n    for (key in check) {\n      // @ts-expect-error: hush, it sure works as an index.\n      if (node[key] !== check[key]) return false\n    }\n\n    return true\n  }\n}\n\n/**\n * Turn a string into a test for a node with a certain type.\n *\n * @param {string} check\n * @returns {AssertAnything}\n */\nfunction typeFactory(check) {\n  return castFactory(type)\n\n  /**\n   * @param {Node} node\n   */\n  function type(node) {\n    return node && node.type === check\n  }\n}\n\n/**\n * Turn a custom test into a test for a node that passes that test.\n *\n * @param {TestFunctionAnything} check\n * @returns {AssertAnything}\n */\nfunction castFactory(check) {\n  return assertion\n\n  /**\n   * @this {unknown}\n   * @param {unknown} node\n   * @param {Array<unknown>} parameters\n   * @returns {boolean}\n   */\n  function assertion(node, ...parameters) {\n    return Boolean(\n      node &&\n        typeof node === 'object' &&\n        'type' in node &&\n        // @ts-expect-error: fine.\n        Boolean(check.call(this, node, ...parameters))\n    )\n  }\n}\n\nfunction ok() {\n  return true\n}\n"],"names":["is","node","test","index","parent","context","check","convert","undefined","Number","POSITIVE_INFINITY","Error","children","type","Boolean","call","ok","typeFactory","Array","isArray","anyFactory","propsFactory","castFactory","tests","checks","length","any","parameters","all","key","assertion"],"sourceRoot":""}\n//# sourceURL=webpack-internal:///(ssr)/./node_modules/unist-util-is/lib/index.js\n");
|