= T extends { a: infer U, b: infer U } ? U : never;\ntype numberAdd = addResultType<{ a: 1, b: 2 }> // 推到出结果类型为 number\ntype textAdd = addResultType<{ a: 'hello', b: 'world' }> // 推到出结果类型为 string\n```\n\n\n### 枚举 enum\n变量的值是约定的几个取值\n\n```\nconst enum PageType {\n HOME = 'home',\n VIDEO = 'video',\n}\n\nfunction getPageUrl(page: PageType) {\n return {\n [PageType.VIDEO]: \"/video\",\n [PageType.HOME]: \"/home\",\n }[page];\n}\n```\n\n\n## tsconfig\n了解了 ts 对于类型的定义和各种规则后,我们则可以在编写 js 代码时利用并进行类型约束。于此同时,我们需要引入 typescript 库去获得这些 ts 能力。\n\n### 如何引入\n```\nnpm install typescript \n// 不必再多说\n```\n\n### 命令\ntypescript 包是有命令文件的,通常 ts 的运行则是通过 tsc 配合相关命令去执行的. 具体命令大家可以安装包之后通过 tsc -h 查看\n![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/349ffc362f0d831a780d2d7f754893a1.png)\n\n### 配置 [官网](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html)\n如果你看了 tsc 命令,你会发现它是有很多命令的,并且有的命令还伴随这相关参数。在工作文件夹中,我们则通过配置文件 `tsconfig.js ` 去配置,保证在项目中的运用。 配置参数这里就不细讲了,还是看官方文档靠谱点。\n"}}]);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"581.bundle.js","mappings":"mIAAA,umL","sources":["webpack://react_wyz/../../blogs/markdown/typescript.md"],"sourcesContent":["export default \"## learn typescript\\n### 类型\\n基本类型: \\n```\\nstring number bool \\n```\\n\\n数组 `[]`:  \\n```\\nstring[]  number[]\\n```\\n\\n元祖:  \\n```\\n[string, number]. 数组中有不同的数据类型\\n```\\n\\n对象:\\n```\\n{ name: string; age: number }\\n```\\n\\n函数：\\n```\\n(arg1: string, arg?: bool) => void\\n```\\n\\nSymbol:  \\n```\\nlet symbol = Symbol(\\\"key\\\"); \\n```\\n\\n空：\\n```\\nundefined   null\\n```\\n\\n任何类型： \\n```\\nany\\n```\\n\\n不存在的值： \\n```\\nnever\\n```\\n\\n### 如何定义类型\\n`type`  定义类型变量\\n```\\ntype Person = { name: string; age: number}\\nts 使用 const person1：Person = { name: '22', age: 1};\\n```\\n\\n`Interfaces` 声明 `对象` 类型的一种方法\\n```\\nInterface Person { name: string; age: number}\\n```\\n\\n`extends` 类型继承于声明的类型\\n```\\ninterface a { name: string}\\ninterface b extends a {\\n\\tage: number\\n}\\nb 的类型等于 { name: string; age: number }\\n```\\n\\nin 判断属性是哪个类型中的\\n```\\ntype PersonListQuery = { user_ids: string[] }\\ntype DogListQuery = { dog_ids: string[] }\\n\\nfunction getList(query: PersonListQuery | DogListQuery ) {\\n\\tif ('user_ids' in PersonListQuery) {\\n\\t \\t// 这里可以推导出 query 类型是 PersonListQuery\\n\\t}\\n}\\n\\n```\\n\\n\\n### 类型组合\\n\\n`Required<T>` 将 T 中所有属性变成必选\\n```\\nRequired<{ a?: bool} > = { a: bool }\\n```\\n\\n`Partial<T>` 将 T 中所有属性变成可选\\n```\\nPartial<{ a: bool }> = { a?: bool }\\n```\\n\\n`Readonly<T>` 将 T 中所有属性变成只读，后续 ts 会检测该类型不允许修改\\n```\\nconst person2: Readonly<{name: string}> = {name: '22'}\\nperson2.name = '33' //error\\n```\\n`Omit<T, keys>` 删除某些属性\\n```\\ninterface Person {\\n  name: string;\\n  age: number;\\n}\\n \\ntype Name = Omit<Person, 'age'>;\\nName 的类型定义为 { name: string }\\n```\\n\\n`Pick<T, keys>` 选择类型中的某些属性\\n```\\ninterface Person {\\n  name: string;\\n  age: number;\\n}\\ntype Name = Pick<Person, 'name'>;\\nName 的类型定义为 { name: string }\\n```\\n\\n\\n`Exclude<T, deleteT>` 删除类型 T 中 deleteT 的类型， 相当于 Omit, 第二个值可以是 keys ，也可以是一个类型变量\\n```\\ninterface Person {\\n  name: string;\\n  age: number;\\n}\\ntype Age = { age: number }\\ntype Name = Exclude<Person, Age>\\nName 的类型定义为 { name: string }\\n```\\n\\n\\n`Extract<T, U>` 提取 T 继承于的 U 类型\\n```\\ntype Person = {  name: string ; age: number } \\ntype PersonDetail = { pet: any; phone: number } \\ntype Name = { name: string }\\ntype Name = Extract<Person | PersonDetail , Name>\\n 将提取出含有 name 的类型 Person\\n```\\n\\n\\n`Parameters<function T>` 获取函数类型的函数类型\\n```\\ntype getName = (perpson: Person) => string;\\ntype queryType = Parameters<getName>;\\nqueryType  的类型定义为 Person\\n```\\n\\n`ReturnType<function T>` 获取函数类型的返回值类型\\n```\\ntype getName = (perpson: Person) => string;\\ntype resType = ReturnType<getName>;\\nvalueType 类型为 string\\n```\\n\\n`Awaited<Promise Type>` 获取异步返回的值类型\\n```\\ntype getPerson = (id: string) => Promise<Person>\\ntype resType = ReturnType<getPerson> // Promise<Person>\\ntype valueType = Awaited<resType> // Person\\n```\\n\\n`Record<K extends keyof any, T>`  定义对象的 key 键类型\\n```\\ntype Keys = 'name' | 'age' \\ntype person = Record<Keys, any>\\n// person 的属性只能为 name 和 age\\n```\\n\\n`NonNullable<T>` 去除类型中定义的 null 和 undefined \\n```\\ntype PersonHobby = hobby: string | undefined;\\ntype Hobby = NonNullable<hobby>\\nHobby 类型为  string\\n```\\n\\n### 类型操作\\n\\n`typeof Object` 获得`对象`的类型\\n```\\nconst person1 = { name: '22', age: 1}\\ntype Person = typeof person1\\nPerson 类型为 { name: string; age: number }\\n```\\n\\n`keyof T`  获得类型中的属性\\n```\\ntype Person = { name: string; age: number }\\ntype Key = keyof Person \\nkey 的类型为 'name' | 'age'\\n```\\n通常我们可以通过 keyof 约束对象的传参， 如\\n```\\ntype Person = { name: string; age: number }\\ntype Key = keyof Person;\\ntype getPersonAtrribute = (person: Person, key: Key) => Person[Key];\\n```\\n或者某些情况下我们想知道一个对象的属性值 \\n```\\nconst workPerson = { \\n\\t'1': { name: '1', age: 1},\\n\\t'2': { name: '2', age: 2},\\n}\\ntype WorkPerson  = typeof workPerson;  // { '1': {name: string; age: number }, '2': {name: string; age: number }\\ntype Key = keyof WorkPerson  // '1' | '2'\\ntype Person = WorkPerson[Key]   // {name: string; age: number }\\n```\\n `|` 类型兼容\\n```\\ntype width = 'string' | 'number';\\n\\n则 width 可以是 '32px' 也可以是 '32' 在 渲染时兼容两种类型\\n```\\n\\n\\n### 函数重载\\n\\n定义不同类型的输入，推到出不同类型的输出\\n\\n```\\ntype PersonListQuery = { user_ids: string[] };\\ntype DongListQuery = { dog_ids: string[] };\\nfunction getList(request: PersonListQuery): Person[];\\nfunction getList(request: DogListQuery): Dog[];\\n\\nfunction getList(query: PersonListQuery | DogListQuery) {\\n  if ('user_ids' in query) {  \\n    return [] as Person[];\\n  } else {\\n    return [] as Dog[];\\n  }\\n}\\n\\nconst a = getList({ personIds: [], region: 'us'})\\n此时 a 的类型将能推到出是 Person[]\\n```\\n\\n### 泛型\\n类型的传参。 用 T 标识，在实际运用时你传入什么类型，该类型就作为后续推导。\\n```\\nasync function request<T>(url: string): Promise<T> {\\n  const res = await fetch(url)\\n  return res.json();\\n}\\n\\nconst res = await request<Person>('getPersonInfo?id=1'); \\n此时 ts 可以推导出 res 的类型是 Person\\n```\\n\\n### Infer  类型参数使用\\n通过 Infer 一个类型为变量，定义出获取类型的方法\\n```\\ntype addResultType<T> = T extends { a: infer U, b: infer U } ?  U : never;\\ntype numberAdd =  addResultType<{ a: 1, b: 2 }>     // 推到出结果类型为 number\\ntype textAdd = addResultType<{ a: 'hello', b: 'world' }>     // 推到出结果类型为 string\\n```\\n\\n\\n### 枚举 enum\\n变量的值是约定的几个取值\\n\\n```\\nconst enum PageType {\\n  HOME = 'home',\\n  VIDEO = 'video',\\n}\\n\\nfunction getPageUrl(page: PageType) {\\n  return {\\n    [PageType.VIDEO]: \\\"/video\\\",\\n    [PageType.HOME]: \\\"/home\\\",\\n  }[page];\\n}\\n```\\n\\n\\n## tsconfig\\n了解了 ts 对于类型的定义和各种规则后，我们则可以在编写 js 代码时利用并进行类型约束。于此同时，我们需要引入 typescript 库去获得这些 ts 能力。\\n\\n### 如何引入\\n```\\nnpm install  typescript  \\n// 不必再多说\\n```\\n\\n### 命令\\ntypescript 包是有命令文件的，通常 ts 的运行则是通过 tsc 配合相关命令去执行的. 具体命令大家可以安装包之后通过 tsc -h 查看\\n![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/349ffc362f0d831a780d2d7f754893a1.png)\\n\\n### 配置 [官网](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html)\\n如果你看了 tsc 命令，你会发现它是有很多命令的，并且有的命令还伴随这相关参数。在工作文件夹中，我们则通过配置文件 `tsconfig.js ` 去配置，保证在项目中的运用。 配置参数这里就不细讲了，还是看官方文档靠谱点。\\n\";"],"names":[],"sourceRoot":""}
\ No newline at end of file
diff --git a/280.bundle.js b/607.bundle.js
similarity index 57%
rename from 280.bundle.js
rename to 607.bundle.js
index 3a0f4fc..fe89dbb 100644
--- a/280.bundle.js
+++ b/607.bundle.js
@@ -1,2 +1,2 @@
-"use strict";(self.webpackChunkreact_wyz=self.webpackChunkreact_wyz||[]).push([[280],{280:(n,t,o)=>{o.r(t),o.d(t,{default:()=>i});const i="作为一个程序员,工作到现在,也将近半年了。公司对员工的代码提交也会有 review 流程。代码的 review 来讲,一般就是看格式、命名、逻辑是否有错,代码是否还有可以抽象的地方,这里总结一下自己遇到的代码规范方面的问题,大家一起写规范的代码,做一个看上去专业码农吧。\n***\n#### **js规范**\n- 代码的缩进了,一般是两格或四格,我司采用的是四格,这里可以根据自己喜好和公司要求了。\n\n- 中英文之间有空格间隔,像这样: `我专业引用 English 单词`\n\n- 命名规范,命名的驼峰式不用再说了。这里具体情况具体分析一下\n - 变量的命名:小驼峰式\n - 函数的命名:小驼峰式\n - 常量:全部大写\n - 构造函数: 大驼峰式\n - 类的成员: 公共属性和方法就是小驼峰式, 私有属性和方法加上`-`前缀,然后是小驼峰式,如 `_nameFrist\n \n ---\n \n#### **css规范**\n- css 的基本命名, 自己刚写的时候以为也是写小驼峰式,后来就呵呵了。css 当中就是用 `-` 连接了, 如 `search-button`,在定义 id 的时候是用小驼峰了。\n\n- css 名字意思定义。这里有一个 BEM 的命名法则参考,可以看看我之前写的一篇博客[了解BEM](http://blog.csdn.net/dadadeganhuo/article/details/76600264)\n- css 命名的统一前缀, 在一个项目中,约定好同一个前缀,可避免样式的覆盖。\n\n- css 样式书写顺序:\n\t- 显示属性:display/list-style/position/float/clear …\n\t- 自身属性(盒模型):width/height/margin/padding/border\n\t- 背景:background\n\t- 行高:line-height\n\t- 文本属性:color/font/text-decoration/text-align/...\n\t- 其他:cursor/z-index/zoom/overflow\n\t- CSS3属性:transform/transition/animation/box-shadow/border-radius\n\t- 如果使用CSS3的属性,如果有必要加入浏览器前缀,则按照 -webkit- / -moz- / -ms- / -o- /\nstd的顺序进行添加,标准属性写在最后。\n\t- 链接的样式请严格按照如下顺序添加: a:link -> a:visited -> a:hover -> a:active\n\n- 代码优化,能合并的属性就合并写,没用的属性也删掉,避免重复样式,避免使用 `!important`\n\n---\n\n#### **git commit log 规则**\n\n- 首先就是commit 内容的分类了,如图片所示:\n![这里写图片描述](https://img-blog.csdn.net/20170830144139403?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)定好分类,分类后面可以加你本次修改具体文件,然后组织本次修改的内容,就写好了 commit log啦。比如:`feat(login): 新增登录验证功能`,这表达出了你再login文件上新增了一个验证的功能。编写正确的 log 信息,能够清楚的表述你写的代码目的。\n\n- commit 次数,这里我们每完成一个小点的时候,都可以 commit 一下,因为commit 是记录你完成一个项目的具体过程。\n\n---\n= = 之前没好好总结,今天写总结的时候,也去搜了搜别的文章,发现这样的文章其实挺多,自己以前都没怎么好好看看 = = 。\n欢迎补充啊~\n\n#### 参考 \n> [前端人员必看的CSS规范](https://www.douban.com/note/499976405/?type=like)\n> [Commit message 和 Change log 编写指南](http://www.ruanyifeng.com/blog/2016/01/commit_message_change_log.html)\n"}}]);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
\ No newline at end of file
+"use strict";(self.webpackChunkreact_wyz=self.webpackChunkreact_wyz||[]).push([[607],{4607:(n,t,o)=>{o.r(t),o.d(t,{default:()=>i});const i="作为一个程序员,工作到现在,也将近半年了。公司对员工的代码提交也会有 review 流程。代码的 review 来讲,一般就是看格式、命名、逻辑是否有错,代码是否还有可以抽象的地方,这里总结一下自己遇到的代码规范方面的问题,大家一起写规范的代码,做一个看上去专业码农吧。\n***\n#### **js规范**\n- 代码的缩进了,一般是两格或四格,我司采用的是四格,这里可以根据自己喜好和公司要求了。\n\n- 中英文之间有空格间隔,像这样: `我专业引用 English 单词`\n\n- 命名规范,命名的驼峰式不用再说了。这里具体情况具体分析一下\n - 变量的命名:小驼峰式\n - 函数的命名:小驼峰式\n - 常量:全部大写\n - 构造函数: 大驼峰式\n - 类的成员: 公共属性和方法就是小驼峰式, 私有属性和方法加上`-`前缀,然后是小驼峰式,如 `_nameFrist\n \n ---\n \n#### **css规范**\n- css 的基本命名, 自己刚写的时候以为也是写小驼峰式,后来就呵呵了。css 当中就是用 `-` 连接了, 如 `search-button`,在定义 id 的时候是用小驼峰了。\n\n- css 名字意思定义。这里有一个 BEM 的命名法则参考,可以看看我之前写的一篇博客[了解BEM](http://blog.csdn.net/dadadeganhuo/article/details/76600264)\n- css 命名的统一前缀, 在一个项目中,约定好同一个前缀,可避免样式的覆盖。\n\n- css 样式书写顺序:\n\t- 显示属性:display/list-style/position/float/clear …\n\t- 自身属性(盒模型):width/height/margin/padding/border\n\t- 背景:background\n\t- 行高:line-height\n\t- 文本属性:color/font/text-decoration/text-align/...\n\t- 其他:cursor/z-index/zoom/overflow\n\t- CSS3属性:transform/transition/animation/box-shadow/border-radius\n\t- 如果使用CSS3的属性,如果有必要加入浏览器前缀,则按照 -webkit- / -moz- / -ms- / -o- /\nstd的顺序进行添加,标准属性写在最后。\n\t- 链接的样式请严格按照如下顺序添加: a:link -> a:visited -> a:hover -> a:active\n\n- 代码优化,能合并的属性就合并写,没用的属性也删掉,避免重复样式,避免使用 `!important`\n\n---\n\n#### **git commit log 规则**\n\n- 首先就是commit 内容的分类了,如图片所示:\n![这里写图片描述](https://img-blog.csdn.net/20170830144139403?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)定好分类,分类后面可以加你本次修改具体文件,然后组织本次修改的内容,就写好了 commit log啦。比如:`feat(login): 新增登录验证功能`,这表达出了你再login文件上新增了一个验证的功能。编写正确的 log 信息,能够清楚的表述你写的代码目的。\n\n- commit 次数,这里我们每完成一个小点的时候,都可以 commit 一下,因为commit 是记录你完成一个项目的具体过程。\n\n---\n= = 之前没好好总结,今天写总结的时候,也去搜了搜别的文章,发现这样的文章其实挺多,自己以前都没怎么好好看看 = = 。\n欢迎补充啊~\n\n#### 参考 \n> [前端人员必看的CSS规范](https://www.douban.com/note/499976405/?type=like)\n> [Commit message 和 Change log 编写指南](http://www.ruanyifeng.com/blog/2016/01/commit_message_change_log.html)\n"}}]);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
\ No newline at end of file
diff --git a/743.bundle.js b/634.bundle.js
similarity index 89%
rename from 743.bundle.js
rename to 634.bundle.js
index 4e244a9..655dfcf 100644
--- a/743.bundle.js
+++ b/634.bundle.js
@@ -1,2 +1,2 @@
-"use strict";(self.webpackChunkcboy_blog=self.webpackChunkcboy_blog||[]).push([[743],{743:function(t,o,u){u.r(o),u.d(o,{default:function(){return s}});var e=u(358);const n={class:"component-canvas-svg"},q={};var s=(0,u(389).A)(q,[["render",function(t,o){return(0,e.uX)(),(0,e.CE)("div",n,o[0]||(o[0]=[(0,e.Fv)("canvas canvas 是 HTML 5 新出的图片元素,它是 2d 绘图 API, 使用 JavaScript 调用API 可以画 lines, shapes, images, text 甚至其他你想话的, 并且不需要什么插件。
它是作为一个画布存在在网页中, 画布上有你绘制的图案,利用 js 你可以实时的改变画布上的图案,以实现动画。
它的支持性也挺好,IE 9 开始支持,Chrome和Opera 9+ 也支持。
svg SVG 可缩放矢量图形, 是 XML 用来描述二维图形和绘图程序的语言。目前SVG在Firefox、Opera、Webkit浏览器、IE等浏览器中已经部分实现。
什么是 XML 它是一种类似于 HTML 的标记语言,设计宗旨在于传输数据而不是显示数据。 XML 数据以纯文本格式进行存储,因此提供了一种独立于软件和硬件的数据存储方法。通过读取你可以获取存储于其中的数据
SVG可以通过定义必要的线和形状来创建一个图形,也可以修改已有的位图,或者将这两种方式结合起来创建图形。图形和其组成部分可以变形,可以合成,还可以通过滤镜完全改变外观。
SVG提供了一些元素,用于定义圆形、矩形、简单或复杂的曲线,以及其他形状。 一个简单的SVG文档由 <svg>
根元素和基本的形状元素构成。另外还有一个g元素,它用来把若干个基本形状编成一个组。
eg:
<svg version="1.1"\n baseProfile="full"\n width="300" height="200"\n xmlns="http://www.w3.org/2000/svg">\n\n <rect width="100%" height="100%" fill="red" />\n\n <circle cx="150" cy="100" r="80" fill="green" />\n\n <text x="150" y="125" font-size="60" text-anchor="middle" fill="white">SVG</text>\n\n</svg>\n\n
可以看到 svg 是在内部组合各种元素绘制形成相应的图案。 并且矢量顾名思义是可以自由缩放的,根据屏幕像素点进行缩放,保留了图案的高清晰度。
总结 通过以上,我们可以知道 svg 和 canvas 的相同点,它们都是可以绘图的元素,并有自身的用法。 canvas 是一块画布,纯用 js 去画画的。根据你的 js 编写,动态去渲染画布上的图案,适用一些大量数据交互修改的,比较复杂的动画。由于它仅仅是根据你设定的大小,它是依赖于分辨率的。 而 svg 是一个个元素组成在一起的, 包含 animate 元素,可做一些小小的动画, 它的矢量优点也更适合做一些高保真的静态图片。
",14)]))}]])}}]);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
\ No newline at end of file
+"use strict";(self.webpackChunkcboy_blog=self.webpackChunkcboy_blog||[]).push([[634],{634:function(t,o,u){u.r(o),u.d(o,{default:function(){return s}});var e=u(762);const n={class:"component-canvas-svg"},q={};var s=(0,u(314).A)(q,[["render",function(t,o){return(0,e.uX)(),(0,e.CE)("div",n,o[0]||(o[0]=[(0,e.Fv)("canvas canvas 是 HTML 5 新出的图片元素,它是 2d 绘图 API, 使用 JavaScript 调用API 可以画 lines, shapes, images, text 甚至其他你想话的, 并且不需要什么插件。
它是作为一个画布存在在网页中, 画布上有你绘制的图案,利用 js 你可以实时的改变画布上的图案,以实现动画。
它的支持性也挺好,IE 9 开始支持,Chrome和Opera 9+ 也支持。
svg SVG 可缩放矢量图形, 是 XML 用来描述二维图形和绘图程序的语言。目前SVG在Firefox、Opera、Webkit浏览器、IE等浏览器中已经部分实现。
什么是 XML 它是一种类似于 HTML 的标记语言,设计宗旨在于传输数据而不是显示数据。 XML 数据以纯文本格式进行存储,因此提供了一种独立于软件和硬件的数据存储方法。通过读取你可以获取存储于其中的数据
SVG可以通过定义必要的线和形状来创建一个图形,也可以修改已有的位图,或者将这两种方式结合起来创建图形。图形和其组成部分可以变形,可以合成,还可以通过滤镜完全改变外观。
SVG提供了一些元素,用于定义圆形、矩形、简单或复杂的曲线,以及其他形状。 一个简单的SVG文档由 <svg>
根元素和基本的形状元素构成。另外还有一个g元素,它用来把若干个基本形状编成一个组。
eg:
<svg version="1.1"\n baseProfile="full"\n width="300" height="200"\n xmlns="http://www.w3.org/2000/svg">\n\n <rect width="100%" height="100%" fill="red" />\n\n <circle cx="150" cy="100" r="80" fill="green" />\n\n <text x="150" y="125" font-size="60" text-anchor="middle" fill="white">SVG</text>\n\n</svg>\n\n
可以看到 svg 是在内部组合各种元素绘制形成相应的图案。 并且矢量顾名思义是可以自由缩放的,根据屏幕像素点进行缩放,保留了图案的高清晰度。
总结 通过以上,我们可以知道 svg 和 canvas 的相同点,它们都是可以绘图的元素,并有自身的用法。 canvas 是一块画布,纯用 js 去画画的。根据你的 js 编写,动态去渲染画布上的图案,适用一些大量数据交互修改的,比较复杂的动画。由于它仅仅是根据你设定的大小,它是依赖于分辨率的。 而 svg 是一个个元素组成在一起的, 包含 animate 元素,可做一些小小的动画, 它的矢量优点也更适合做一些高保真的静态图片。
",14)]))}]])}}]);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
\ No newline at end of file
diff --git a/843.bundle.js b/636.bundle.js
similarity index 58%
rename from 843.bundle.js
rename to 636.bundle.js
index 9e4a344..a4803bb 100644
--- a/843.bundle.js
+++ b/636.bundle.js
@@ -1,2 +1,2 @@
-"use strict";(self.webpackChunkreact_wyz=self.webpackChunkreact_wyz||[]).push([[843],{843:(n,e,s)=>{s.r(e),s.d(e,{default:()=>t});const t='### **什么是PWA** \n先说一下全名,progressive web app: 渐进式网页应用。这是谷歌推出的,我是这样理解的:\n\n- 我们一般写web应用,在 pc 上是没有缓存的,打开页面的时去请求数据。\n\n- 第二个也没有像 app 一样的小图标放在桌面,一点开就进入了应用,而是通过打开浏览器输入网址, \n\n- 第三个就是,不能像 app 一样给用户推送消息,像微博会跟你推送说有谁评论了你的微博之类的功能。 \n\n而谷歌推出的 pwa,就是具有这些了这些特点, 使我们的 web 应用,能够像一款 app 一样使用。并且对比与 app, 它不用复杂的安装,也不用下载更新包,刷新页面就可以了(注意到缓存的处理)。\n\n#### **那么这些功能分别是怎么实现的呢?** \n**关于缓存**\n\n其实这个就是 我们平时做的 Session 啊、localStorage、CacheStorage 之类的。\n\n这里用的就是 [cacheStorage](https://developer.mozilla.org/zh-CN/docs/Web/API/CacheStorage) 缓存,它提供了一个ServiceWorker类型的工作者或window范围可以访问的所有命名缓存的主目录, 并维护字符串的映射名称到相应的 Cache 对象。\n主要方法包括: \n![这里写图片描述](https://img-blog.csdn.net/20171112212302073?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\n有了这些方法你可以对你的缓存进行操作。目前还在草案状态,仅火狐和谷歌浏览器支持此特性。\n\nPWA是通过 ServiceWorker 访问 cache ,所以需要注册 ServiceWorker 工作者。在之前别忘记判断浏览器是否支持。\n\n```\nif (\'serviceWorker\' in navigator) {\n\tnavigator.serviceWorker.register(sw.js) // 注册sw.js 文件中变成的服务对象,返回注册成功的对象\n\t.then(function(swReg){\n swRegistration = swReg;\n }).catch(function(error) {\n console.error(\'Service Worker Error\', error);\n });\n}\n```\n这个 [Service Worker](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) 服务工作者就厉害了,它相当于浏览器和网络之间的代理服务器,可以拦截网络请求,做一些你可能需要的处理(请求资源从缓存中获取等)。\n\n- 它能够创建有效的离线体验,拦截网络请求,并根据网络是否可用判断是否使用缓存数据或者更新缓存数据。\n\n- 它们还允许访问推送的通知和后台的API。\n\n关于 sw.js 中具体的缓存的代码:\n\n创建需要缓存的文件\n\n```\n\'use strict\'\nlet cacheName = \'pwa-demo-assets\'; // 缓存名字\nlet imgCacheName = \'pwa-img\';\nlet filesToCache;\nfilesToCache = [ // 所需缓存的文件\n \'/\',\n \'/index.html\',\n \'/scripts/app.js\',\n \'/assets/imgs/48.png\',\n \'/assets/imgs/96.png\',\n \'/assets/imgs/192.png\',\n \'/dist/js/app.js\',\n \'/manifest.json\'\n];\n\nself.addEventListener(\'install\', function(e) {\n e.waitUntil(\n\t // 安装服务者时,对需要缓存的文件进行缓存\n caches.open(cacheName).then(function(cache) {\n return cache.addAll(filesToCache);\n })\n );\n});\n\n\nself.addEventListener(\'fetch\', (e) => {\n // 判断地址是不是需要实时去请求,是就继续发送请求\n if (e.request.url.indexOf(\'/api/400/200\') > -1) {\n e.respondWith(\n caches.open(imgCacheName).then(function(cache){\n return fetch(e.request).then(function (response){\n cache.put(e.request.url, response.clone()); // 每请求一次缓存更新一次新加载的图片\n return response;\n });\n })\n );\n } else {\n e.respondWith(\n\t // 匹配到缓存资源,就从缓存中返回数据\n caches.match(e.request).then(function (response) {\n return response || fetch(e.request);\n })\n );\n }\n\n});\n```\n\n**这里进而就引入到 pwa 的推送通知功能。这都是通过 ServiceWorker 去实现的。**\n\n基本原理是,你的客户端要和推送服务进行绑定,会生成一个绑定后的推送服务API接口,服务端调用此接口,发送消息。同时,浏览器也要支持推送功能,在注册 sw 时, 加上推送功能的判断。\n\n```\nif (\'serviceWorker\' in navigator && \'PushManager\' in window) {\n\tnavigator.serviceWorker.register(sw.js)\n\t.then(function(swReg) {\n swRegistration = swReg;\n }).catch(function(error) {\n console.error(\'Service Worker Error\', error);\n });\n } else {\n console.warn(\'Push messaging is not supported\');\n }\n```\nPushManager 注册好之后, 那么要做的就是浏览器和服务器的绑定了。\n\n![这里写图片描述](https://img-blog.csdn.net/20171112203347222?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\n此图是用户订阅某个应用程序的推送服务。\n客户端传入应用程序服务器公钥,向将生成端点的 `webpush 服务器`( 这是谷歌自己实现的一个推送功能的服务器)发出网络请求,将生成的端点(一个推送服务)与应用程序公钥关联,并将端点返回给应用程序。浏览器会将此端点添加到 PushSubscription,通过 promise异步成功时,可以将它的信息保存到你的数据库。\n\n![这里写图片描述](https://img-blog.csdn.net/20171112203753820?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\n服务器发送推送的时候,请求相关接口,验证成功后推送服务会发消息给客户端。\n\n**最后关于桌面小图标**\n\n这个可以说是非常简单了,就是一个manifest.json配置文件,然后在页面引入此文件就好了\n\n```\n\x3c!-- 加载清单 --\x3e\n \n```\n关于[清单内容](https://developers.google.com/web/fundamentals/web-app-manifest/)这里简单介绍一下:\n\n```\n{\n "short_name": "pwa",\n "name": "pwa - demo", // 应用名称\n "icons": [ // 应用显示图标,根据容器大小适配\n {\n "src": "assets/imgs/48.png",\n "type": "image/png",\n "sizes": "48x48"\n },\n {\n "src": "assets/imgs/96.png",\n "type": "image/png",\n "sizes": "96x96"\n },\n {\n "src": "assets/imgs/192.png",\n "type": "image/png",\n "sizes": "192x192"\n }\n ],\n "background_color": "#2196F3", // 刚打开页面时的背景\n "theme_color": "#2196F3", // 主题颜色\n "display": "standalone", //独立显示\n "start_url": "index.html?launcher=true" // 启动的页面\n}\n```\n好了, 如果感兴趣赶快上手吧。\n可以查看[谷歌官方教程](https://developers.google.com/web/progressive-web-apps/)。\n\n这里说一下坑的点,\tPWA应用需要在本地localhost:8080 上运行或者 https 协议下, 要保证你的页面是安全页面。\n\n添加桌面时,确保你的谷歌浏览器可以显示弹出通知。\n\n如果你要自己实现推送,自己服务器要有公钥和私钥的获取, 这里可以通过 https://web-push-codelab.glitch.me 获取, 用 chrome 的 [webpush](https://github.com/zaru/webpush) 推送。\n\n这里也可以看一下我的[ GitHub 项项目 ](https://github.com/cleverboy32/chorme-PwaDemo),官方也有很多例子。'}}]);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"843.bundle.js","mappings":"kIAAA,0oK","sources":["webpack://react_wyz/../../blogs/markdown/pwa.md"],"sourcesContent":["export default \"### **什么是PWA** \\n先说一下全名，progressive web app： 渐进式网页应用。这是谷歌推出的，我是这样理解的：\\n\\n- 我们一般写web应用，在 pc 上是没有缓存的，打开页面的时去请求数据。\\n\\n-  第二个也没有像 app 一样的小图标放在桌面，一点开就进入了应用，而是通过打开浏览器输入网址， \\n\\n- 第三个就是，不能像 app 一样给用户推送消息，像微博会跟你推送说有谁评论了你的微博之类的功能。 \\n\\n而谷歌推出的 pwa，就是具有这些了这些特点， 使我们的 web 应用，能够像一款 app 一样使用。并且对比与 app, 它不用复杂的安装，也不用下载更新包，刷新页面就可以了(注意到缓存的处理)。\\n\\n#### **那么这些功能分别是怎么实现的呢？** \\n**关于缓存**\\n\\n其实这个就是 我们平时做的 Session 啊、localStorage、CacheStorage 之类的。\\n\\n这里用的就是 [cacheStorage](https://developer.mozilla.org/zh-CN/docs/Web/API/CacheStorage) 缓存，它提供了一个ServiceWorker类型的工作者或window范围可以访问的所有命名缓存的主目录, 并维护字符串的映射名称到相应的 Cache 对象。\\n主要方法包括： \\n![这里写图片描述](https://img-blog.csdn.net/20171112212302073?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\\n有了这些方法你可以对你的缓存进行操作。目前还在草案状态，仅火狐和谷歌浏览器支持此特性。\\n\\nPWA是通过 ServiceWorker 访问 cache ,所以需要注册 ServiceWorker 工作者。在之前别忘记判断浏览器是否支持。\\n\\n```\\nif ('serviceWorker' in navigator) {\\n\\tnavigator.serviceWorker.register(sw.js) // 注册sw.js 文件中变成的服务对象，返回注册成功的对象\\n\\t.then(function(swReg){\\n          swRegistration = swReg;\\n     }).catch(function(error) {\\n          console.error('Service Worker Error', error);\\n     });\\n}\\n```\\n这个 [Service Worker](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) 服务工作者就厉害了，它相当于浏览器和网络之间的代理服务器，可以拦截网络请求，做一些你可能需要的处理(请求资源从缓存中获取等)。\\n\\n-  它能够创建有效的离线体验，拦截网络请求，并根据网络是否可用判断是否使用缓存数据或者更新缓存数据。\\n\\n-  它们还允许访问推送的通知和后台的API。\\n\\n关于 sw.js 中具体的缓存的代码：\\n\\n创建需要缓存的文件\\n\\n```\\n'use strict'\\nlet cacheName = 'pwa-demo-assets'; // 缓存名字\\nlet imgCacheName = 'pwa-img';\\nlet filesToCache;\\nfilesToCache = [ // 所需缓存的文件\\n    '/',\\n    '/index.html',\\n    '/scripts/app.js',\\n    '/assets/imgs/48.png',\\n    '/assets/imgs/96.png',\\n    '/assets/imgs/192.png',\\n    '/dist/js/app.js',\\n    '/manifest.json'\\n];\\n\\nself.addEventListener('install', function(e) {\\n    e.waitUntil(\\n\\t    // 安装服务者时，对需要缓存的文件进行缓存\\n        caches.open(cacheName).then(function(cache) {\\n            return cache.addAll(filesToCache);\\n        })\\n    );\\n});\\n\\n\\nself.addEventListener('fetch', (e) => {\\n    // 判断地址是不是需要实时去请求，是就继续发送请求\\n    if (e.request.url.indexOf('/api/400/200') > -1) {\\n        e.respondWith(\\n            caches.open(imgCacheName).then(function(cache){\\n                 return fetch(e.request).then(function (response){\\n                    cache.put(e.request.url, response.clone()); // 每请求一次缓存更新一次新加载的图片\\n                    return response;\\n                });\\n            })\\n        );\\n    } else {\\n        e.respondWith(\\n\\t        // 匹配到缓存资源，就从缓存中返回数据\\n            caches.match(e.request).then(function (response) {\\n                return response || fetch(e.request);\\n            })\\n        );\\n    }\\n\\n});\\n```\\n\\n**这里进而就引入到 pwa 的推送通知功能。这都是通过 ServiceWorker 去实现的。**\\n\\n基本原理是，你的客户端要和推送服务进行绑定，会生成一个绑定后的推送服务API接口，服务端调用此接口，发送消息。同时，浏览器也要支持推送功能，在注册 sw 时, 加上推送功能的判断。\\n\\n```\\nif ('serviceWorker' in navigator && 'PushManager' in window) {\\n\\tnavigator.serviceWorker.register(sw.js)\\n\\t.then(function(swReg) {\\n        swRegistration = swReg;\\n    }).catch(function(error) {\\n        console.error('Service Worker Error', error);\\n        });\\n } else {\\n     console.warn('Push messaging is not supported');\\n }\\n```\\nPushManager 注册好之后， 那么要做的就是浏览器和服务器的绑定了。\\n\\n![这里写图片描述](https://img-blog.csdn.net/20171112203347222?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\\n此图是用户订阅某个应用程序的推送服务。\\n客户端传入应用程序服务器公钥，向将生成端点的 `webpush 服务器`( 这是谷歌自己实现的一个推送功能的服务器)发出网络请求，将生成的端点(一个推送服务)与应用程序公钥关联，并将端点返回给应用程序。浏览器会将此端点添加到 PushSubscription，通过 promise异步成功时，可以将它的信息保存到你的数据库。\\n\\n![这里写图片描述](https://img-blog.csdn.net/20171112203753820?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\\n服务器发送推送的时候,请求相关接口，验证成功后推送服务会发消息给客户端。\\n\\n**最后关于桌面小图标**\\n\\n这个可以说是非常简单了，就是一个manifest.json配置文件，然后在页面引入此文件就好了\\n\\n```\\n<!-- 加载清单 -->\\n<link rel=\\\"manifest\\\" href=\\\"./manifest.json\\\">\\n```\\n关于[清单内容](https://developers.google.com/web/fundamentals/web-app-manifest/)这里简单介绍一下：\\n\\n```\\n{\\n    \\\"short_name\\\": \\\"pwa\\\",\\n    \\\"name\\\": \\\"pwa - demo\\\", // 应用名称\\n    \\\"icons\\\": [ // 应用显示图标，根据容器大小适配\\n        {\\n            \\\"src\\\": \\\"assets/imgs/48.png\\\",\\n            \\\"type\\\": \\\"image/png\\\",\\n            \\\"sizes\\\": \\\"48x48\\\"\\n        },\\n        {\\n            \\\"src\\\": \\\"assets/imgs/96.png\\\",\\n            \\\"type\\\": \\\"image/png\\\",\\n            \\\"sizes\\\": \\\"96x96\\\"\\n        },\\n        {\\n            \\\"src\\\": \\\"assets/imgs/192.png\\\",\\n            \\\"type\\\": \\\"image/png\\\",\\n            \\\"sizes\\\": \\\"192x192\\\"\\n        }\\n    ],\\n    \\\"background_color\\\": \\\"#2196F3\\\", // 刚打开页面时的背景\\n    \\\"theme_color\\\": \\\"#2196F3\\\", // 主题颜色\\n    \\\"display\\\": \\\"standalone\\\", //独立显示\\n    \\\"start_url\\\": \\\"index.html?launcher=true\\\" // 启动的页面\\n}\\n```\\n好了， 如果感兴趣赶快上手吧。\\n可以查看[谷歌官方教程](https://developers.google.com/web/progressive-web-apps/)。\\n\\n这里说一下坑的点，\\tPWA应用需要在本地localhost:8080 上运行或者 https 协议下， 要保证你的页面是安全页面。\\n\\n添加桌面时，确保你的谷歌浏览器可以显示弹出通知。\\n\\n如果你要自己实现推送，自己服务器要有公钥和私钥的获取， 这里可以通过 https://web-push-codelab.glitch.me 获取， 用 chrome 的 [webpush](https://github.com/zaru/webpush) 推送。\\n\\n这里也可以看一下我的[ GitHub 项项目 ](https://github.com/cleverboy32/chorme-PwaDemo)，官方也有很多例子。\";"],"names":[],"sourceRoot":""}
\ No newline at end of file
+"use strict";(self.webpackChunkreact_wyz=self.webpackChunkreact_wyz||[]).push([[636],{4636:(n,e,s)=>{s.r(e),s.d(e,{default:()=>t});const t='### **什么是PWA** \n先说一下全名,progressive web app: 渐进式网页应用。这是谷歌推出的,我是这样理解的:\n\n- 我们一般写web应用,在 pc 上是没有缓存的,打开页面的时去请求数据。\n\n- 第二个也没有像 app 一样的小图标放在桌面,一点开就进入了应用,而是通过打开浏览器输入网址, \n\n- 第三个就是,不能像 app 一样给用户推送消息,像微博会跟你推送说有谁评论了你的微博之类的功能。 \n\n而谷歌推出的 pwa,就是具有这些了这些特点, 使我们的 web 应用,能够像一款 app 一样使用。并且对比与 app, 它不用复杂的安装,也不用下载更新包,刷新页面就可以了(注意到缓存的处理)。\n\n#### **那么这些功能分别是怎么实现的呢?** \n**关于缓存**\n\n其实这个就是 我们平时做的 Session 啊、localStorage、CacheStorage 之类的。\n\n这里用的就是 [cacheStorage](https://developer.mozilla.org/zh-CN/docs/Web/API/CacheStorage) 缓存,它提供了一个ServiceWorker类型的工作者或window范围可以访问的所有命名缓存的主目录, 并维护字符串的映射名称到相应的 Cache 对象。\n主要方法包括: \n![这里写图片描述](https://img-blog.csdn.net/20171112212302073?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\n有了这些方法你可以对你的缓存进行操作。目前还在草案状态,仅火狐和谷歌浏览器支持此特性。\n\nPWA是通过 ServiceWorker 访问 cache ,所以需要注册 ServiceWorker 工作者。在之前别忘记判断浏览器是否支持。\n\n```\nif (\'serviceWorker\' in navigator) {\n\tnavigator.serviceWorker.register(sw.js) // 注册sw.js 文件中变成的服务对象,返回注册成功的对象\n\t.then(function(swReg){\n swRegistration = swReg;\n }).catch(function(error) {\n console.error(\'Service Worker Error\', error);\n });\n}\n```\n这个 [Service Worker](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) 服务工作者就厉害了,它相当于浏览器和网络之间的代理服务器,可以拦截网络请求,做一些你可能需要的处理(请求资源从缓存中获取等)。\n\n- 它能够创建有效的离线体验,拦截网络请求,并根据网络是否可用判断是否使用缓存数据或者更新缓存数据。\n\n- 它们还允许访问推送的通知和后台的API。\n\n关于 sw.js 中具体的缓存的代码:\n\n创建需要缓存的文件\n\n```\n\'use strict\'\nlet cacheName = \'pwa-demo-assets\'; // 缓存名字\nlet imgCacheName = \'pwa-img\';\nlet filesToCache;\nfilesToCache = [ // 所需缓存的文件\n \'/\',\n \'/index.html\',\n \'/scripts/app.js\',\n \'/assets/imgs/48.png\',\n \'/assets/imgs/96.png\',\n \'/assets/imgs/192.png\',\n \'/dist/js/app.js\',\n \'/manifest.json\'\n];\n\nself.addEventListener(\'install\', function(e) {\n e.waitUntil(\n\t // 安装服务者时,对需要缓存的文件进行缓存\n caches.open(cacheName).then(function(cache) {\n return cache.addAll(filesToCache);\n })\n );\n});\n\n\nself.addEventListener(\'fetch\', (e) => {\n // 判断地址是不是需要实时去请求,是就继续发送请求\n if (e.request.url.indexOf(\'/api/400/200\') > -1) {\n e.respondWith(\n caches.open(imgCacheName).then(function(cache){\n return fetch(e.request).then(function (response){\n cache.put(e.request.url, response.clone()); // 每请求一次缓存更新一次新加载的图片\n return response;\n });\n })\n );\n } else {\n e.respondWith(\n\t // 匹配到缓存资源,就从缓存中返回数据\n caches.match(e.request).then(function (response) {\n return response || fetch(e.request);\n })\n );\n }\n\n});\n```\n\n**这里进而就引入到 pwa 的推送通知功能。这都是通过 ServiceWorker 去实现的。**\n\n基本原理是,你的客户端要和推送服务进行绑定,会生成一个绑定后的推送服务API接口,服务端调用此接口,发送消息。同时,浏览器也要支持推送功能,在注册 sw 时, 加上推送功能的判断。\n\n```\nif (\'serviceWorker\' in navigator && \'PushManager\' in window) {\n\tnavigator.serviceWorker.register(sw.js)\n\t.then(function(swReg) {\n swRegistration = swReg;\n }).catch(function(error) {\n console.error(\'Service Worker Error\', error);\n });\n } else {\n console.warn(\'Push messaging is not supported\');\n }\n```\nPushManager 注册好之后, 那么要做的就是浏览器和服务器的绑定了。\n\n![这里写图片描述](https://img-blog.csdn.net/20171112203347222?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\n此图是用户订阅某个应用程序的推送服务。\n客户端传入应用程序服务器公钥,向将生成端点的 `webpush 服务器`( 这是谷歌自己实现的一个推送功能的服务器)发出网络请求,将生成的端点(一个推送服务)与应用程序公钥关联,并将端点返回给应用程序。浏览器会将此端点添加到 PushSubscription,通过 promise异步成功时,可以将它的信息保存到你的数据库。\n\n![这里写图片描述](https://img-blog.csdn.net/20171112203753820?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\n服务器发送推送的时候,请求相关接口,验证成功后推送服务会发消息给客户端。\n\n**最后关于桌面小图标**\n\n这个可以说是非常简单了,就是一个manifest.json配置文件,然后在页面引入此文件就好了\n\n```\n\x3c!-- 加载清单 --\x3e\n \n```\n关于[清单内容](https://developers.google.com/web/fundamentals/web-app-manifest/)这里简单介绍一下:\n\n```\n{\n "short_name": "pwa",\n "name": "pwa - demo", // 应用名称\n "icons": [ // 应用显示图标,根据容器大小适配\n {\n "src": "assets/imgs/48.png",\n "type": "image/png",\n "sizes": "48x48"\n },\n {\n "src": "assets/imgs/96.png",\n "type": "image/png",\n "sizes": "96x96"\n },\n {\n "src": "assets/imgs/192.png",\n "type": "image/png",\n "sizes": "192x192"\n }\n ],\n "background_color": "#2196F3", // 刚打开页面时的背景\n "theme_color": "#2196F3", // 主题颜色\n "display": "standalone", //独立显示\n "start_url": "index.html?launcher=true" // 启动的页面\n}\n```\n好了, 如果感兴趣赶快上手吧。\n可以查看[谷歌官方教程](https://developers.google.com/web/progressive-web-apps/)。\n\n这里说一下坑的点,\tPWA应用需要在本地localhost:8080 上运行或者 https 协议下, 要保证你的页面是安全页面。\n\n添加桌面时,确保你的谷歌浏览器可以显示弹出通知。\n\n如果你要自己实现推送,自己服务器要有公钥和私钥的获取, 这里可以通过 https://web-push-codelab.glitch.me 获取, 用 chrome 的 [webpush](https://github.com/zaru/webpush) 推送。\n\n这里也可以看一下我的[ GitHub 项项目 ](https://github.com/cleverboy32/chorme-PwaDemo),官方也有很多例子。'}}]);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"636.bundle.js","mappings":"mIAAA,0oK","sources":["webpack://react_wyz/../../blogs/markdown/pwa.md"],"sourcesContent":["export default \"### **什么是PWA** \\n先说一下全名，progressive web app： 渐进式网页应用。这是谷歌推出的，我是这样理解的：\\n\\n- 我们一般写web应用，在 pc 上是没有缓存的，打开页面的时去请求数据。\\n\\n-  第二个也没有像 app 一样的小图标放在桌面，一点开就进入了应用，而是通过打开浏览器输入网址， \\n\\n- 第三个就是，不能像 app 一样给用户推送消息，像微博会跟你推送说有谁评论了你的微博之类的功能。 \\n\\n而谷歌推出的 pwa，就是具有这些了这些特点， 使我们的 web 应用，能够像一款 app 一样使用。并且对比与 app, 它不用复杂的安装，也不用下载更新包，刷新页面就可以了(注意到缓存的处理)。\\n\\n#### **那么这些功能分别是怎么实现的呢？** \\n**关于缓存**\\n\\n其实这个就是 我们平时做的 Session 啊、localStorage、CacheStorage 之类的。\\n\\n这里用的就是 [cacheStorage](https://developer.mozilla.org/zh-CN/docs/Web/API/CacheStorage) 缓存，它提供了一个ServiceWorker类型的工作者或window范围可以访问的所有命名缓存的主目录, 并维护字符串的映射名称到相应的 Cache 对象。\\n主要方法包括： \\n![这里写图片描述](https://img-blog.csdn.net/20171112212302073?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\\n有了这些方法你可以对你的缓存进行操作。目前还在草案状态，仅火狐和谷歌浏览器支持此特性。\\n\\nPWA是通过 ServiceWorker 访问 cache ,所以需要注册 ServiceWorker 工作者。在之前别忘记判断浏览器是否支持。\\n\\n```\\nif ('serviceWorker' in navigator) {\\n\\tnavigator.serviceWorker.register(sw.js) // 注册sw.js 文件中变成的服务对象，返回注册成功的对象\\n\\t.then(function(swReg){\\n          swRegistration = swReg;\\n     }).catch(function(error) {\\n          console.error('Service Worker Error', error);\\n     });\\n}\\n```\\n这个 [Service Worker](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) 服务工作者就厉害了，它相当于浏览器和网络之间的代理服务器，可以拦截网络请求，做一些你可能需要的处理(请求资源从缓存中获取等)。\\n\\n-  它能够创建有效的离线体验，拦截网络请求，并根据网络是否可用判断是否使用缓存数据或者更新缓存数据。\\n\\n-  它们还允许访问推送的通知和后台的API。\\n\\n关于 sw.js 中具体的缓存的代码：\\n\\n创建需要缓存的文件\\n\\n```\\n'use strict'\\nlet cacheName = 'pwa-demo-assets'; // 缓存名字\\nlet imgCacheName = 'pwa-img';\\nlet filesToCache;\\nfilesToCache = [ // 所需缓存的文件\\n    '/',\\n    '/index.html',\\n    '/scripts/app.js',\\n    '/assets/imgs/48.png',\\n    '/assets/imgs/96.png',\\n    '/assets/imgs/192.png',\\n    '/dist/js/app.js',\\n    '/manifest.json'\\n];\\n\\nself.addEventListener('install', function(e) {\\n    e.waitUntil(\\n\\t    // 安装服务者时，对需要缓存的文件进行缓存\\n        caches.open(cacheName).then(function(cache) {\\n            return cache.addAll(filesToCache);\\n        })\\n    );\\n});\\n\\n\\nself.addEventListener('fetch', (e) => {\\n    // 判断地址是不是需要实时去请求，是就继续发送请求\\n    if (e.request.url.indexOf('/api/400/200') > -1) {\\n        e.respondWith(\\n            caches.open(imgCacheName).then(function(cache){\\n                 return fetch(e.request).then(function (response){\\n                    cache.put(e.request.url, response.clone()); // 每请求一次缓存更新一次新加载的图片\\n                    return response;\\n                });\\n            })\\n        );\\n    } else {\\n        e.respondWith(\\n\\t        // 匹配到缓存资源，就从缓存中返回数据\\n            caches.match(e.request).then(function (response) {\\n                return response || fetch(e.request);\\n            })\\n        );\\n    }\\n\\n});\\n```\\n\\n**这里进而就引入到 pwa 的推送通知功能。这都是通过 ServiceWorker 去实现的。**\\n\\n基本原理是，你的客户端要和推送服务进行绑定，会生成一个绑定后的推送服务API接口，服务端调用此接口，发送消息。同时，浏览器也要支持推送功能，在注册 sw 时, 加上推送功能的判断。\\n\\n```\\nif ('serviceWorker' in navigator && 'PushManager' in window) {\\n\\tnavigator.serviceWorker.register(sw.js)\\n\\t.then(function(swReg) {\\n        swRegistration = swReg;\\n    }).catch(function(error) {\\n        console.error('Service Worker Error', error);\\n        });\\n } else {\\n     console.warn('Push messaging is not supported');\\n }\\n```\\nPushManager 注册好之后， 那么要做的就是浏览器和服务器的绑定了。\\n\\n![这里写图片描述](https://img-blog.csdn.net/20171112203347222?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\\n此图是用户订阅某个应用程序的推送服务。\\n客户端传入应用程序服务器公钥，向将生成端点的 `webpush 服务器`( 这是谷歌自己实现的一个推送功能的服务器)发出网络请求，将生成的端点(一个推送服务)与应用程序公钥关联，并将端点返回给应用程序。浏览器会将此端点添加到 PushSubscription，通过 promise异步成功时，可以将它的信息保存到你的数据库。\\n\\n![这里写图片描述](https://img-blog.csdn.net/20171112203753820?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\\n服务器发送推送的时候,请求相关接口，验证成功后推送服务会发消息给客户端。\\n\\n**最后关于桌面小图标**\\n\\n这个可以说是非常简单了，就是一个manifest.json配置文件，然后在页面引入此文件就好了\\n\\n```\\n<!-- 加载清单 -->\\n<link rel=\\\"manifest\\\" href=\\\"./manifest.json\\\">\\n```\\n关于[清单内容](https://developers.google.com/web/fundamentals/web-app-manifest/)这里简单介绍一下：\\n\\n```\\n{\\n    \\\"short_name\\\": \\\"pwa\\\",\\n    \\\"name\\\": \\\"pwa - demo\\\", // 应用名称\\n    \\\"icons\\\": [ // 应用显示图标，根据容器大小适配\\n        {\\n            \\\"src\\\": \\\"assets/imgs/48.png\\\",\\n            \\\"type\\\": \\\"image/png\\\",\\n            \\\"sizes\\\": \\\"48x48\\\"\\n        },\\n        {\\n            \\\"src\\\": \\\"assets/imgs/96.png\\\",\\n            \\\"type\\\": \\\"image/png\\\",\\n            \\\"sizes\\\": \\\"96x96\\\"\\n        },\\n        {\\n            \\\"src\\\": \\\"assets/imgs/192.png\\\",\\n            \\\"type\\\": \\\"image/png\\\",\\n            \\\"sizes\\\": \\\"192x192\\\"\\n        }\\n    ],\\n    \\\"background_color\\\": \\\"#2196F3\\\", // 刚打开页面时的背景\\n    \\\"theme_color\\\": \\\"#2196F3\\\", // 主题颜色\\n    \\\"display\\\": \\\"standalone\\\", //独立显示\\n    \\\"start_url\\\": \\\"index.html?launcher=true\\\" // 启动的页面\\n}\\n```\\n好了， 如果感兴趣赶快上手吧。\\n可以查看[谷歌官方教程](https://developers.google.com/web/progressive-web-apps/)。\\n\\n这里说一下坑的点，\\tPWA应用需要在本地localhost:8080 上运行或者 https 协议下， 要保证你的页面是安全页面。\\n\\n添加桌面时，确保你的谷歌浏览器可以显示弹出通知。\\n\\n如果你要自己实现推送，自己服务器要有公钥和私钥的获取， 这里可以通过 https://web-push-codelab.glitch.me 获取， 用 chrome 的 [webpush](https://github.com/zaru/webpush) 推送。\\n\\n这里也可以看一下我的[ GitHub 项项目 ](https://github.com/cleverboy32/chorme-PwaDemo)，官方也有很多例子。\";"],"names":[],"sourceRoot":""}
\ No newline at end of file
diff --git a/643.bundle.js b/643.bundle.js
index 90100ac..71e29b8 100644
--- a/643.bundle.js
+++ b/643.bundle.js
@@ -1,2 +1,2 @@
-"use strict";(self.webpackChunkreact_wyz=self.webpackChunkreact_wyz||[]).push([[643],{643:(n,t,i)=>{i.r(t),i.d(t,{default:()=>o});const o='作为一个前端,写页面结构,写CSS怎么命名? \n就算不用,但你的了解, 让自己的代码更规范。\n\n##### BEM是什么\n它是css命名的一种规范。试想,你写了一个页面,有input, button, div, 这些元素是什么样的关系,给他们添加样式的时候,怎么知道他们是一个页面的? 怎么知道input 是否放在div里面的? 不要急,这就说到了下面的命名之作用\n\n#### BEM是怎么命名的\n```html\n\n\t\n\t\t \n\t\t确定 \t\n\t
\n\n```\n通过上面命名可以很直接看出,input 和button 在div 里面。\n这里讲 后面的 __input/__confim 这里后面接两个下划线,表示的是div里面的子元素。\n```html\n\n\t\n\t\t \n\t\t确定 \t\n\t
\n\n```\n这里说, --big表示添加的描述, 很明显是大的注册表单的样式嘛。\n\n#### BEM总结\n好了, 这里loggin-from 相当于一块整体(block), 里面包含了元素input/button(element), 还有这个块或者一些元素的修饰big(modifier) => BEM\n它一般和sass一起使用,在用@C代表块、 @d代表元素、 @m代码修饰符的时候, css可以这样写了\n```\n@C loggin-from {\n\twidth: 100px;\n\theight: 100px;\n\t@m big {\n\t\twidth: 200px;\n\t\theight: 200px;\n\t}\n\t@d input {\n\t\tcolor: red;\n\t}\n\t@d button {\n\t\tcolor: blue;\n\t}\n}\n```\n怎么样,这样是不是就不用写那么长了, 而且一看样式文件,就能知道页面布局是什么样的。\n**以上写法, 要通过sass 插件配置的**\n这里有一个包 ,可以使用[sass-bem-constructor](https://www.npmjs.com/package/sass-bem-constructor)'}}]);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
\ No newline at end of file
+"use strict";(self.webpackChunkcboy_blog=self.webpackChunkcboy_blog||[]).push([[643],{643:function(e,n,t){t.r(n),t.d(n,{default:function(){return s}});var r=t(762);const o={class:"component-typescript"},p={};var s=(0,t(314).A)(p,[["render",function(e,n){return(0,r.uX)(),(0,r.CE)("div",o,n[0]||(n[0]=[(0,r.Fv)('learn typescript 类型 基本类型:
string number bool \n
数组 []
:
string[] number[]\n
元祖:
[string, number]. 数组中有不同的数据类型\n
对象:
{ name: string; age: number }\n
函数:
(arg1: string, arg?: bool) => void\n
Symbol:
let symbol = Symbol("key"); \n
空:
undefined null\n
任何类型:
any\n
不存在的值:
never\n
如何定义类型 type
定义类型变量
type Person = { name: string; age: number}\nts 使用 const person1:Person = { name: '22', age: 1};\n
Interfaces
声明 对象
类型的一种方法
Interface Person { name: string; age: number}\n
extends
类型继承于声明的类型
interface a { name: string}\ninterface b extends a {\n\tage: number\n}\nb 的类型等于 { name: string; age: number }\n
in 判断属性是哪个类型中的
type PersonListQuery = { user_ids: string[] }\ntype DogListQuery = { dog_ids: string[] }\n\nfunction getList(query: PersonListQuery | DogListQuery ) {\n\tif ('user_ids' in PersonListQuery) {\n\t \t// 这里可以推导出 query 类型是 PersonListQuery\n\t}\n}\n\n
类型组合 Required<T>
将 T 中所有属性变成必选
Required<{ a?: bool} > = { a: bool }\n
Partial<T>
将 T 中所有属性变成可选
Partial<{ a: bool }> = { a?: bool }\n
Readonly<T>
将 T 中所有属性变成只读,后续 ts 会检测该类型不允许修改
const person2: Readonly<{name: string}> = {name: '22'}\nperson2.name = '33' //error\n
Omit<T, keys>
删除某些属性
interface Person {\n name: string;\n age: number;\n}\n \ntype Name = Omit<Person, 'age'>;\nName 的类型定义为 { name: string }\n
Pick<T, keys>
选择类型中的某些属性
interface Person {\n name: string;\n age: number;\n}\ntype Name = Pick<Person, 'name'>;\nName 的类型定义为 { name: string }\n
Exclude<T, deleteT>
删除类型 T 中 deleteT 的类型, 相当于 Omit, 第二个值可以是 keys ,也可以是一个类型变量
interface Person {\n name: string;\n age: number;\n}\ntype Age = { age: number }\ntype Name = Exclude<Person, Age>\nName 的类型定义为 { name: string }\n
Extract<T, U>
提取 T 继承于的 U 类型
type Person = { name: string ; age: number } \ntype PersonDetail = { pet: any; phone: number } \ntype Name = { name: string }\ntype Name = Extract<Person | PersonDetail , Name>\n 将提取出含有 name 的类型 Person\n
Parameters<function T>
获取函数类型的函数类型
type getName = (perpson: Person) => string;\ntype queryType = Parameters<getName>;\nqueryType 的类型定义为 Person\n
ReturnType<function T>
获取函数类型的返回值类型
type getName = (perpson: Person) => string;\ntype resType = ReturnType<getName>;\nvalueType 类型为 string\n
Awaited<Promise Type>
获取异步返回的值类型
type getPerson = (id: string) => Promise<Person>\ntype resType = ReturnType<getPerson> // Promise<Person>\ntype valueType = Awaited<resType> // Person\n
Record<K extends keyof any, T>
定义对象的 key 键类型
type Keys = 'name' | 'age' \ntype person = Record<Keys, any>\n// person 的属性只能为 name 和 age\n
NonNullable<T>
去除类型中定义的 null 和 undefined
type PersonHobby = hobby: string | undefined;\ntype Hobby = NonNullable<hobby>\nHobby 类型为 string\n
类型操作 typeof Object
获得对象
的类型
const person1 = { name: '22', age: 1}\ntype Person = typeof person1\nPerson 类型为 { name: string; age: number }\n
keyof T
获得类型中的属性
type Person = { name: string; age: number }\ntype Key = keyof Person \nkey 的类型为 'name' | 'age'\n
通常我们可以通过 keyof 约束对象的传参, 如
type Person = { name: string; age: number }\ntype Key = keyof Person;\ntype getPersonAtrribute = (person: Person, key: Key) => Person[Key];\n
或者某些情况下我们想知道一个对象的属性值
const workPerson = { \n\t'1': { name: '1', age: 1},\n\t'2': { name: '2', age: 2},\n}\ntype WorkPerson = typeof workPerson; // { '1': {name: string; age: number }, '2': {name: string; age: number }\ntype Key = keyof WorkPerson // '1' | '2'\ntype Person = WorkPerson[Key] // {name: string; age: number }\n
|
类型兼容
type width = 'string' | 'number';\n\n则 width 可以是 '32px' 也可以是 '32' 在 渲染时兼容两种类型\n
函数重载 定义不同类型的输入,推到出不同类型的输出
type PersonListQuery = { user_ids: string[] };\ntype DongListQuery = { dog_ids: string[] };\nfunction getList(request: PersonListQuery): Person[];\nfunction getList(request: DogListQuery): Dog[];\n\nfunction getList(query: PersonListQuery | DogListQuery) {\n if ('user_ids' in query) { \n return [] as Person[];\n } else {\n return [] as Dog[];\n }\n}\n\nconst a = getList({ personIds: [], region: 'us'})\n此时 a 的类型将能推到出是 Person[]\n
泛型 类型的传参。 用 T 标识,在实际运用时你传入什么类型,该类型就作为后续推导。
async function request<T>(url: string): Promise<T> {\n const res = await fetch(url)\n return res.json();\n}\n\nconst res = await request<Person>('getPersonInfo?id=1'); \n此时 ts 可以推导出 res 的类型是 Person\n
Infer 类型参数使用 通过 Infer 一个类型为变量,定义出获取类型的方法
type addResultType<T> = T extends { a: infer U, b: infer U } ? U : never;\ntype numberAdd = addResultType<{ a: 1, b: 2 }> // 推到出结果类型为 number\ntype textAdd = addResultType<{ a: 'hello', b: 'world' }> // 推到出结果类型为 string\n
枚举 enum 变量的值是约定的几个取值
const enum PageType {\n HOME = 'home',\n VIDEO = 'video',\n}\n\nfunction getPageUrl(page: PageType) {\n return {\n [PageType.VIDEO]: "/video",\n [PageType.HOME]: "/home",\n }[page];\n}\n
tsconfig 了解了 ts 对于类型的定义和各种规则后,我们则可以在编写 js 代码时利用并进行类型约束。于此同时,我们需要引入 typescript 库去获得这些 ts 能力。
如何引入 npm install typescript \n// 不必再多说\n
命令 typescript 包是有命令文件的,通常 ts 的运行则是通过 tsc 配合相关命令去执行的. 具体命令大家可以安装包之后通过 tsc -h 查看
如果你看了 tsc 命令,你会发现它是有很多命令的,并且有的命令还伴随这相关参数。在工作文件夹中,我们则通过配置文件 tsconfig.js
去配置,保证在项目中的运用。 配置参数这里就不细讲了,还是看官方文档靠谱点。
',85)]))}]])}}]);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"643.bundle.js","mappings":"6KAAeA,MAAM,wBCCfC,EAAS,CAAC,EAKhB,OAFiC,E,OAAA,GAAgBA,EAAQ,CAAC,CAAC,S,gCDJjDC,EAAAA,EAAAA,IAqNJ,MArNIC,EAqNJC,EAAA,KAAAA,EAAA,KArNNC,EAAAA,EAAAA,IAAA,+6N","sources":["webpack://cboy-blog/../../blogs/markdown/typescript.md","webpack://cboy-blog/../../blogs/markdown/typescript.md?e2d6"],"sourcesContent":["<template><div class=\"component-typescript\"><h2>learn typescript</h2>\n<h3>类型</h3>\n<p>基本类型:</p>\n<pre v-pre=\"\"><code>string number bool \n</code></pre>\n<p>数组 <code>[]</code>:</p>\n<pre v-pre=\"\"><code>string[]  number[]\n</code></pre>\n<p>元祖:</p>\n<pre v-pre=\"\"><code>[string, number]. 数组中有不同的数据类型\n</code></pre>\n<p>对象:</p>\n<pre v-pre=\"\"><code>{ name: string; age: number }\n</code></pre>\n<p>函数：</p>\n<pre v-pre=\"\"><code>(arg1: string, arg?: bool) =&gt; void\n</code></pre>\n<p>Symbol:</p>\n<pre v-pre=\"\"><code>let symbol = Symbol(\"key\"); \n</code></pre>\n<p>空：</p>\n<pre v-pre=\"\"><code>undefined   null\n</code></pre>\n<p>任何类型：</p>\n<pre v-pre=\"\"><code>any\n</code></pre>\n<p>不存在的值：</p>\n<pre v-pre=\"\"><code>never\n</code></pre>\n<h3>如何定义类型</h3>\n<p><code>type</code>  定义类型变量</p>\n<pre v-pre=\"\"><code>type Person = { name: string; age: number}\nts 使用 const person1：Person = { name: '22', age: 1};\n</code></pre>\n<p><code>Interfaces</code> 声明 <code>对象</code> 类型的一种方法</p>\n<pre v-pre=\"\"><code>Interface Person { name: string; age: number}\n</code></pre>\n<p><code>extends</code> 类型继承于声明的类型</p>\n<pre v-pre=\"\"><code>interface a { name: string}\ninterface b extends a {\n\tage: number\n}\nb 的类型等于 { name: string; age: number }\n</code></pre>\n<p>in 判断属性是哪个类型中的</p>\n<pre v-pre=\"\"><code>type PersonListQuery = { user_ids: string[] }\ntype DogListQuery = { dog_ids: string[] }\n\nfunction getList(query: PersonListQuery | DogListQuery ) {\n\tif ('user_ids' in PersonListQuery) {\n\t \t// 这里可以推导出 query 类型是 PersonListQuery\n\t}\n}\n\n</code></pre>\n<h3>类型组合</h3>\n<p><code>Required&lt;T&gt;</code> 将 T 中所有属性变成必选</p>\n<pre v-pre=\"\"><code>Required&lt;{ a?: bool} &gt; = { a: bool }\n</code></pre>\n<p><code>Partial&lt;T&gt;</code> 将 T 中所有属性变成可选</p>\n<pre v-pre=\"\"><code>Partial&lt;{ a: bool }&gt; = { a?: bool }\n</code></pre>\n<p><code>Readonly&lt;T&gt;</code> 将 T 中所有属性变成只读，后续 ts 会检测该类型不允许修改</p>\n<pre v-pre=\"\"><code>const person2: Readonly&lt;{name: string}&gt; = {name: '22'}\nperson2.name = '33' //error\n</code></pre>\n<p><code>Omit&lt;T, keys&gt;</code> 删除某些属性</p>\n<pre v-pre=\"\"><code>interface Person {\n  name: string;\n  age: number;\n}\n \ntype Name = Omit&lt;Person, 'age'&gt;;\nName 的类型定义为 { name: string }\n</code></pre>\n<p><code>Pick&lt;T, keys&gt;</code> 选择类型中的某些属性</p>\n<pre v-pre=\"\"><code>interface Person {\n  name: string;\n  age: number;\n}\ntype Name = Pick&lt;Person, 'name'&gt;;\nName 的类型定义为 { name: string }\n</code></pre>\n<p><code>Exclude&lt;T, deleteT&gt;</code> 删除类型 T 中 deleteT 的类型， 相当于 Omit, 第二个值可以是 keys ，也可以是一个类型变量</p>\n<pre v-pre=\"\"><code>interface Person {\n  name: string;\n  age: number;\n}\ntype Age = { age: number }\ntype Name = Exclude&lt;Person, Age&gt;\nName 的类型定义为 { name: string }\n</code></pre>\n<p><code>Extract&lt;T, U&gt;</code> 提取 T 继承于的 U 类型</p>\n<pre v-pre=\"\"><code>type Person = {  name: string ; age: number } \ntype PersonDetail = { pet: any; phone: number } \ntype Name = { name: string }\ntype Name = Extract&lt;Person | PersonDetail , Name&gt;\n 将提取出含有 name 的类型 Person\n</code></pre>\n<p><code>Parameters&lt;function T&gt;</code> 获取函数类型的函数类型</p>\n<pre v-pre=\"\"><code>type getName = (perpson: Person) =&gt; string;\ntype queryType = Parameters&lt;getName&gt;;\nqueryType  的类型定义为 Person\n</code></pre>\n<p><code>ReturnType&lt;function T&gt;</code> 获取函数类型的返回值类型</p>\n<pre v-pre=\"\"><code>type getName = (perpson: Person) =&gt; string;\ntype resType = ReturnType&lt;getName&gt;;\nvalueType 类型为 string\n</code></pre>\n<p><code>Awaited&lt;Promise Type&gt;</code> 获取异步返回的值类型</p>\n<pre v-pre=\"\"><code>type getPerson = (id: string) =&gt; Promise&lt;Person&gt;\ntype resType = ReturnType&lt;getPerson&gt; // Promise&lt;Person&gt;\ntype valueType = Awaited&lt;resType&gt; // Person\n</code></pre>\n<p><code>Record&lt;K extends keyof any, T&gt;</code>  定义对象的 key 键类型</p>\n<pre v-pre=\"\"><code>type Keys = 'name' | 'age' \ntype person = Record&lt;Keys, any&gt;\n// person 的属性只能为 name 和 age\n</code></pre>\n<p><code>NonNullable&lt;T&gt;</code> 去除类型中定义的 null 和 undefined</p>\n<pre v-pre=\"\"><code>type PersonHobby = hobby: string | undefined;\ntype Hobby = NonNullable&lt;hobby&gt;\nHobby 类型为  string\n</code></pre>\n<h3>类型操作</h3>\n<p><code>typeof Object</code> 获得<code>对象</code>的类型</p>\n<pre v-pre=\"\"><code>const person1 = { name: '22', age: 1}\ntype Person = typeof person1\nPerson 类型为 { name: string; age: number }\n</code></pre>\n<p><code>keyof T</code>  获得类型中的属性</p>\n<pre v-pre=\"\"><code>type Person = { name: string; age: number }\ntype Key = keyof Person \nkey 的类型为 'name' | 'age'\n</code></pre>\n<p>通常我们可以通过 keyof 约束对象的传参， 如</p>\n<pre v-pre=\"\"><code>type Person = { name: string; age: number }\ntype Key = keyof Person;\ntype getPersonAtrribute = (person: Person, key: Key) =&gt; Person[Key];\n</code></pre>\n<p>或者某些情况下我们想知道一个对象的属性值</p>\n<pre v-pre=\"\"><code>const workPerson = { \n\t'1': { name: '1', age: 1},\n\t'2': { name: '2', age: 2},\n}\ntype WorkPerson  = typeof workPerson;  // { '1': {name: string; age: number }, '2': {name: string; age: number }\ntype Key = keyof WorkPerson  // '1' | '2'\ntype Person = WorkPerson[Key]   // {name: string; age: number }\n</code></pre>\n<p><code>|</code> 类型兼容</p>\n<pre v-pre=\"\"><code>type width = 'string' | 'number';\n\n则 width 可以是 '32px' 也可以是 '32' 在 渲染时兼容两种类型\n</code></pre>\n<h3>函数重载</h3>\n<p>定义不同类型的输入，推到出不同类型的输出</p>\n<pre v-pre=\"\"><code>type PersonListQuery = { user_ids: string[] };\ntype DongListQuery = { dog_ids: string[] };\nfunction getList(request: PersonListQuery): Person[];\nfunction getList(request: DogListQuery): Dog[];\n\nfunction getList(query: PersonListQuery | DogListQuery) {\n  if ('user_ids' in query) {  \n    return [] as Person[];\n  } else {\n    return [] as Dog[];\n  }\n}\n\nconst a = getList({ personIds: [], region: 'us'})\n此时 a 的类型将能推到出是 Person[]\n</code></pre>\n<h3>泛型</h3>\n<p>类型的传参。 用 T 标识，在实际运用时你传入什么类型，该类型就作为后续推导。</p>\n<pre v-pre=\"\"><code>async function request&lt;T&gt;(url: string): Promise&lt;T&gt; {\n  const res = await fetch(url)\n  return res.json();\n}\n\nconst res = await request&lt;Person&gt;('getPersonInfo?id=1'); \n此时 ts 可以推导出 res 的类型是 Person\n</code></pre>\n<h3>Infer  类型参数使用</h3>\n<p>通过 Infer 一个类型为变量，定义出获取类型的方法</p>\n<pre v-pre=\"\"><code>type addResultType&lt;T&gt; = T extends { a: infer U, b: infer U } ?  U : never;\ntype numberAdd =  addResultType&lt;{ a: 1, b: 2 }&gt;     // 推到出结果类型为 number\ntype textAdd = addResultType&lt;{ a: 'hello', b: 'world' }&gt;     // 推到出结果类型为 string\n</code></pre>\n<h3>枚举 enum</h3>\n<p>变量的值是约定的几个取值</p>\n<pre v-pre=\"\"><code>const enum PageType {\n  HOME = 'home',\n  VIDEO = 'video',\n}\n\nfunction getPageUrl(page: PageType) {\n  return {\n    [PageType.VIDEO]: \"/video\",\n    [PageType.HOME]: \"/home\",\n  }[page];\n}\n</code></pre>\n<h2>tsconfig</h2>\n<p>了解了 ts 对于类型的定义和各种规则后，我们则可以在编写 js 代码时利用并进行类型约束。于此同时，我们需要引入 typescript 库去获得这些 ts 能力。</p>\n<h3>如何引入</h3>\n<pre v-pre=\"\"><code>npm install  typescript  \n// 不必再多说\n</code></pre>\n<h3>命令</h3>\n<p>typescript 包是有命令文件的，通常 ts 的运行则是通过 tsc 配合相关命令去执行的. 具体命令大家可以安装包之后通过 tsc -h 查看\n<img src=\"https://i-blog.csdnimg.cn/blog_migrate/349ffc362f0d831a780d2d7f754893a1.png\" alt=\"在这里插入图片描述\"></p>\n<h3>配置 <a href=\"https://www.typescriptlang.org/docs/handbook/tsconfig-json.html\">官网</a></h3>\n<p>如果你看了 tsc 命令，你会发现它是有很多命令的，并且有的命令还伴随这相关参数。在工作文件夹中，我们则通过配置文件 <code>tsconfig.js </code> 去配置，保证在项目中的运用。 配置参数这里就不细讲了，还是看官方文档靠谱点。</p>\n</div></template>","import { render } from \"./typescript.md?vue&type=template&id=3dde7082\"\nconst script = {}\n\nimport exportComponent from \"../../node_modules/.pnpm/vue-loader@17.4.2_@vue+compiler-sfc@3.5.12_vue@3.5.12_typescript@5.6.3__webpack@5.95.0_webpack-cli@5.1.4_/node_modules/vue-loader/dist/exportHelper.js\"\nconst __exports__ = /*#__PURE__*/exportComponent(script, [['render',render]])\n\nexport default __exports__"],"names":["class","script","_createElementBlock","_hoisted_1","_cache","_createStaticVNode"],"sourceRoot":""}
\ No newline at end of file
diff --git a/674.bundle.js b/674.bundle.js
new file mode 100644
index 0000000..34015f1
--- /dev/null
+++ b/674.bundle.js
@@ -0,0 +1,3 @@
+/*! For license information please see 674.bundle.js.LICENSE.txt */
+(self.webpackChunkreact_wyz=self.webpackChunkreact_wyz||[]).push([[674],{7674:function(e){e.exports=function(){"use strict";function e(t){return e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},e(t)}function t(e,n){return t=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e},t(e,n)}function n(e,r,o){return n=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}()?Reflect.construct:function(e,n,r){var o=[null];o.push.apply(o,n);var a=new(Function.bind.apply(e,o));return r&&t(a,r.prototype),a},n.apply(null,arguments)}function r(e){return function(e){if(Array.isArray(e))return o(e)}(e)||function(e){if("undefined"!=typeof Symbol&&null!=e[Symbol.iterator]||null!=e["@@iterator"])return Array.from(e)}(e)||function(e,t){if(e){if("string"==typeof e)return o(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);return"Object"===n&&e.constructor&&(n=e.constructor.name),"Map"===n||"Set"===n?Array.from(e):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?o(e,t):void 0}}(e)||function(){throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function o(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n1?n-1:0),o=1;o/gm),q=m(/\${[\w\W]*}/gm),Y=m(/^data-[\-\w.\u00B7-\uFFFF]/),$=m(/^aria-[\-\w]+$/),K=m(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i),V=m(/^(?:\w+script|data):/i),X=m(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g),Z=m(/^html$/i),J=m(/^[a-z][.\w]*(-[.\w]+)+$/i),Q=function(){return"undefined"==typeof window?null:window};return function t(){var n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:Q(),o=function(e){return t(e)};if(o.version="2.5.7",o.removed=[],!n||!n.document||9!==n.document.nodeType)return o.isSupported=!1,o;var a=n.document,i=n.document,l=n.DocumentFragment,c=n.HTMLTemplateElement,u=n.Node,m=n.Element,f=n.NodeFilter,p=n.NamedNodeMap,d=void 0===p?n.NamedNodeMap||n.MozNamedAttrMap:p,h=n.HTMLFormElement,g=n.DOMParser,x=n.trustedTypes,ee=m.prototype,te=L(ee,"cloneNode"),ne=L(ee,"nextSibling"),re=L(ee,"childNodes"),oe=L(ee,"parentNode");if("function"==typeof c){var ae=i.createElement("template");ae.content&&ae.content.ownerDocument&&(i=ae.content.ownerDocument)}var ie=function(t,n){if("object"!==e(t)||"function"!=typeof t.createPolicy)return null;var r=null,o="data-tt-policy-suffix";n.currentScript&&n.currentScript.hasAttribute(o)&&(r=n.currentScript.getAttribute(o));var a="dompurify"+(r?"#"+r:"");try{return t.createPolicy(a,{createHTML:function(e){return e},createScriptURL:function(e){return e}})}catch(e){return console.warn("TrustedTypes policy "+a+" could not be created."),null}}(x,a),le=ie?ie.createHTML(""):"",ce=i,ue=ce.implementation,se=ce.createNodeIterator,me=ce.createDocumentFragment,fe=ce.getElementsByTagName,pe=a.importNode,de={};try{de=C(i).documentMode?i.documentMode:{}}catch(e){}var he={};o.isSupported="function"==typeof oe&&ue&&void 0!==ue.createHTMLDocument&&9!==de;var ge,ye,be=G,Te=W,ve=q,Ne=Y,Ee=$,Ae=V,we=X,_e=J,Se=K,ke=null,xe=O({},[].concat(r(R),r(D),r(M),r(F),r(H))),Oe=null,Ce=O({},[].concat(r(z),r(P),r(B),r(j))),Le=Object.seal(Object.create(null,{tagNameCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},attributeNameCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},allowCustomizedBuiltInElements:{writable:!0,configurable:!1,enumerable:!0,value:!1}})),Re=null,De=null,Me=!0,Ie=!0,Fe=!1,Ue=!0,He=!1,ze=!0,Pe=!1,Be=!1,je=!1,Ge=!1,We=!1,qe=!1,Ye=!0,$e=!1,Ke=!0,Ve=!1,Xe={},Ze=null,Je=O({},["annotation-xml","audio","colgroup","desc","foreignobject","head","iframe","math","mi","mn","mo","ms","mtext","noembed","noframes","noscript","plaintext","script","style","svg","template","thead","title","video","xmp"]),Qe=null,et=O({},["audio","video","img","source","image","track"]),tt=null,nt=O({},["alt","class","for","id","label","name","pattern","placeholder","role","summary","title","value","style","xmlns"]),rt="http://www.w3.org/1998/Math/MathML",ot="http://www.w3.org/2000/svg",at="http://www.w3.org/1999/xhtml",it=at,lt=!1,ct=null,ut=O({},[rt,ot,at],N),st=["application/xhtml+xml","text/html"],mt=null,ft=i.createElement("form"),pt=function(e){return e instanceof RegExp||e instanceof Function},dt=function(t){mt&&mt===t||(t&&"object"===e(t)||(t={}),t=C(t),ge=ge=-1===st.indexOf(t.PARSER_MEDIA_TYPE)?"text/html":t.PARSER_MEDIA_TYPE,ye="application/xhtml+xml"===ge?N:v,ke="ALLOWED_TAGS"in t?O({},t.ALLOWED_TAGS,ye):xe,Oe="ALLOWED_ATTR"in t?O({},t.ALLOWED_ATTR,ye):Ce,ct="ALLOWED_NAMESPACES"in t?O({},t.ALLOWED_NAMESPACES,N):ut,tt="ADD_URI_SAFE_ATTR"in t?O(C(nt),t.ADD_URI_SAFE_ATTR,ye):nt,Qe="ADD_DATA_URI_TAGS"in t?O(C(et),t.ADD_DATA_URI_TAGS,ye):et,Ze="FORBID_CONTENTS"in t?O({},t.FORBID_CONTENTS,ye):Je,Re="FORBID_TAGS"in t?O({},t.FORBID_TAGS,ye):{},De="FORBID_ATTR"in t?O({},t.FORBID_ATTR,ye):{},Xe="USE_PROFILES"in t&&t.USE_PROFILES,Me=!1!==t.ALLOW_ARIA_ATTR,Ie=!1!==t.ALLOW_DATA_ATTR,Fe=t.ALLOW_UNKNOWN_PROTOCOLS||!1,Ue=!1!==t.ALLOW_SELF_CLOSE_IN_ATTR,He=t.SAFE_FOR_TEMPLATES||!1,ze=!1!==t.SAFE_FOR_XML,Pe=t.WHOLE_DOCUMENT||!1,Ge=t.RETURN_DOM||!1,We=t.RETURN_DOM_FRAGMENT||!1,qe=t.RETURN_TRUSTED_TYPE||!1,je=t.FORCE_BODY||!1,Ye=!1!==t.SANITIZE_DOM,$e=t.SANITIZE_NAMED_PROPS||!1,Ke=!1!==t.KEEP_CONTENT,Ve=t.IN_PLACE||!1,Se=t.ALLOWED_URI_REGEXP||Se,it=t.NAMESPACE||at,Le=t.CUSTOM_ELEMENT_HANDLING||{},t.CUSTOM_ELEMENT_HANDLING&&pt(t.CUSTOM_ELEMENT_HANDLING.tagNameCheck)&&(Le.tagNameCheck=t.CUSTOM_ELEMENT_HANDLING.tagNameCheck),t.CUSTOM_ELEMENT_HANDLING&&pt(t.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)&&(Le.attributeNameCheck=t.CUSTOM_ELEMENT_HANDLING.attributeNameCheck),t.CUSTOM_ELEMENT_HANDLING&&"boolean"==typeof t.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements&&(Le.allowCustomizedBuiltInElements=t.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements),He&&(Ie=!1),We&&(Ge=!0),Xe&&(ke=O({},r(H)),Oe=[],!0===Xe.html&&(O(ke,R),O(Oe,z)),!0===Xe.svg&&(O(ke,D),O(Oe,P),O(Oe,j)),!0===Xe.svgFilters&&(O(ke,M),O(Oe,P),O(Oe,j)),!0===Xe.mathMl&&(O(ke,F),O(Oe,B),O(Oe,j))),t.ADD_TAGS&&(ke===xe&&(ke=C(ke)),O(ke,t.ADD_TAGS,ye)),t.ADD_ATTR&&(Oe===Ce&&(Oe=C(Oe)),O(Oe,t.ADD_ATTR,ye)),t.ADD_URI_SAFE_ATTR&&O(tt,t.ADD_URI_SAFE_ATTR,ye),t.FORBID_CONTENTS&&(Ze===Je&&(Ze=C(Ze)),O(Ze,t.FORBID_CONTENTS,ye)),Ke&&(ke["#text"]=!0),Pe&&O(ke,["html","head","body"]),ke.table&&(O(ke,["tbody"]),delete Re.tbody),s&&s(t),mt=t)},ht=O({},["mi","mo","mn","ms","mtext"]),gt=O({},["annotation-xml"]),yt=O({},["title","style","font","a","script"]),bt=O({},D);O(bt,M),O(bt,I);var Tt=O({},F);O(Tt,U);var vt=function(e){T(o.removed,{element:e});try{e.parentNode.removeChild(e)}catch(t){try{e.outerHTML=le}catch(t){e.remove()}}},Nt=function(e,t){try{T(o.removed,{attribute:t.getAttributeNode(e),from:t})}catch(e){T(o.removed,{attribute:null,from:t})}if(t.removeAttribute(e),"is"===e&&!Oe[e])if(Ge||We)try{vt(t)}catch(e){}else try{t.setAttribute(e,"")}catch(e){}},Et=function(e){var t,n;if(je)e=" "+e;else{var r=E(e,/^[\r\n\t ]+/);n=r&&r[0]}"application/xhtml+xml"===ge&&it===at&&(e=''+e+"");var o=ie?ie.createHTML(e):e;if(it===at)try{t=(new g).parseFromString(o,ge)}catch(e){}if(!t||!t.documentElement){t=ue.createDocument(it,"template",null);try{t.documentElement.innerHTML=lt?le:o}catch(e){}}var a=t.body||t.documentElement;return e&&n&&a.insertBefore(i.createTextNode(n),a.childNodes[0]||null),it===at?fe.call(t,Pe?"html":"body")[0]:Pe?t.documentElement:a},At=function(e){return se.call(e.ownerDocument||e,e,f.SHOW_ELEMENT|f.SHOW_COMMENT|f.SHOW_TEXT|f.SHOW_PROCESSING_INSTRUCTION|f.SHOW_CDATA_SECTION,null,!1)},wt=function(e){return e instanceof h&&("string"!=typeof e.nodeName||"string"!=typeof e.textContent||"function"!=typeof e.removeChild||!(e.attributes instanceof d)||"function"!=typeof e.removeAttribute||"function"!=typeof e.setAttribute||"string"!=typeof e.namespaceURI||"function"!=typeof e.insertBefore||"function"!=typeof e.hasChildNodes)},_t=function(t){return"object"===e(u)?t instanceof u:t&&"object"===e(t)&&"number"==typeof t.nodeType&&"string"==typeof t.nodeName},St=function(e,t,n){he[e]&&y(he[e],(function(e){e.call(o,t,n,mt)}))},kt=function(e){var t;if(St("beforeSanitizeElements",e,null),wt(e))return vt(e),!0;if(S(/[\u0080-\uFFFF]/,e.nodeName))return vt(e),!0;var n=ye(e.nodeName);if(St("uponSanitizeElement",e,{tagName:n,allowedTags:ke}),e.hasChildNodes()&&!_t(e.firstElementChild)&&(!_t(e.content)||!_t(e.content.firstElementChild))&&S(/<[/\w]/g,e.innerHTML)&&S(/<[/\w]/g,e.textContent))return vt(e),!0;if("select"===n&&S(/=0;--i){var l=te(a[i],!0);l.__removalCount=(e.__removalCount||0)+1,r.insertBefore(l,ne(e))}}return vt(e),!0}return e instanceof m&&!function(e){var t=oe(e);t&&t.tagName||(t={namespaceURI:it,tagName:"template"});var n=v(e.tagName),r=v(t.tagName);return!!ct[e.namespaceURI]&&(e.namespaceURI===ot?t.namespaceURI===at?"svg"===n:t.namespaceURI===rt?"svg"===n&&("annotation-xml"===r||ht[r]):Boolean(bt[n]):e.namespaceURI===rt?t.namespaceURI===at?"math"===n:t.namespaceURI===ot?"math"===n&>[r]:Boolean(Tt[n]):e.namespaceURI===at?!(t.namespaceURI===ot&&!gt[r])&&!(t.namespaceURI===rt&&!ht[r])&&!Tt[n]&&(yt[n]||!bt[n]):!("application/xhtml+xml"!==ge||!ct[e.namespaceURI]))}(e)?(vt(e),!0):"noscript"!==n&&"noembed"!==n&&"noframes"!==n||!S(/<\/no(script|embed|frames)/i,e.innerHTML)?(He&&3===e.nodeType&&(t=e.textContent,t=A(t,be," "),t=A(t,Te," "),t=A(t,ve," "),e.textContent!==t&&(T(o.removed,{element:e.cloneNode()}),e.textContent=t)),St("afterSanitizeElements",e,null),!1):(vt(e),!0)},xt=function(e,t,n){if(Ye&&("id"===t||"name"===t)&&(n in i||n in ft))return!1;if(Ie&&!De[t]&&S(Ne,t));else if(Me&&S(Ee,t));else if(!Oe[t]||De[t]){if(!(Ot(e)&&(Le.tagNameCheck instanceof RegExp&&S(Le.tagNameCheck,e)||Le.tagNameCheck instanceof Function&&Le.tagNameCheck(e))&&(Le.attributeNameCheck instanceof RegExp&&S(Le.attributeNameCheck,t)||Le.attributeNameCheck instanceof Function&&Le.attributeNameCheck(t))||"is"===t&&Le.allowCustomizedBuiltInElements&&(Le.tagNameCheck instanceof RegExp&&S(Le.tagNameCheck,n)||Le.tagNameCheck instanceof Function&&Le.tagNameCheck(n))))return!1}else if(tt[t]);else if(S(Se,A(n,we,"")));else if("src"!==t&&"xlink:href"!==t&&"href"!==t||"script"===e||0!==w(n,"data:")||!Qe[e])if(Fe&&!S(Ae,A(n,we,"")));else if(n)return!1;return!0},Ot=function(e){return"annotation-xml"!==e&&E(e,_e)},Ct=function(t){var n,r,a,i;St("beforeSanitizeAttributes",t,null);var l=t.attributes;if(l){var c={attrName:"",attrValue:"",keepAttr:!0,allowedAttributes:Oe};for(i=l.length;i--;){var u=n=l[i],s=u.name,m=u.namespaceURI;if(r="value"===s?n.value:_(n.value),a=ye(s),c.attrName=a,c.attrValue=r,c.keepAttr=!0,c.forceKeepAttr=void 0,St("uponSanitizeAttribute",t,c),r=c.attrValue,!c.forceKeepAttr&&(Nt(s,t),c.keepAttr))if(Ue||!S(/\/>/i,r)){He&&(r=A(r,be," "),r=A(r,Te," "),r=A(r,ve," "));var f=ye(t.nodeName);if(xt(f,a,r))if(!$e||"id"!==a&&"name"!==a||(Nt(s,t),r="user-content-"+r),ze&&S(/((--!?|])>)|<\/(style|title)/i,r))Nt(s,t);else{if(ie&&"object"===e(x)&&"function"==typeof x.getAttributeType)if(m);else switch(x.getAttributeType(f,a)){case"TrustedHTML":r=ie.createHTML(r);break;case"TrustedScriptURL":r=ie.createScriptURL(r)}try{m?t.setAttributeNS(m,s,r):t.setAttribute(s,r),wt(t)?vt(t):b(o.removed)}catch(e){}}}else Nt(s,t)}St("afterSanitizeAttributes",t,null)}},Lt=function e(t){var n,r=At(t);for(St("beforeSanitizeShadowDOM",t,null);n=r.nextNode();)St("uponSanitizeShadowNode",n,null),kt(n)||(n.content instanceof l&&e(n.content),Ct(n));St("afterSanitizeShadowDOM",t,null)};return o.sanitize=function(t){var r,i,c,s,m,f=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};if((lt=!t)&&(t="\x3c!--\x3e"),"string"!=typeof t&&!_t(t)){if("function"!=typeof t.toString)throw k("toString is not a function");if("string"!=typeof(t=t.toString()))throw k("dirty is not a string, aborting")}if(!o.isSupported){if("object"===e(n.toStaticHTML)||"function"==typeof n.toStaticHTML){if("string"==typeof t)return n.toStaticHTML(t);if(_t(t))return n.toStaticHTML(t.outerHTML)}return t}if(Be||dt(f),o.removed=[],"string"==typeof t&&(Ve=!1),Ve){if(t.nodeName){var p=ye(t.nodeName);if(!ke[p]||Re[p])throw k("root node is forbidden and cannot be sanitized in-place")}}else if(t instanceof u)1===(i=(r=Et("\x3c!----\x3e")).ownerDocument.importNode(t,!0)).nodeType&&"BODY"===i.nodeName||"HTML"===i.nodeName?r=i:r.appendChild(i);else{if(!Ge&&!He&&!Pe&&-1===t.indexOf("<"))return ie&&qe?ie.createHTML(t):t;if(!(r=Et(t)))return Ge?null:qe?le:""}r&&je&&vt(r.firstChild);for(var d=At(Ve?t:r);c=d.nextNode();)3===c.nodeType&&c===s||kt(c)||(c.content instanceof l&&Lt(c.content),Ct(c),s=c);if(s=null,Ve)return t;if(Ge){if(We)for(m=me.call(r.ownerDocument);r.firstChild;)m.appendChild(r.firstChild);else m=r;return(Oe.shadowroot||Oe.shadowrootmod)&&(m=pe.call(a,m,!0)),m}var h=Pe?r.outerHTML:r.innerHTML;return Pe&&ke["!doctype"]&&r.ownerDocument&&r.ownerDocument.doctype&&r.ownerDocument.doctype.name&&S(Z,r.ownerDocument.doctype.name)&&(h="\n"+h),He&&(h=A(h,be," "),h=A(h,Te," "),h=A(h,ve," ")),ie&&qe?ie.createHTML(h):h},o.setConfig=function(e){dt(e),Be=!0},o.clearConfig=function(){mt=null,Be=!1},o.isValidAttribute=function(e,t,n){mt||dt({});var r=ye(e),o=ye(t);return xt(r,o,n)},o.addHook=function(e,t){"function"==typeof t&&(he[e]=he[e]||[],T(he[e],t))},o.removeHook=function(e){if(he[e])return b(he[e])},o.removeHooks=function(e){he[e]&&(he[e]=[])},o.removeAllHooks=function(){he={}},o}()}()}}]);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"674.bundle.js","mappings":"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","sources":["webpack://react_wyz/../../node_modules/.pnpm/dompurify@2.5.7/node_modules/dompurify/dist/purify.js"],"sourcesContent":["/*! @license DOMPurify 2.5.7 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/2.5.7/LICENSE */\n\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.DOMPurify = factory());\n})(this, (function () { 'use strict';\n\n  function _typeof(obj) {\n    \"@babel/helpers - typeof\";\n\n    return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n      return typeof obj;\n    } : function (obj) {\n      return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    }, _typeof(obj);\n  }\n  function _setPrototypeOf(o, p) {\n    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n      o.__proto__ = p;\n      return o;\n    };\n    return _setPrototypeOf(o, p);\n  }\n  function _isNativeReflectConstruct() {\n    if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n    if (Reflect.construct.sham) return false;\n    if (typeof Proxy === \"function\") return true;\n    try {\n      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n  function _construct(Parent, args, Class) {\n    if (_isNativeReflectConstruct()) {\n      _construct = Reflect.construct;\n    } else {\n      _construct = function _construct(Parent, args, Class) {\n        var a = [null];\n        a.push.apply(a, args);\n        var Constructor = Function.bind.apply(Parent, a);\n        var instance = new Constructor();\n        if (Class) _setPrototypeOf(instance, Class.prototype);\n        return instance;\n      };\n    }\n    return _construct.apply(null, arguments);\n  }\n  function _toConsumableArray(arr) {\n    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();\n  }\n  function _arrayWithoutHoles(arr) {\n    if (Array.isArray(arr)) return _arrayLikeToArray(arr);\n  }\n  function _iterableToArray(iter) {\n    if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n  }\n  function _unsupportedIterableToArray(o, minLen) {\n    if (!o) return;\n    if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n    var n = Object.prototype.toString.call(o).slice(8, -1);\n    if (n === \"Object\" && o.constructor) n = o.constructor.name;\n    if (n === \"Map\" || n === \"Set\") return Array.from(o);\n    if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n  }\n  function _arrayLikeToArray(arr, len) {\n    if (len == null || len > arr.length) len = arr.length;\n    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n    return arr2;\n  }\n  function _nonIterableSpread() {\n    throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n\n  var hasOwnProperty = Object.hasOwnProperty,\n    setPrototypeOf = Object.setPrototypeOf,\n    isFrozen = Object.isFrozen,\n    getPrototypeOf = Object.getPrototypeOf,\n    getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n  var freeze = Object.freeze,\n    seal = Object.seal,\n    create = Object.create; // eslint-disable-line import/no-mutable-exports\n  var _ref = typeof Reflect !== 'undefined' && Reflect,\n    apply = _ref.apply,\n    construct = _ref.construct;\n  if (!apply) {\n    apply = function apply(fun, thisValue, args) {\n      return fun.apply(thisValue, args);\n    };\n  }\n  if (!freeze) {\n    freeze = function freeze(x) {\n      return x;\n    };\n  }\n  if (!seal) {\n    seal = function seal(x) {\n      return x;\n    };\n  }\n  if (!construct) {\n    construct = function construct(Func, args) {\n      return _construct(Func, _toConsumableArray(args));\n    };\n  }\n  var arrayForEach = unapply(Array.prototype.forEach);\n  var arrayPop = unapply(Array.prototype.pop);\n  var arrayPush = unapply(Array.prototype.push);\n  var stringToLowerCase = unapply(String.prototype.toLowerCase);\n  var stringToString = unapply(String.prototype.toString);\n  var stringMatch = unapply(String.prototype.match);\n  var stringReplace = unapply(String.prototype.replace);\n  var stringIndexOf = unapply(String.prototype.indexOf);\n  var stringTrim = unapply(String.prototype.trim);\n  var regExpTest = unapply(RegExp.prototype.test);\n  var typeErrorCreate = unconstruct(TypeError);\n  function unapply(func) {\n    return function (thisArg) {\n      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n        args[_key - 1] = arguments[_key];\n      }\n      return apply(func, thisArg, args);\n    };\n  }\n  function unconstruct(func) {\n    return function () {\n      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n        args[_key2] = arguments[_key2];\n      }\n      return construct(func, args);\n    };\n  }\n\n  /* Add properties to a lookup table */\n  function addToSet(set, array, transformCaseFunc) {\n    var _transformCaseFunc;\n    transformCaseFunc = (_transformCaseFunc = transformCaseFunc) !== null && _transformCaseFunc !== void 0 ? _transformCaseFunc : stringToLowerCase;\n    if (setPrototypeOf) {\n      // Make 'in' and truthy checks like Boolean(set.constructor)\n      // independent of any properties defined on Object.prototype.\n      // Prevent prototype setters from intercepting set as a this value.\n      setPrototypeOf(set, null);\n    }\n    var l = array.length;\n    while (l--) {\n      var element = array[l];\n      if (typeof element === 'string') {\n        var lcElement = transformCaseFunc(element);\n        if (lcElement !== element) {\n          // Config presets (e.g. tags.js, attrs.js) are immutable.\n          if (!isFrozen(array)) {\n            array[l] = lcElement;\n          }\n          element = lcElement;\n        }\n      }\n      set[element] = true;\n    }\n    return set;\n  }\n\n  /* Shallow clone an object */\n  function clone(object) {\n    var newObject = create(null);\n    var property;\n    for (property in object) {\n      if (apply(hasOwnProperty, object, [property]) === true) {\n        newObject[property] = object[property];\n      }\n    }\n    return newObject;\n  }\n\n  /* IE10 doesn't support __lookupGetter__ so lets'\n   * simulate it. It also automatically checks\n   * if the prop is function or getter and behaves\n   * accordingly. */\n  function lookupGetter(object, prop) {\n    while (object !== null) {\n      var desc = getOwnPropertyDescriptor(object, prop);\n      if (desc) {\n        if (desc.get) {\n          return unapply(desc.get);\n        }\n        if (typeof desc.value === 'function') {\n          return unapply(desc.value);\n        }\n      }\n      object = getPrototypeOf(object);\n    }\n    function fallbackValue(element) {\n      console.warn('fallback value for', element);\n      return null;\n    }\n    return fallbackValue;\n  }\n\n  var html$1 = freeze(['a', 'abbr', 'acronym', 'address', 'area', 'article', 'aside', 'audio', 'b', 'bdi', 'bdo', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'content', 'data', 'datalist', 'dd', 'decorator', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meter', 'nav', 'nobr', 'ol', 'optgroup', 'option', 'output', 'p', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'section', 'select', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr']);\n\n  // SVG\n  var svg$1 = freeze(['svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern']);\n  var svgFilters = freeze(['feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence']);\n\n  // List of SVG elements that are disallowed by default.\n  // We still need to know them so that we can do namespace\n  // checks properly in case one wants to add them to\n  // allow-list.\n  var svgDisallowed = freeze(['animate', 'color-profile', 'cursor', 'discard', 'fedropshadow', 'font-face', 'font-face-format', 'font-face-name', 'font-face-src', 'font-face-uri', 'foreignobject', 'hatch', 'hatchpath', 'mesh', 'meshgradient', 'meshpatch', 'meshrow', 'missing-glyph', 'script', 'set', 'solidcolor', 'unknown', 'use']);\n  var mathMl$1 = freeze(['math', 'menclose', 'merror', 'mfenced', 'mfrac', 'mglyph', 'mi', 'mlabeledtr', 'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded', 'mphantom', 'mroot', 'mrow', 'ms', 'mspace', 'msqrt', 'mstyle', 'msub', 'msup', 'msubsup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder', 'munderover']);\n\n  // Similarly to SVG, we want to know all MathML elements,\n  // even those that we disallow by default.\n  var mathMlDisallowed = freeze(['maction', 'maligngroup', 'malignmark', 'mlongdiv', 'mscarries', 'mscarry', 'msgroup', 'mstack', 'msline', 'msrow', 'semantics', 'annotation', 'annotation-xml', 'mprescripts', 'none']);\n  var text = freeze(['#text']);\n\n  var html = freeze(['accept', 'action', 'align', 'alt', 'autocapitalize', 'autocomplete', 'autopictureinpicture', 'autoplay', 'background', 'bgcolor', 'border', 'capture', 'cellpadding', 'cellspacing', 'checked', 'cite', 'class', 'clear', 'color', 'cols', 'colspan', 'controls', 'controlslist', 'coords', 'crossorigin', 'datetime', 'decoding', 'default', 'dir', 'disabled', 'disablepictureinpicture', 'disableremoteplayback', 'download', 'draggable', 'enctype', 'enterkeyhint', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inputmode', 'integrity', 'ismap', 'kind', 'label', 'lang', 'list', 'loading', 'loop', 'low', 'max', 'maxlength', 'media', 'method', 'min', 'minlength', 'multiple', 'muted', 'name', 'nonce', 'noshade', 'novalidate', 'nowrap', 'open', 'optimum', 'pattern', 'placeholder', 'playsinline', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'xmlns', 'slot']);\n  var svg = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'targetx', 'targety', 'transform', 'transform-origin', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);\n  var mathMl = freeze(['accent', 'accentunder', 'align', 'bevelled', 'close', 'columnsalign', 'columnlines', 'columnspan', 'denomalign', 'depth', 'dir', 'display', 'displaystyle', 'encoding', 'fence', 'frame', 'height', 'href', 'id', 'largeop', 'length', 'linethickness', 'lspace', 'lquote', 'mathbackground', 'mathcolor', 'mathsize', 'mathvariant', 'maxsize', 'minsize', 'movablelimits', 'notation', 'numalign', 'open', 'rowalign', 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'rquote', 'scriptlevel', 'scriptminsize', 'scriptsizemultiplier', 'selection', 'separator', 'separators', 'stretchy', 'subscriptshift', 'supscriptshift', 'symmetric', 'voffset', 'width', 'xmlns']);\n  var xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink']);\n\n  // eslint-disable-next-line unicorn/better-regex\n  var MUSTACHE_EXPR = seal(/\\{\\{[\\w\\W]*|[\\w\\W]*\\}\\}/gm); // Specify template detection regex for SAFE_FOR_TEMPLATES mode\n  var ERB_EXPR = seal(/<%[\\w\\W]*|[\\w\\W]*%>/gm);\n  var TMPLIT_EXPR = seal(/\\${[\\w\\W]*}/gm);\n  var DATA_ATTR = seal(/^data-[\\-\\w.\\u00B7-\\uFFFF]/); // eslint-disable-line no-useless-escape\n  var ARIA_ATTR = seal(/^aria-[\\-\\w]+$/); // eslint-disable-line no-useless-escape\n  var IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\\-]+(?:[^a-z+.\\-:]|$))/i // eslint-disable-line no-useless-escape\n  );\n  var IS_SCRIPT_OR_DATA = seal(/^(?:\\w+script|data):/i);\n  var ATTR_WHITESPACE = seal(/[\\u0000-\\u0020\\u00A0\\u1680\\u180E\\u2000-\\u2029\\u205F\\u3000]/g // eslint-disable-line no-control-regex\n  );\n  var DOCTYPE_NAME = seal(/^html$/i);\n  var CUSTOM_ELEMENT = seal(/^[a-z][.\\w]*(-[.\\w]+)+$/i);\n\n  var getGlobal = function getGlobal() {\n    return typeof window === 'undefined' ? null : window;\n  };\n\n  /**\n   * Creates a no-op policy for internal use only.\n   * Don't export this function outside this module!\n   * @param {?TrustedTypePolicyFactory} trustedTypes The policy factory.\n   * @param {Document} document The document object (to determine policy name suffix)\n   * @return {?TrustedTypePolicy} The policy created (or null, if Trusted Types\n   * are not supported).\n   */\n  var _createTrustedTypesPolicy = function _createTrustedTypesPolicy(trustedTypes, document) {\n    if (_typeof(trustedTypes) !== 'object' || typeof trustedTypes.createPolicy !== 'function') {\n      return null;\n    }\n\n    // Allow the callers to control the unique policy name\n    // by adding a data-tt-policy-suffix to the script element with the DOMPurify.\n    // Policy creation with duplicate names throws in Trusted Types.\n    var suffix = null;\n    var ATTR_NAME = 'data-tt-policy-suffix';\n    if (document.currentScript && document.currentScript.hasAttribute(ATTR_NAME)) {\n      suffix = document.currentScript.getAttribute(ATTR_NAME);\n    }\n    var policyName = 'dompurify' + (suffix ? '#' + suffix : '');\n    try {\n      return trustedTypes.createPolicy(policyName, {\n        createHTML: function createHTML(html) {\n          return html;\n        },\n        createScriptURL: function createScriptURL(scriptUrl) {\n          return scriptUrl;\n        }\n      });\n    } catch (_) {\n      // Policy creation failed (most likely another DOMPurify script has\n      // already run). Skip creating the policy, as this will only cause errors\n      // if TT are enforced.\n      console.warn('TrustedTypes policy ' + policyName + ' could not be created.');\n      return null;\n    }\n  };\n  function createDOMPurify() {\n    var window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();\n    var DOMPurify = function DOMPurify(root) {\n      return createDOMPurify(root);\n    };\n\n    /**\n     * Version label, exposed for easier checks\n     * if DOMPurify is up to date or not\n     */\n    DOMPurify.version = '2.5.7';\n\n    /**\n     * Array of elements that DOMPurify removed during sanitation.\n     * Empty if nothing was removed.\n     */\n    DOMPurify.removed = [];\n    if (!window || !window.document || window.document.nodeType !== 9) {\n      // Not running in a browser, provide a factory function\n      // so that you can pass your own Window\n      DOMPurify.isSupported = false;\n      return DOMPurify;\n    }\n    var originalDocument = window.document;\n    var document = window.document;\n    var DocumentFragment = window.DocumentFragment,\n      HTMLTemplateElement = window.HTMLTemplateElement,\n      Node = window.Node,\n      Element = window.Element,\n      NodeFilter = window.NodeFilter,\n      _window$NamedNodeMap = window.NamedNodeMap,\n      NamedNodeMap = _window$NamedNodeMap === void 0 ? window.NamedNodeMap || window.MozNamedAttrMap : _window$NamedNodeMap,\n      HTMLFormElement = window.HTMLFormElement,\n      DOMParser = window.DOMParser,\n      trustedTypes = window.trustedTypes;\n    var ElementPrototype = Element.prototype;\n    var cloneNode = lookupGetter(ElementPrototype, 'cloneNode');\n    var getNextSibling = lookupGetter(ElementPrototype, 'nextSibling');\n    var getChildNodes = lookupGetter(ElementPrototype, 'childNodes');\n    var getParentNode = lookupGetter(ElementPrototype, 'parentNode');\n\n    // As per issue #47, the web-components registry is inherited by a\n    // new document created via createHTMLDocument. As per the spec\n    // (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries)\n    // a new empty registry is used when creating a template contents owner\n    // document, so we use that as our parent document to ensure nothing\n    // is inherited.\n    if (typeof HTMLTemplateElement === 'function') {\n      var template = document.createElement('template');\n      if (template.content && template.content.ownerDocument) {\n        document = template.content.ownerDocument;\n      }\n    }\n    var trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, originalDocument);\n    var emptyHTML = trustedTypesPolicy ? trustedTypesPolicy.createHTML('') : '';\n    var _document = document,\n      implementation = _document.implementation,\n      createNodeIterator = _document.createNodeIterator,\n      createDocumentFragment = _document.createDocumentFragment,\n      getElementsByTagName = _document.getElementsByTagName;\n    var importNode = originalDocument.importNode;\n    var documentMode = {};\n    try {\n      documentMode = clone(document).documentMode ? document.documentMode : {};\n    } catch (_) {}\n    var hooks = {};\n\n    /**\n     * Expose whether this browser supports running the full DOMPurify.\n     */\n    DOMPurify.isSupported = typeof getParentNode === 'function' && implementation && implementation.createHTMLDocument !== undefined && documentMode !== 9;\n    var MUSTACHE_EXPR$1 = MUSTACHE_EXPR,\n      ERB_EXPR$1 = ERB_EXPR,\n      TMPLIT_EXPR$1 = TMPLIT_EXPR,\n      DATA_ATTR$1 = DATA_ATTR,\n      ARIA_ATTR$1 = ARIA_ATTR,\n      IS_SCRIPT_OR_DATA$1 = IS_SCRIPT_OR_DATA,\n      ATTR_WHITESPACE$1 = ATTR_WHITESPACE,\n      CUSTOM_ELEMENT$1 = CUSTOM_ELEMENT;\n    var IS_ALLOWED_URI$1 = IS_ALLOWED_URI;\n\n    /**\n     * We consider the elements and attributes below to be safe. Ideally\n     * don't add any new ones but feel free to remove unwanted ones.\n     */\n\n    /* allowed element names */\n    var ALLOWED_TAGS = null;\n    var DEFAULT_ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray(html$1), _toConsumableArray(svg$1), _toConsumableArray(svgFilters), _toConsumableArray(mathMl$1), _toConsumableArray(text)));\n\n    /* Allowed attribute names */\n    var ALLOWED_ATTR = null;\n    var DEFAULT_ALLOWED_ATTR = addToSet({}, [].concat(_toConsumableArray(html), _toConsumableArray(svg), _toConsumableArray(mathMl), _toConsumableArray(xml)));\n\n    /*\n     * Configure how DOMPUrify should handle custom elements and their attributes as well as customized built-in elements.\n     * @property {RegExp|Function|null} tagNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any custom elements)\n     * @property {RegExp|Function|null} attributeNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any attributes not on the allow list)\n     * @property {boolean} allowCustomizedBuiltInElements allow custom elements derived from built-ins if they pass CUSTOM_ELEMENT_HANDLING.tagNameCheck. Default: `false`.\n     */\n    var CUSTOM_ELEMENT_HANDLING = Object.seal(Object.create(null, {\n      tagNameCheck: {\n        writable: true,\n        configurable: false,\n        enumerable: true,\n        value: null\n      },\n      attributeNameCheck: {\n        writable: true,\n        configurable: false,\n        enumerable: true,\n        value: null\n      },\n      allowCustomizedBuiltInElements: {\n        writable: true,\n        configurable: false,\n        enumerable: true,\n        value: false\n      }\n    }));\n\n    /* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */\n    var FORBID_TAGS = null;\n\n    /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */\n    var FORBID_ATTR = null;\n\n    /* Decide if ARIA attributes are okay */\n    var ALLOW_ARIA_ATTR = true;\n\n    /* Decide if custom data attributes are okay */\n    var ALLOW_DATA_ATTR = true;\n\n    /* Decide if unknown protocols are okay */\n    var ALLOW_UNKNOWN_PROTOCOLS = false;\n\n    /* Decide if self-closing tags in attributes are allowed.\n     * Usually removed due to a mXSS issue in jQuery 3.0 */\n    var ALLOW_SELF_CLOSE_IN_ATTR = true;\n\n    /* Output should be safe for common template engines.\n     * This means, DOMPurify removes data attributes, mustaches and ERB\n     */\n    var SAFE_FOR_TEMPLATES = false;\n\n    /* Output should be safe even for XML used within HTML and alike.\n     * This means, DOMPurify removes comments when containing risky content.\n     */\n    var SAFE_FOR_XML = true;\n\n    /* Decide if document with <html>... should be returned */\n    var WHOLE_DOCUMENT = false;\n\n    /* Track whether config is already set on this instance of DOMPurify. */\n    var SET_CONFIG = false;\n\n    /* Decide if all elements (e.g. style, script) must be children of\n     * document.body. By default, browsers might move them to document.head */\n    var FORCE_BODY = false;\n\n    /* Decide if a DOM `HTMLBodyElement` should be returned, instead of a html\n     * string (or a TrustedHTML object if Trusted Types are supported).\n     * If `WHOLE_DOCUMENT` is enabled a `HTMLHtmlElement` will be returned instead\n     */\n    var RETURN_DOM = false;\n\n    /* Decide if a DOM `DocumentFragment` should be returned, instead of a html\n     * string  (or a TrustedHTML object if Trusted Types are supported) */\n    var RETURN_DOM_FRAGMENT = false;\n\n    /* Try to return a Trusted Type object instead of a string, return a string in\n     * case Trusted Types are not supported  */\n    var RETURN_TRUSTED_TYPE = false;\n\n    /* Output should be free from DOM clobbering attacks?\n     * This sanitizes markups named with colliding, clobberable built-in DOM APIs.\n     */\n    var SANITIZE_DOM = true;\n\n    /* Achieve full DOM Clobbering protection by isolating the namespace of named\n     * properties and JS variables, mitigating attacks that abuse the HTML/DOM spec rules.\n     *\n     * HTML/DOM spec rules that enable DOM Clobbering:\n     *   - Named Access on Window (§7.3.3)\n     *   - DOM Tree Accessors (§3.1.5)\n     *   - Form Element Parent-Child Relations (§4.10.3)\n     *   - Iframe srcdoc / Nested WindowProxies (§4.8.5)\n     *   - HTMLCollection (§4.2.10.2)\n     *\n     * Namespace isolation is implemented by prefixing `id` and `name` attributes\n     * with a constant string, i.e., `user-content-`\n     */\n    var SANITIZE_NAMED_PROPS = false;\n    var SANITIZE_NAMED_PROPS_PREFIX = 'user-content-';\n\n    /* Keep element content when removing element? */\n    var KEEP_CONTENT = true;\n\n    /* If a `Node` is passed to sanitize(), then performs sanitization in-place instead\n     * of importing it into a new Document and returning a sanitized copy */\n    var IN_PLACE = false;\n\n    /* Allow usage of profiles like html, svg and mathMl */\n    var USE_PROFILES = {};\n\n    /* Tags to ignore content of when KEEP_CONTENT is true */\n    var FORBID_CONTENTS = null;\n    var DEFAULT_FORBID_CONTENTS = addToSet({}, ['annotation-xml', 'audio', 'colgroup', 'desc', 'foreignobject', 'head', 'iframe', 'math', 'mi', 'mn', 'mo', 'ms', 'mtext', 'noembed', 'noframes', 'noscript', 'plaintext', 'script', 'style', 'svg', 'template', 'thead', 'title', 'video', 'xmp']);\n\n    /* Tags that are safe for data: URIs */\n    var DATA_URI_TAGS = null;\n    var DEFAULT_DATA_URI_TAGS = addToSet({}, ['audio', 'video', 'img', 'source', 'image', 'track']);\n\n    /* Attributes safe for values like \"javascript:\" */\n    var URI_SAFE_ATTRIBUTES = null;\n    var DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ['alt', 'class', 'for', 'id', 'label', 'name', 'pattern', 'placeholder', 'role', 'summary', 'title', 'value', 'style', 'xmlns']);\n    var MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';\n    var SVG_NAMESPACE = 'http://www.w3.org/2000/svg';\n    var HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';\n    /* Document namespace */\n    var NAMESPACE = HTML_NAMESPACE;\n    var IS_EMPTY_INPUT = false;\n\n    /* Allowed XHTML+XML namespaces */\n    var ALLOWED_NAMESPACES = null;\n    var DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [MATHML_NAMESPACE, SVG_NAMESPACE, HTML_NAMESPACE], stringToString);\n\n    /* Parsing of strict XHTML documents */\n    var PARSER_MEDIA_TYPE;\n    var SUPPORTED_PARSER_MEDIA_TYPES = ['application/xhtml+xml', 'text/html'];\n    var DEFAULT_PARSER_MEDIA_TYPE = 'text/html';\n    var transformCaseFunc;\n\n    /* Keep a reference to config to pass to hooks */\n    var CONFIG = null;\n\n    /* Ideally, do not touch anything below this line */\n    /* ______________________________________________ */\n\n    var formElement = document.createElement('form');\n    var isRegexOrFunction = function isRegexOrFunction(testValue) {\n      return testValue instanceof RegExp || testValue instanceof Function;\n    };\n\n    /**\n     * _parseConfig\n     *\n     * @param  {Object} cfg optional config literal\n     */\n    // eslint-disable-next-line complexity\n    var _parseConfig = function _parseConfig(cfg) {\n      if (CONFIG && CONFIG === cfg) {\n        return;\n      }\n\n      /* Shield configuration object from tampering */\n      if (!cfg || _typeof(cfg) !== 'object') {\n        cfg = {};\n      }\n\n      /* Shield configuration object from prototype pollution */\n      cfg = clone(cfg);\n      PARSER_MEDIA_TYPE =\n      // eslint-disable-next-line unicorn/prefer-includes\n      SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? PARSER_MEDIA_TYPE = DEFAULT_PARSER_MEDIA_TYPE : PARSER_MEDIA_TYPE = cfg.PARSER_MEDIA_TYPE;\n\n      // HTML tags and attributes are not case-sensitive, converting to lowercase. Keeping XHTML as is.\n      transformCaseFunc = PARSER_MEDIA_TYPE === 'application/xhtml+xml' ? stringToString : stringToLowerCase;\n\n      /* Set configuration parameters */\n      ALLOWED_TAGS = 'ALLOWED_TAGS' in cfg ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;\n      ALLOWED_ATTR = 'ALLOWED_ATTR' in cfg ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;\n      ALLOWED_NAMESPACES = 'ALLOWED_NAMESPACES' in cfg ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;\n      URI_SAFE_ATTRIBUTES = 'ADD_URI_SAFE_ATTR' in cfg ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES),\n      // eslint-disable-line indent\n      cfg.ADD_URI_SAFE_ATTR,\n      // eslint-disable-line indent\n      transformCaseFunc // eslint-disable-line indent\n      ) // eslint-disable-line indent\n      : DEFAULT_URI_SAFE_ATTRIBUTES;\n      DATA_URI_TAGS = 'ADD_DATA_URI_TAGS' in cfg ? addToSet(clone(DEFAULT_DATA_URI_TAGS),\n      // eslint-disable-line indent\n      cfg.ADD_DATA_URI_TAGS,\n      // eslint-disable-line indent\n      transformCaseFunc // eslint-disable-line indent\n      ) // eslint-disable-line indent\n      : DEFAULT_DATA_URI_TAGS;\n      FORBID_CONTENTS = 'FORBID_CONTENTS' in cfg ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;\n      FORBID_TAGS = 'FORBID_TAGS' in cfg ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : {};\n      FORBID_ATTR = 'FORBID_ATTR' in cfg ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : {};\n      USE_PROFILES = 'USE_PROFILES' in cfg ? cfg.USE_PROFILES : false;\n      ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false; // Default true\n      ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false; // Default true\n      ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false; // Default false\n      ALLOW_SELF_CLOSE_IN_ATTR = cfg.ALLOW_SELF_CLOSE_IN_ATTR !== false; // Default true\n      SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false; // Default false\n      SAFE_FOR_XML = cfg.SAFE_FOR_XML !== false; // Default true\n      WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false; // Default false\n      RETURN_DOM = cfg.RETURN_DOM || false; // Default false\n      RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false; // Default false\n      RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false; // Default false\n      FORCE_BODY = cfg.FORCE_BODY || false; // Default false\n      SANITIZE_DOM = cfg.SANITIZE_DOM !== false; // Default true\n      SANITIZE_NAMED_PROPS = cfg.SANITIZE_NAMED_PROPS || false; // Default false\n      KEEP_CONTENT = cfg.KEEP_CONTENT !== false; // Default true\n      IN_PLACE = cfg.IN_PLACE || false; // Default false\n      IS_ALLOWED_URI$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI$1;\n      NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;\n      CUSTOM_ELEMENT_HANDLING = cfg.CUSTOM_ELEMENT_HANDLING || {};\n      if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {\n        CUSTOM_ELEMENT_HANDLING.tagNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck;\n      }\n      if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) {\n        CUSTOM_ELEMENT_HANDLING.attributeNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck;\n      }\n      if (cfg.CUSTOM_ELEMENT_HANDLING && typeof cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements === 'boolean') {\n        CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements = cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements;\n      }\n      if (SAFE_FOR_TEMPLATES) {\n        ALLOW_DATA_ATTR = false;\n      }\n      if (RETURN_DOM_FRAGMENT) {\n        RETURN_DOM = true;\n      }\n\n      /* Parse profile info */\n      if (USE_PROFILES) {\n        ALLOWED_TAGS = addToSet({}, _toConsumableArray(text));\n        ALLOWED_ATTR = [];\n        if (USE_PROFILES.html === true) {\n          addToSet(ALLOWED_TAGS, html$1);\n          addToSet(ALLOWED_ATTR, html);\n        }\n        if (USE_PROFILES.svg === true) {\n          addToSet(ALLOWED_TAGS, svg$1);\n          addToSet(ALLOWED_ATTR, svg);\n          addToSet(ALLOWED_ATTR, xml);\n        }\n        if (USE_PROFILES.svgFilters === true) {\n          addToSet(ALLOWED_TAGS, svgFilters);\n          addToSet(ALLOWED_ATTR, svg);\n          addToSet(ALLOWED_ATTR, xml);\n        }\n        if (USE_PROFILES.mathMl === true) {\n          addToSet(ALLOWED_TAGS, mathMl$1);\n          addToSet(ALLOWED_ATTR, mathMl);\n          addToSet(ALLOWED_ATTR, xml);\n        }\n      }\n\n      /* Merge configuration parameters */\n      if (cfg.ADD_TAGS) {\n        if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {\n          ALLOWED_TAGS = clone(ALLOWED_TAGS);\n        }\n        addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);\n      }\n      if (cfg.ADD_ATTR) {\n        if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {\n          ALLOWED_ATTR = clone(ALLOWED_ATTR);\n        }\n        addToSet(ALLOWED_ATTR, cfg.ADD_ATTR, transformCaseFunc);\n      }\n      if (cfg.ADD_URI_SAFE_ATTR) {\n        addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR, transformCaseFunc);\n      }\n      if (cfg.FORBID_CONTENTS) {\n        if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {\n          FORBID_CONTENTS = clone(FORBID_CONTENTS);\n        }\n        addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS, transformCaseFunc);\n      }\n\n      /* Add #text in case KEEP_CONTENT is set to true */\n      if (KEEP_CONTENT) {\n        ALLOWED_TAGS['#text'] = true;\n      }\n\n      /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */\n      if (WHOLE_DOCUMENT) {\n        addToSet(ALLOWED_TAGS, ['html', 'head', 'body']);\n      }\n\n      /* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286, #365 */\n      if (ALLOWED_TAGS.table) {\n        addToSet(ALLOWED_TAGS, ['tbody']);\n        delete FORBID_TAGS.tbody;\n      }\n\n      // Prevent further manipulation of configuration.\n      // Not available in IE8, Safari 5, etc.\n      if (freeze) {\n        freeze(cfg);\n      }\n      CONFIG = cfg;\n    };\n    var MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ['mi', 'mo', 'mn', 'ms', 'mtext']);\n    var HTML_INTEGRATION_POINTS = addToSet({}, ['annotation-xml']);\n\n    // Certain elements are allowed in both SVG and HTML\n    // namespace. We need to specify them explicitly\n    // so that they don't get erroneously deleted from\n    // HTML namespace.\n    var COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ['title', 'style', 'font', 'a', 'script']);\n\n    /* Keep track of all possible SVG and MathML tags\n     * so that we can perform the namespace checks\n     * correctly. */\n    var ALL_SVG_TAGS = addToSet({}, svg$1);\n    addToSet(ALL_SVG_TAGS, svgFilters);\n    addToSet(ALL_SVG_TAGS, svgDisallowed);\n    var ALL_MATHML_TAGS = addToSet({}, mathMl$1);\n    addToSet(ALL_MATHML_TAGS, mathMlDisallowed);\n\n    /**\n     *\n     *\n     * @param  {Element} element a DOM element whose namespace is being checked\n     * @returns {boolean} Return false if the element has a\n     *  namespace that a spec-compliant parser would never\n     *  return. Return true otherwise.\n     */\n    var _checkValidNamespace = function _checkValidNamespace(element) {\n      var parent = getParentNode(element);\n\n      // In JSDOM, if we're inside shadow DOM, then parentNode\n      // can be null. We just simulate parent in this case.\n      if (!parent || !parent.tagName) {\n        parent = {\n          namespaceURI: NAMESPACE,\n          tagName: 'template'\n        };\n      }\n      var tagName = stringToLowerCase(element.tagName);\n      var parentTagName = stringToLowerCase(parent.tagName);\n      if (!ALLOWED_NAMESPACES[element.namespaceURI]) {\n        return false;\n      }\n      if (element.namespaceURI === SVG_NAMESPACE) {\n        // The only way to switch from HTML namespace to SVG\n        // is via <svg>. If it happens via any other tag, then\n        // it should be killed.\n        if (parent.namespaceURI === HTML_NAMESPACE) {\n          return tagName === 'svg';\n        }\n\n        // The only way to switch from MathML to SVG is via`\n        // svg if parent is either <annotation-xml> or MathML\n        // text integration points.\n        if (parent.namespaceURI === MATHML_NAMESPACE) {\n          return tagName === 'svg' && (parentTagName === 'annotation-xml' || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);\n        }\n\n        // We only allow elements that are defined in SVG\n        // spec. All others are disallowed in SVG namespace.\n        return Boolean(ALL_SVG_TAGS[tagName]);\n      }\n      if (element.namespaceURI === MATHML_NAMESPACE) {\n        // The only way to switch from HTML namespace to MathML\n        // is via <math>. If it happens via any other tag, then\n        // it should be killed.\n        if (parent.namespaceURI === HTML_NAMESPACE) {\n          return tagName === 'math';\n        }\n\n        // The only way to switch from SVG to MathML is via\n        // <math> and HTML integration points\n        if (parent.namespaceURI === SVG_NAMESPACE) {\n          return tagName === 'math' && HTML_INTEGRATION_POINTS[parentTagName];\n        }\n\n        // We only allow elements that are defined in MathML\n        // spec. All others are disallowed in MathML namespace.\n        return Boolean(ALL_MATHML_TAGS[tagName]);\n      }\n      if (element.namespaceURI === HTML_NAMESPACE) {\n        // The only way to switch from SVG to HTML is via\n        // HTML integration points, and from MathML to HTML\n        // is via MathML text integration points\n        if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {\n          return false;\n        }\n        if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {\n          return false;\n        }\n\n        // We disallow tags that are specific for MathML\n        // or SVG and should never appear in HTML namespace\n        return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] || !ALL_SVG_TAGS[tagName]);\n      }\n\n      // For XHTML and XML documents that support custom namespaces\n      if (PARSER_MEDIA_TYPE === 'application/xhtml+xml' && ALLOWED_NAMESPACES[element.namespaceURI]) {\n        return true;\n      }\n\n      // The code should never reach this place (this means\n      // that the element somehow got namespace that is not\n      // HTML, SVG, MathML or allowed via ALLOWED_NAMESPACES).\n      // Return false just in case.\n      return false;\n    };\n\n    /**\n     * _forceRemove\n     *\n     * @param  {Node} node a DOM node\n     */\n    var _forceRemove = function _forceRemove(node) {\n      arrayPush(DOMPurify.removed, {\n        element: node\n      });\n      try {\n        // eslint-disable-next-line unicorn/prefer-dom-node-remove\n        node.parentNode.removeChild(node);\n      } catch (_) {\n        try {\n          node.outerHTML = emptyHTML;\n        } catch (_) {\n          node.remove();\n        }\n      }\n    };\n\n    /**\n     * _removeAttribute\n     *\n     * @param  {String} name an Attribute name\n     * @param  {Node} node a DOM node\n     */\n    var _removeAttribute = function _removeAttribute(name, node) {\n      try {\n        arrayPush(DOMPurify.removed, {\n          attribute: node.getAttributeNode(name),\n          from: node\n        });\n      } catch (_) {\n        arrayPush(DOMPurify.removed, {\n          attribute: null,\n          from: node\n        });\n      }\n      node.removeAttribute(name);\n\n      // We void attribute values for unremovable \"is\"\" attributes\n      if (name === 'is' && !ALLOWED_ATTR[name]) {\n        if (RETURN_DOM || RETURN_DOM_FRAGMENT) {\n          try {\n            _forceRemove(node);\n          } catch (_) {}\n        } else {\n          try {\n            node.setAttribute(name, '');\n          } catch (_) {}\n        }\n      }\n    };\n\n    /**\n     * _initDocument\n     *\n     * @param  {String} dirty a string of dirty markup\n     * @return {Document} a DOM, filled with the dirty markup\n     */\n    var _initDocument = function _initDocument(dirty) {\n      /* Create a HTML document */\n      var doc;\n      var leadingWhitespace;\n      if (FORCE_BODY) {\n        dirty = '<remove></remove>' + dirty;\n      } else {\n        /* If FORCE_BODY isn't used, leading whitespace needs to be preserved manually */\n        var matches = stringMatch(dirty, /^[\\r\\n\\t ]+/);\n        leadingWhitespace = matches && matches[0];\n      }\n      if (PARSER_MEDIA_TYPE === 'application/xhtml+xml' && NAMESPACE === HTML_NAMESPACE) {\n        // Root of XHTML doc must contain xmlns declaration (see https://www.w3.org/TR/xhtml1/normative.html#strict)\n        dirty = '<html xmlns=\"http://www.w3.org/1999/xhtml\"><head></head><body>' + dirty + '</body></html>';\n      }\n      var dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;\n      /*\n       * Use the DOMParser API by default, fallback later if needs be\n       * DOMParser not work for svg when has multiple root element.\n       */\n      if (NAMESPACE === HTML_NAMESPACE) {\n        try {\n          doc = new DOMParser().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);\n        } catch (_) {}\n      }\n\n      /* Use createHTMLDocument in case DOMParser is not available */\n      if (!doc || !doc.documentElement) {\n        doc = implementation.createDocument(NAMESPACE, 'template', null);\n        try {\n          doc.documentElement.innerHTML = IS_EMPTY_INPUT ? emptyHTML : dirtyPayload;\n        } catch (_) {\n          // Syntax error if dirtyPayload is invalid xml\n        }\n      }\n      var body = doc.body || doc.documentElement;\n      if (dirty && leadingWhitespace) {\n        body.insertBefore(document.createTextNode(leadingWhitespace), body.childNodes[0] || null);\n      }\n\n      /* Work on whole document or just its body */\n      if (NAMESPACE === HTML_NAMESPACE) {\n        return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? 'html' : 'body')[0];\n      }\n      return WHOLE_DOCUMENT ? doc.documentElement : body;\n    };\n\n    /**\n     * _createIterator\n     *\n     * @param  {Document} root document/fragment to create iterator for\n     * @return {Iterator} iterator instance\n     */\n    var _createIterator = function _createIterator(root) {\n      return createNodeIterator.call(root.ownerDocument || root, root,\n      // eslint-disable-next-line no-bitwise\n      NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT | NodeFilter.SHOW_PROCESSING_INSTRUCTION | NodeFilter.SHOW_CDATA_SECTION, null, false);\n    };\n\n    /**\n     * _isClobbered\n     *\n     * @param  {Node} elm element to check for clobbering attacks\n     * @return {Boolean} true if clobbered, false if safe\n     */\n    var _isClobbered = function _isClobbered(elm) {\n      return elm instanceof HTMLFormElement && (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function' || typeof elm.hasChildNodes !== 'function');\n    };\n\n    /**\n     * _isNode\n     *\n     * @param  {Node} obj object to check whether it's a DOM node\n     * @return {Boolean} true is object is a DOM node\n     */\n    var _isNode = function _isNode(object) {\n      return _typeof(Node) === 'object' ? object instanceof Node : object && _typeof(object) === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string';\n    };\n\n    /**\n     * _executeHook\n     * Execute user configurable hooks\n     *\n     * @param  {String} entryPoint  Name of the hook's entry point\n     * @param  {Node} currentNode node to work on with the hook\n     * @param  {Object} data additional hook parameters\n     */\n    var _executeHook = function _executeHook(entryPoint, currentNode, data) {\n      if (!hooks[entryPoint]) {\n        return;\n      }\n      arrayForEach(hooks[entryPoint], function (hook) {\n        hook.call(DOMPurify, currentNode, data, CONFIG);\n      });\n    };\n\n    /**\n     * _sanitizeElements\n     *\n     * @protect nodeName\n     * @protect textContent\n     * @protect removeChild\n     *\n     * @param   {Node} currentNode to check for permission to exist\n     * @return  {Boolean} true if node was killed, false if left alive\n     */\n    var _sanitizeElements = function _sanitizeElements(currentNode) {\n      var content;\n\n      /* Execute a hook if present */\n      _executeHook('beforeSanitizeElements', currentNode, null);\n\n      /* Check if element is clobbered or can clobber */\n      if (_isClobbered(currentNode)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Check if tagname contains Unicode */\n      if (regExpTest(/[\\u0080-\\uFFFF]/, currentNode.nodeName)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Now let's check the element's type and name */\n      var tagName = transformCaseFunc(currentNode.nodeName);\n\n      /* Execute a hook if present */\n      _executeHook('uponSanitizeElement', currentNode, {\n        tagName: tagName,\n        allowedTags: ALLOWED_TAGS\n      });\n\n      /* Detect mXSS attempts abusing namespace confusion */\n      if (currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && (!_isNode(currentNode.content) || !_isNode(currentNode.content.firstElementChild)) && regExpTest(/<[/\\w]/g, currentNode.innerHTML) && regExpTest(/<[/\\w]/g, currentNode.textContent)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Mitigate a problem with templates inside select */\n      if (tagName === 'select' && regExpTest(/<template/i, currentNode.innerHTML)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Remove any ocurrence of processing instructions */\n      if (currentNode.nodeType === 7) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Remove any kind of possibly harmful comments */\n      if (SAFE_FOR_XML && currentNode.nodeType === 8 && regExpTest(/<[/\\w]/g, currentNode.data)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Remove element if anything forbids its presence */\n      if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {\n        /* Check if we have a custom element to handle */\n        if (!FORBID_TAGS[tagName] && _basicCustomElementTest(tagName)) {\n          if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) return false;\n          if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName)) return false;\n        }\n\n        /* Keep content except for bad-listed elements */\n        if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {\n          var parentNode = getParentNode(currentNode) || currentNode.parentNode;\n          var childNodes = getChildNodes(currentNode) || currentNode.childNodes;\n          if (childNodes && parentNode) {\n            var childCount = childNodes.length;\n            for (var i = childCount - 1; i >= 0; --i) {\n              var childClone = cloneNode(childNodes[i], true);\n              childClone.__removalCount = (currentNode.__removalCount || 0) + 1;\n              parentNode.insertBefore(childClone, getNextSibling(currentNode));\n            }\n          }\n        }\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Check whether element has a valid namespace */\n      if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Make sure that older browsers don't get fallback-tag mXSS */\n      if ((tagName === 'noscript' || tagName === 'noembed' || tagName === 'noframes') && regExpTest(/<\\/no(script|embed|frames)/i, currentNode.innerHTML)) {\n        _forceRemove(currentNode);\n        return true;\n      }\n\n      /* Sanitize element content to be template-safe */\n      if (SAFE_FOR_TEMPLATES && currentNode.nodeType === 3) {\n        /* Get the element's text content */\n        content = currentNode.textContent;\n        content = stringReplace(content, MUSTACHE_EXPR$1, ' ');\n        content = stringReplace(content, ERB_EXPR$1, ' ');\n        content = stringReplace(content, TMPLIT_EXPR$1, ' ');\n        if (currentNode.textContent !== content) {\n          arrayPush(DOMPurify.removed, {\n            element: currentNode.cloneNode()\n          });\n          currentNode.textContent = content;\n        }\n      }\n\n      /* Execute a hook if present */\n      _executeHook('afterSanitizeElements', currentNode, null);\n      return false;\n    };\n\n    /**\n     * _isValidAttribute\n     *\n     * @param  {string} lcTag Lowercase tag name of containing element.\n     * @param  {string} lcName Lowercase attribute name.\n     * @param  {string} value Attribute value.\n     * @return {Boolean} Returns true if `value` is valid, otherwise false.\n     */\n    // eslint-disable-next-line complexity\n    var _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) {\n      /* Make sure attribute cannot clobber */\n      if (SANITIZE_DOM && (lcName === 'id' || lcName === 'name') && (value in document || value in formElement)) {\n        return false;\n      }\n\n      /* Allow valid data-* attributes: At least one character after \"-\"\n          (https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes)\n          XML-compatible (https://html.spec.whatwg.org/multipage/infrastructure.html#xml-compatible and http://www.w3.org/TR/xml/#d0e804)\n          We don't need to check the value; it's always URI safe. */\n      if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR$1, lcName)) ; else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR$1, lcName)) ; else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {\n        if (\n        // First condition does a very basic check if a) it's basically a valid custom element tagname AND\n        // b) if the tagName passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck\n        // and c) if the attribute name passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.attributeNameCheck\n        _basicCustomElementTest(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) || CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName)) ||\n        // Alternative, second condition checks if it's an `is`-attribute, AND\n        // the value passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck\n        lcName === 'is' && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value))) ; else {\n          return false;\n        }\n        /* Check value is safe. First, is attr inert? If so, is safe */\n      } else if (URI_SAFE_ATTRIBUTES[lcName]) ; else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE$1, ''))) ; else if ((lcName === 'src' || lcName === 'xlink:href' || lcName === 'href') && lcTag !== 'script' && stringIndexOf(value, 'data:') === 0 && DATA_URI_TAGS[lcTag]) ; else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA$1, stringReplace(value, ATTR_WHITESPACE$1, ''))) ; else if (value) {\n        return false;\n      } else ;\n      return true;\n    };\n\n    /**\n     * _basicCustomElementCheck\n     * checks if at least one dash is included in tagName, and it's not the first char\n     * for more sophisticated checking see https://github.com/sindresorhus/validate-element-name\n     * @param {string} tagName name of the tag of the node to sanitize\n     */\n    var _basicCustomElementTest = function _basicCustomElementTest(tagName) {\n      return tagName !== 'annotation-xml' && stringMatch(tagName, CUSTOM_ELEMENT$1);\n    };\n\n    /**\n     * _sanitizeAttributes\n     *\n     * @protect attributes\n     * @protect nodeName\n     * @protect removeAttribute\n     * @protect setAttribute\n     *\n     * @param  {Node} currentNode to sanitize\n     */\n    var _sanitizeAttributes = function _sanitizeAttributes(currentNode) {\n      var attr;\n      var value;\n      var lcName;\n      var l;\n      /* Execute a hook if present */\n      _executeHook('beforeSanitizeAttributes', currentNode, null);\n      var attributes = currentNode.attributes;\n\n      /* Check if we have attributes; if not we might have a text node */\n      if (!attributes) {\n        return;\n      }\n      var hookEvent = {\n        attrName: '',\n        attrValue: '',\n        keepAttr: true,\n        allowedAttributes: ALLOWED_ATTR\n      };\n      l = attributes.length;\n\n      /* Go backwards over all attributes; safely remove bad ones */\n      while (l--) {\n        attr = attributes[l];\n        var _attr = attr,\n          name = _attr.name,\n          namespaceURI = _attr.namespaceURI;\n        value = name === 'value' ? attr.value : stringTrim(attr.value);\n        lcName = transformCaseFunc(name);\n\n        /* Execute a hook if present */\n        hookEvent.attrName = lcName;\n        hookEvent.attrValue = value;\n        hookEvent.keepAttr = true;\n        hookEvent.forceKeepAttr = undefined; // Allows developers to see this is a property they can set\n        _executeHook('uponSanitizeAttribute', currentNode, hookEvent);\n        value = hookEvent.attrValue;\n\n        /* Did the hooks approve of the attribute? */\n        if (hookEvent.forceKeepAttr) {\n          continue;\n        }\n\n        /* Remove attribute */\n        _removeAttribute(name, currentNode);\n\n        /* Did the hooks approve of the attribute? */\n        if (!hookEvent.keepAttr) {\n          continue;\n        }\n\n        /* Work around a security issue in jQuery 3.0 */\n        if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(/\\/>/i, value)) {\n          _removeAttribute(name, currentNode);\n          continue;\n        }\n\n        /* Sanitize attribute content to be template-safe */\n        if (SAFE_FOR_TEMPLATES) {\n          value = stringReplace(value, MUSTACHE_EXPR$1, ' ');\n          value = stringReplace(value, ERB_EXPR$1, ' ');\n          value = stringReplace(value, TMPLIT_EXPR$1, ' ');\n        }\n\n        /* Is `value` valid for this attribute? */\n        var lcTag = transformCaseFunc(currentNode.nodeName);\n        if (!_isValidAttribute(lcTag, lcName, value)) {\n          continue;\n        }\n\n        /* Full DOM Clobbering protection via namespace isolation,\n         * Prefix id and name attributes with `user-content-`\n         */\n        if (SANITIZE_NAMED_PROPS && (lcName === 'id' || lcName === 'name')) {\n          // Remove the attribute with this value\n          _removeAttribute(name, currentNode);\n\n          // Prefix the value and later re-create the attribute with the sanitized value\n          value = SANITIZE_NAMED_PROPS_PREFIX + value;\n        }\n\n        /* Work around a security issue with comments inside attributes */\n        if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\\/(style|title)/i, value)) {\n          _removeAttribute(name, currentNode);\n          continue;\n        }\n\n        /* Handle attributes that require Trusted Types */\n        if (trustedTypesPolicy && _typeof(trustedTypes) === 'object' && typeof trustedTypes.getAttributeType === 'function') {\n          if (namespaceURI) ; else {\n            switch (trustedTypes.getAttributeType(lcTag, lcName)) {\n              case 'TrustedHTML':\n                {\n                  value = trustedTypesPolicy.createHTML(value);\n                  break;\n                }\n              case 'TrustedScriptURL':\n                {\n                  value = trustedTypesPolicy.createScriptURL(value);\n                  break;\n                }\n            }\n          }\n        }\n\n        /* Handle invalid data-* attribute set by try-catching it */\n        try {\n          if (namespaceURI) {\n            currentNode.setAttributeNS(namespaceURI, name, value);\n          } else {\n            /* Fallback to setAttribute() for browser-unrecognized namespaces e.g. \"x-schema\". */\n            currentNode.setAttribute(name, value);\n          }\n          if (_isClobbered(currentNode)) {\n            _forceRemove(currentNode);\n          } else {\n            arrayPop(DOMPurify.removed);\n          }\n        } catch (_) {}\n      }\n\n      /* Execute a hook if present */\n      _executeHook('afterSanitizeAttributes', currentNode, null);\n    };\n\n    /**\n     * _sanitizeShadowDOM\n     *\n     * @param  {DocumentFragment} fragment to iterate over recursively\n     */\n    var _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {\n      var shadowNode;\n      var shadowIterator = _createIterator(fragment);\n\n      /* Execute a hook if present */\n      _executeHook('beforeSanitizeShadowDOM', fragment, null);\n      while (shadowNode = shadowIterator.nextNode()) {\n        /* Execute a hook if present */\n        _executeHook('uponSanitizeShadowNode', shadowNode, null);\n\n        /* Sanitize tags and elements */\n        if (_sanitizeElements(shadowNode)) {\n          continue;\n        }\n\n        /* Deep shadow DOM detected */\n        if (shadowNode.content instanceof DocumentFragment) {\n          _sanitizeShadowDOM(shadowNode.content);\n        }\n\n        /* Check attributes, sanitize if necessary */\n        _sanitizeAttributes(shadowNode);\n      }\n\n      /* Execute a hook if present */\n      _executeHook('afterSanitizeShadowDOM', fragment, null);\n    };\n\n    /**\n     * Sanitize\n     * Public method providing core sanitation functionality\n     *\n     * @param {String|Node} dirty string or DOM node\n     * @param {Object} configuration object\n     */\n    // eslint-disable-next-line complexity\n    DOMPurify.sanitize = function (dirty) {\n      var cfg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n      var body;\n      var importedNode;\n      var currentNode;\n      var oldNode;\n      var returnNode;\n      /* Make sure we have a string to sanitize.\n        DO NOT return early, as this will return the wrong type if\n        the user has requested a DOM object rather than a string */\n      IS_EMPTY_INPUT = !dirty;\n      if (IS_EMPTY_INPUT) {\n        dirty = '<!-->';\n      }\n\n      /* Stringify, in case dirty is an object */\n      if (typeof dirty !== 'string' && !_isNode(dirty)) {\n        if (typeof dirty.toString === 'function') {\n          dirty = dirty.toString();\n          if (typeof dirty !== 'string') {\n            throw typeErrorCreate('dirty is not a string, aborting');\n          }\n        } else {\n          throw typeErrorCreate('toString is not a function');\n        }\n      }\n\n      /* Check we can run. Otherwise fall back or ignore */\n      if (!DOMPurify.isSupported) {\n        if (_typeof(window.toStaticHTML) === 'object' || typeof window.toStaticHTML === 'function') {\n          if (typeof dirty === 'string') {\n            return window.toStaticHTML(dirty);\n          }\n          if (_isNode(dirty)) {\n            return window.toStaticHTML(dirty.outerHTML);\n          }\n        }\n        return dirty;\n      }\n\n      /* Assign config vars */\n      if (!SET_CONFIG) {\n        _parseConfig(cfg);\n      }\n\n      /* Clean up removed elements */\n      DOMPurify.removed = [];\n\n      /* Check if dirty is correctly typed for IN_PLACE */\n      if (typeof dirty === 'string') {\n        IN_PLACE = false;\n      }\n      if (IN_PLACE) {\n        /* Do some early pre-sanitization to avoid unsafe root nodes */\n        if (dirty.nodeName) {\n          var tagName = transformCaseFunc(dirty.nodeName);\n          if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {\n            throw typeErrorCreate('root node is forbidden and cannot be sanitized in-place');\n          }\n        }\n      } else if (dirty instanceof Node) {\n        /* If dirty is a DOM element, append to an empty document to avoid\n           elements being stripped by the parser */\n        body = _initDocument('<!---->');\n        importedNode = body.ownerDocument.importNode(dirty, true);\n        if (importedNode.nodeType === 1 && importedNode.nodeName === 'BODY') {\n          /* Node is already a body, use as is */\n          body = importedNode;\n        } else if (importedNode.nodeName === 'HTML') {\n          body = importedNode;\n        } else {\n          // eslint-disable-next-line unicorn/prefer-dom-node-append\n          body.appendChild(importedNode);\n        }\n      } else {\n        /* Exit directly if we have nothing to do */\n        if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT &&\n        // eslint-disable-next-line unicorn/prefer-includes\n        dirty.indexOf('<') === -1) {\n          return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;\n        }\n\n        /* Initialize the document to work on */\n        body = _initDocument(dirty);\n\n        /* Check we have a DOM node from the data */\n        if (!body) {\n          return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : '';\n        }\n      }\n\n      /* Remove first element node (ours) if FORCE_BODY is set */\n      if (body && FORCE_BODY) {\n        _forceRemove(body.firstChild);\n      }\n\n      /* Get node iterator */\n      var nodeIterator = _createIterator(IN_PLACE ? dirty : body);\n\n      /* Now start iterating over the created document */\n      while (currentNode = nodeIterator.nextNode()) {\n        /* Fix IE's strange behavior with manipulated textNodes #89 */\n        if (currentNode.nodeType === 3 && currentNode === oldNode) {\n          continue;\n        }\n\n        /* Sanitize tags and elements */\n        if (_sanitizeElements(currentNode)) {\n          continue;\n        }\n\n        /* Shadow DOM detected, sanitize it */\n        if (currentNode.content instanceof DocumentFragment) {\n          _sanitizeShadowDOM(currentNode.content);\n        }\n\n        /* Check attributes, sanitize if necessary */\n        _sanitizeAttributes(currentNode);\n        oldNode = currentNode;\n      }\n      oldNode = null;\n\n      /* If we sanitized `dirty` in-place, return it. */\n      if (IN_PLACE) {\n        return dirty;\n      }\n\n      /* Return sanitized string or DOM */\n      if (RETURN_DOM) {\n        if (RETURN_DOM_FRAGMENT) {\n          returnNode = createDocumentFragment.call(body.ownerDocument);\n          while (body.firstChild) {\n            // eslint-disable-next-line unicorn/prefer-dom-node-append\n            returnNode.appendChild(body.firstChild);\n          }\n        } else {\n          returnNode = body;\n        }\n        if (ALLOWED_ATTR.shadowroot || ALLOWED_ATTR.shadowrootmod) {\n          /*\n            AdoptNode() is not used because internal state is not reset\n            (e.g. the past names map of a HTMLFormElement), this is safe\n            in theory but we would rather not risk another attack vector.\n            The state that is cloned by importNode() is explicitly defined\n            by the specs.\n          */\n          returnNode = importNode.call(originalDocument, returnNode, true);\n        }\n        return returnNode;\n      }\n      var serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;\n\n      /* Serialize doctype if allowed */\n      if (WHOLE_DOCUMENT && ALLOWED_TAGS['!doctype'] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) {\n        serializedHTML = '<!DOCTYPE ' + body.ownerDocument.doctype.name + '>\\n' + serializedHTML;\n      }\n\n      /* Sanitize final string template-safe */\n      if (SAFE_FOR_TEMPLATES) {\n        serializedHTML = stringReplace(serializedHTML, MUSTACHE_EXPR$1, ' ');\n        serializedHTML = stringReplace(serializedHTML, ERB_EXPR$1, ' ');\n        serializedHTML = stringReplace(serializedHTML, TMPLIT_EXPR$1, ' ');\n      }\n      return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;\n    };\n\n    /**\n     * Public method to set the configuration once\n     * setConfig\n     *\n     * @param {Object} cfg configuration object\n     */\n    DOMPurify.setConfig = function (cfg) {\n      _parseConfig(cfg);\n      SET_CONFIG = true;\n    };\n\n    /**\n     * Public method to remove the configuration\n     * clearConfig\n     *\n     */\n    DOMPurify.clearConfig = function () {\n      CONFIG = null;\n      SET_CONFIG = false;\n    };\n\n    /**\n     * Public method to check if an attribute value is valid.\n     * Uses last set config, if any. Otherwise, uses config defaults.\n     * isValidAttribute\n     *\n     * @param  {string} tag Tag name of containing element.\n     * @param  {string} attr Attribute name.\n     * @param  {string} value Attribute value.\n     * @return {Boolean} Returns true if `value` is valid. Otherwise, returns false.\n     */\n    DOMPurify.isValidAttribute = function (tag, attr, value) {\n      /* Initialize shared config vars if necessary. */\n      if (!CONFIG) {\n        _parseConfig({});\n      }\n      var lcTag = transformCaseFunc(tag);\n      var lcName = transformCaseFunc(attr);\n      return _isValidAttribute(lcTag, lcName, value);\n    };\n\n    /**\n     * AddHook\n     * Public method to add DOMPurify hooks\n     *\n     * @param {String} entryPoint entry point for the hook to add\n     * @param {Function} hookFunction function to execute\n     */\n    DOMPurify.addHook = function (entryPoint, hookFunction) {\n      if (typeof hookFunction !== 'function') {\n        return;\n      }\n      hooks[entryPoint] = hooks[entryPoint] || [];\n      arrayPush(hooks[entryPoint], hookFunction);\n    };\n\n    /**\n     * RemoveHook\n     * Public method to remove a DOMPurify hook at a given entryPoint\n     * (pops it from the stack of hooks if more are present)\n     *\n     * @param {String} entryPoint entry point for the hook to remove\n     * @return {Function} removed(popped) hook\n     */\n    DOMPurify.removeHook = function (entryPoint) {\n      if (hooks[entryPoint]) {\n        return arrayPop(hooks[entryPoint]);\n      }\n    };\n\n    /**\n     * RemoveHooks\n     * Public method to remove all DOMPurify hooks at a given entryPoint\n     *\n     * @param  {String} entryPoint entry point for the hooks to remove\n     */\n    DOMPurify.removeHooks = function (entryPoint) {\n      if (hooks[entryPoint]) {\n        hooks[entryPoint] = [];\n      }\n    };\n\n    /**\n     * RemoveAllHooks\n     * Public method to remove all DOMPurify hooks\n     *\n     */\n    DOMPurify.removeAllHooks = function () {\n      hooks = {};\n    };\n    return DOMPurify;\n  }\n  var purify = createDOMPurify();\n\n  return purify;\n\n}));\n//# sourceMappingURL=purify.js.map\n"],"names":["module","exports","_typeof","obj","Symbol","iterator","constructor","prototype","_setPrototypeOf","o","p","Object","setPrototypeOf","__proto__","_construct","Parent","args","Class","Reflect","construct","sham","Proxy","Boolean","valueOf","call","e","_isNativeReflectConstruct","a","push","apply","instance","Function","bind","arguments","_toConsumableArray","arr","Array","isArray","_arrayLikeToArray","_arrayWithoutHoles","iter","from","_iterableToArray","minLen","n","toString","slice","name","test","_unsupportedIterableToArray","TypeError","_nonIterableSpread","len","length","i","arr2","hasOwnProperty","isFrozen","getPrototypeOf","getOwnPropertyDescriptor","freeze","seal","create","_ref","fun","thisValue","x","Func","func","arrayForEach","unapply","forEach","arrayPop","pop","arrayPush","stringToLowerCase","String","toLowerCase","stringToString","stringMatch","match","stringReplace","replace","stringIndexOf","indexOf","stringTrim","trim","regExpTest","RegExp","typeErrorCreate","_len2","_key2","thisArg","_len","_key","addToSet","set","array","transformCaseFunc","_transformCaseFunc","l","element","lcElement","clone","object","property","newObject","lookupGetter","prop","desc","get","value","console","warn","html$1","svg$1","svgFilters","svgDisallowed","mathMl$1","mathMlDisallowed","text","html","svg","mathMl","xml","MUSTACHE_EXPR","ERB_EXPR","TMPLIT_EXPR","DATA_ATTR","ARIA_ATTR","IS_ALLOWED_URI","IS_SCRIPT_OR_DATA","ATTR_WHITESPACE","DOCTYPE_NAME","CUSTOM_ELEMENT","getGlobal","window","createDOMPurify","undefined","DOMPurify","root","version","removed","document","nodeType","isSupported","originalDocument","DocumentFragment","HTMLTemplateElement","Node","Element","NodeFilter","_window$NamedNodeMap","NamedNodeMap","MozNamedAttrMap","HTMLFormElement","DOMParser","trustedTypes","ElementPrototype","cloneNode","getNextSibling","getChildNodes","getParentNode","template","createElement","content","ownerDocument","trustedTypesPolicy","createPolicy","suffix","ATTR_NAME","currentScript","hasAttribute","getAttribute","policyName","createHTML","createScriptURL","scriptUrl","_","_createTrustedTypesPolicy","emptyHTML","_document","implementation","createNodeIterator","createDocumentFragment","getElementsByTagName","importNode","documentMode","hooks","createHTMLDocument","PARSER_MEDIA_TYPE","MUSTACHE_EXPR$1","ERB_EXPR$1","TMPLIT_EXPR$1","DATA_ATTR$1","ARIA_ATTR$1","IS_SCRIPT_OR_DATA$1","ATTR_WHITESPACE$1","CUSTOM_ELEMENT$1","IS_ALLOWED_URI$1","ALLOWED_TAGS","DEFAULT_ALLOWED_TAGS","concat","ALLOWED_ATTR","DEFAULT_ALLOWED_ATTR","CUSTOM_ELEMENT_HANDLING","tagNameCheck","writable","configurable","enumerable","attributeNameCheck","allowCustomizedBuiltInElements","FORBID_TAGS","FORBID_ATTR","ALLOW_ARIA_ATTR","ALLOW_DATA_ATTR","ALLOW_UNKNOWN_PROTOCOLS","ALLOW_SELF_CLOSE_IN_ATTR","SAFE_FOR_TEMPLATES","SAFE_FOR_XML","WHOLE_DOCUMENT","SET_CONFIG","FORCE_BODY","RETURN_DOM","RETURN_DOM_FRAGMENT","RETURN_TRUSTED_TYPE","SANITIZE_DOM","SANITIZE_NAMED_PROPS","KEEP_CONTENT","IN_PLACE","USE_PROFILES","FORBID_CONTENTS","DEFAULT_FORBID_CONTENTS","DATA_URI_TAGS","DEFAULT_DATA_URI_TAGS","URI_SAFE_ATTRIBUTES","DEFAULT_URI_SAFE_ATTRIBUTES","MATHML_NAMESPACE","SVG_NAMESPACE","HTML_NAMESPACE","NAMESPACE","IS_EMPTY_INPUT","ALLOWED_NAMESPACES","DEFAULT_ALLOWED_NAMESPACES","SUPPORTED_PARSER_MEDIA_TYPES","CONFIG","formElement","isRegexOrFunction","testValue","_parseConfig","cfg","ADD_URI_SAFE_ATTR","ADD_DATA_URI_TAGS","ALLOWED_URI_REGEXP","ADD_TAGS","ADD_ATTR","table","tbody","MATHML_TEXT_INTEGRATION_POINTS","HTML_INTEGRATION_POINTS","COMMON_SVG_AND_HTML_ELEMENTS","ALL_SVG_TAGS","ALL_MATHML_TAGS","_forceRemove","node","parentNode","removeChild","outerHTML","remove","_removeAttribute","attribute","getAttributeNode","removeAttribute","setAttribute","_initDocument","dirty","doc","leadingWhitespace","matches","dirtyPayload","parseFromString","documentElement","createDocument","innerHTML","body","insertBefore","createTextNode","childNodes","_createIterator","SHOW_ELEMENT","SHOW_COMMENT","SHOW_TEXT","SHOW_PROCESSING_INSTRUCTION","SHOW_CDATA_SECTION","_isClobbered","elm","nodeName","textContent","attributes","namespaceURI","hasChildNodes","_isNode","_executeHook","entryPoint","currentNode","data","hook","_sanitizeElements","tagName","allowedTags","firstElementChild","_basicCustomElementTest","childClone","__removalCount","parent","parentTagName","_checkValidNamespace","_isValidAttribute","lcTag","lcName","_sanitizeAttributes","attr","hookEvent","attrName","attrValue","keepAttr","allowedAttributes","_attr","forceKeepAttr","getAttributeType","setAttributeNS","_sanitizeShadowDOM","fragment","shadowNode","shadowIterator","nextNode","sanitize","importedNode","oldNode","returnNode","toStaticHTML","appendChild","firstChild","nodeIterator","shadowroot","shadowrootmod","serializedHTML","doctype","setConfig","clearConfig","isValidAttribute","tag","addHook","hookFunction","removeHook","removeHooks","removeAllHooks","factory"],"sourceRoot":""}
\ No newline at end of file
diff --git a/674.bundle.js.LICENSE.txt b/674.bundle.js.LICENSE.txt
new file mode 100644
index 0000000..de117d8
--- /dev/null
+++ b/674.bundle.js.LICENSE.txt
@@ -0,0 +1 @@
+/*! @license DOMPurify 2.5.7 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/2.5.7/LICENSE */
diff --git a/685.bundle.js b/685.bundle.js
new file mode 100644
index 0000000..db0d55b
--- /dev/null
+++ b/685.bundle.js
@@ -0,0 +1,2 @@
+"use strict";(self.webpackChunkcboy_blog=self.webpackChunkcboy_blog||[]).push([[685],{685:function(e,o,p){p.r(o),p.d(o,{default:function(){return a}});var c=p(762);const t={class:"component-webpack"},s={};var a=(0,p(314).A)(s,[["render",function(e,o){return(0,c.uX)(),(0,c.CE)("div",t,o[0]||(o[0]=[(0,c.Fv)('一 webpack 是什么? 它是一个打包工具。 噗,完啦?
来,我们看官方概念: webpack 是一个现代 JavaScript 应用程序的静态模块打包工具。当 webpack 处理应用程序时,它会在内部构建一个 依赖图(dependency graph),此依赖图会映射项目所需的每个模块,并生成一个或多个 bundle。
内部如何构建一个依赖图,我们知道 webpack 会配置一个入口,这就是从这入口文件开始, 找到所有被依赖到的文件,比如其他 js / image / json 文件等,然后通过 loader 对这些文件进行处理、编译、打包、优化,生成一个 bundle 或者多个 bundle。
它的原理 通过以上,主要就是找依赖, 通过配置处理相应环境,根据你的需要配置插件进行优化(如 profill、babel、 miniSize etc) 打包出文件,可以放到服务器上运行。
关于找依赖,可以想到关于模块化的语法: import 、require、@import etc, 通过解析对应的语法寻找相应的依赖。然后通过读取依赖到的文件,根据对应的 loader 进行处理文件,最后根据你的插件配置,分割,压缩或注入等,根据 output config输出到对应的文件夹。
这里推荐一篇 webpack原理 文章, 下面就提一提我最近遇到的一个很神奇的问题吧
想象抖一抖树,枯萎的叶子就会脱落。 这里指的是把没有用到的代码删除掉,从而减小文件的大小。通过这一优化,在引用多个第三方库时,能够大大的减少你的文件大小,但请确定这个包是没有副作用的。
什么是副作用? 就是在导入时会自行运行一段函数,从而改变了 window 变量啊或者其他的变量以供导入的包能正常运行, 而不是只单单 export 了变量。
它是依赖于 es2015 的 静态导入导出( import / export)
。在打包时就会通过 import 确定引用包的 export 导出的某一个变量之一, 在告知没有副作用的情况下,删除掉没有用到的其他的导出代码。
静态导入是指一开始就默认加载这个文件,而不是一步一步执行代码判断逻辑,去导入对应文件
webpack 在生成环境下,默认打开树抖动配置, 如下配置。
optimization: {\n\tprovidedExports: true,\n\tusedExports: true,\n\tsideEffects: true,\n\tconcatenateModules: true,\n }\n
providedExports
开启 export 导出收集; usedExportts
告诉webpack确定每个模块的已使用导出; concatenateModules
告诉webpack查找模块图的各个部分,这些部分可以安全地连接成一个模块; sideEffects
告诉webpack识别 sideEffects 标志的 package.json 或规则以跳过模块,这些模块在未使用导出时被标记为不包含副作用, 则可以把无副作用的未使用的导出进行删除。
所以如果你的包无副作用,推荐在 package.json 设置 sideEffects: false
开启树抖动。 注意, 它会删掉样式文件,因为样式文件是没有 export 的。所以我们需要声明样式文件是有副作用的。 在 package.json 中设置:
sideEffects: [\n\t'*.css'\n]\n
总结,为了利用树木摇晃,你必须: 1 使用ES2015模块语法 (配置 babel 禁止转义 es6 模块语义) 2 将"sideEffects"属性添加到项目的 package.json文件中。 3 配合压缩工具一起使用
demo 通过配置 webpack.prod.js
sideEffects 值, 你可以看到 build 时 main.js 文件的大小发生改变。
',20)]))}]])}}]);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
\ No newline at end of file
diff --git a/731.bundle.js b/692.bundle.js
similarity index 57%
rename from 731.bundle.js
rename to 692.bundle.js
index de29a2f..d6243f8 100644
--- a/731.bundle.js
+++ b/692.bundle.js
@@ -1,2 +1,2 @@
-"use strict";(self.webpackChunkreact_wyz=self.webpackChunkreact_wyz||[]).push([[731],{731:(t,n,s)=>{s.r(n),s.d(n,{default:()=>e});const e="### 购买服务器\n\n学生购买可以使用阿里云优惠专享, 每个月只要9.9 就好了。这里我用的是学生优惠,机型内存什么都限定好了的。所以- - 没什么可以说的。关于国内外服务器的区别就是,如果你购买了国外的服务器,就可以在云服务器上搭梯子访问国外的网站,也就是翻墙了。\n\n### 安装环境\n\n因为服务器默认 linux 系统,所以这里讲怎么配置 linux 云服务环境。 \n我第一次使用的时候,还以为是要去安装一个界面化桌面,以便我这个命令小白可以操作。但是,对于只有2G 的内存来说安装了之后将会很卡很卡。后来我问学长,他说不要安装界面化,使用命令就好了。\n\n首先关于远程服务器的登录, 默认系统的用户名是 root, 然后登录密码可以在控制台进行修改。如下图点击重置密码。\n![重置密码处](https://img-blog.csdn.net/20180107170054918?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast) \n\n重置之后,然后点击远程连接,就可以连接登录到你的服务器上了。这里要将一点,如果你是 mac 电脑的话,可以在你的电脑上通过 ssh 登录到你的服务器。 命令如下:\n`ssh root@你的公网IP`,比如 `ssh root@120.78.32.12`\n然后输入密码即可连接成功。\n\n![登录成功图](https://img-blog.csdn.net/20180107170503333?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\n\n接下来在终端中输入命令。配置环境。如果你是配置 java 环境,那么可以去谷歌一下如何在 linux 中配置 java 环境,这里我是配置的 node 环境,就讲一下如何配置 node 环境以及 npm。\n\n这里我用的是源码安装。首先安装 node 编译依赖的第三方模块\n`yum -y install gcc make gcc-c++ openssl-devel`\n\n然后下载 node 的源码包\n![这里写图片描述](https://img-blog.csdn.net/20180107171300036?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\n\nnode 官网的源码 包。\n`wget https://nodejs.org/dist/v8.9.4/node-v8.9.4.tar.gz`\n\n你下载的时候可以手动改成当前最新版本。下载后,进行解压 `tar -zxvf node-v8.9.4.tar.gz`, 然后进入解压后的文件夹 ` cd node-v8.9.4`, 依次\n` ./configure`\n` make`\n`sudo make install`\n这里编译时间会有点久,请耐心等待- -\n查看安装成功\n![这里写图片描述](https://img-blog.csdn.net/20180107172311684?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\n\n安装 npm\n同样下载 npm 包\n`wget http://nodejs.org/dist/npm/npm-1.4.9.zip`\n解压 `tar -zxvf npm-1.4.9.tgz`\n查看是否安装成功 `npm -v`\n\n这就是 node 环境配置了, 然后就是 mysql 数据库。\n[http://blog.csdn.net/win7system/article/details/53579500](http://blog.csdn.net/win7system/article/details/53579500)\n\n关于项目的上传,如果你本地编写了代码,想上传至服务器,第一个方式,可以是使用 ftp 上传文件。 第二个方式,就是在你的服务器上搭建一个 git 服务器,通过从服务器推送和克隆项目来获取文件。这里我使用的是第二种方法,参见教程:\n[https://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000/00137583770360579bc4b458f044ce7afed3df579123eca000](https://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000/00137583770360579bc4b458f044ce7afed3df579123eca000)\n这里注意一下, 关于 设置 ssh 登录,一定要把创建的 .ssh 文件放到你创建的用户下,如我这里是 git 用户,路径就是\n![这里写图片描述](https://img-blog.csdn.net/20180107174529969?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\n\n放置在正确位置之后,还要注意项目的归属者也要是 git 用户,这样才会在 git 用户里匹配到对应的 ssh key。也就是下面这一个步骤\n![这里写图片描述](https://img-blog.csdn.net/20180107174749168?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\n\n还有一点要注意的就是,你再本地推送了代码上 git 服务器之后,想要在云服务器上获取到代码, 需要在服务器上再次克隆 `git clone git@server:/srv/sample.git` 项目,git pull 获取到代码。 这里也可以通过自己配置 git 服务器的钩子函数,使其自动更新代码,我还没配置,就先不说了 - -。\n\n好了,现在现在基本环境配置好了就可以开始开发你的项目啦。\n\n另外附: \n项目在服务器上启动了,发现在本地电脑无法通过 ip 访问,那么可能是你的端口号没有开放,需要去服务器上设置安全组。\n具体添加方法 ,以及其他一些关于服务器的配置,都可以随时点击右侧的 **点我提问**,像云博士提问。 = =\n![这里写图片描述](https://img-blog.csdn.net/20180107175548703?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)"}}]);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
\ No newline at end of file
+"use strict";(self.webpackChunkreact_wyz=self.webpackChunkreact_wyz||[]).push([[692],{2692:(t,n,s)=>{s.r(n),s.d(n,{default:()=>e});const e="### 购买服务器\n\n学生购买可以使用阿里云优惠专享, 每个月只要9.9 就好了。这里我用的是学生优惠,机型内存什么都限定好了的。所以- - 没什么可以说的。关于国内外服务器的区别就是,如果你购买了国外的服务器,就可以在云服务器上搭梯子访问国外的网站,也就是翻墙了。\n\n### 安装环境\n\n因为服务器默认 linux 系统,所以这里讲怎么配置 linux 云服务环境。 \n我第一次使用的时候,还以为是要去安装一个界面化桌面,以便我这个命令小白可以操作。但是,对于只有2G 的内存来说安装了之后将会很卡很卡。后来我问学长,他说不要安装界面化,使用命令就好了。\n\n首先关于远程服务器的登录, 默认系统的用户名是 root, 然后登录密码可以在控制台进行修改。如下图点击重置密码。\n![重置密码处](https://img-blog.csdn.net/20180107170054918?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast) \n\n重置之后,然后点击远程连接,就可以连接登录到你的服务器上了。这里要将一点,如果你是 mac 电脑的话,可以在你的电脑上通过 ssh 登录到你的服务器。 命令如下:\n`ssh root@你的公网IP`,比如 `ssh root@120.78.32.12`\n然后输入密码即可连接成功。\n\n![登录成功图](https://img-blog.csdn.net/20180107170503333?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\n\n接下来在终端中输入命令。配置环境。如果你是配置 java 环境,那么可以去谷歌一下如何在 linux 中配置 java 环境,这里我是配置的 node 环境,就讲一下如何配置 node 环境以及 npm。\n\n这里我用的是源码安装。首先安装 node 编译依赖的第三方模块\n`yum -y install gcc make gcc-c++ openssl-devel`\n\n然后下载 node 的源码包\n![这里写图片描述](https://img-blog.csdn.net/20180107171300036?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\n\nnode 官网的源码 包。\n`wget https://nodejs.org/dist/v8.9.4/node-v8.9.4.tar.gz`\n\n你下载的时候可以手动改成当前最新版本。下载后,进行解压 `tar -zxvf node-v8.9.4.tar.gz`, 然后进入解压后的文件夹 ` cd node-v8.9.4`, 依次\n` ./configure`\n` make`\n`sudo make install`\n这里编译时间会有点久,请耐心等待- -\n查看安装成功\n![这里写图片描述](https://img-blog.csdn.net/20180107172311684?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\n\n安装 npm\n同样下载 npm 包\n`wget http://nodejs.org/dist/npm/npm-1.4.9.zip`\n解压 `tar -zxvf npm-1.4.9.tgz`\n查看是否安装成功 `npm -v`\n\n这就是 node 环境配置了, 然后就是 mysql 数据库。\n[http://blog.csdn.net/win7system/article/details/53579500](http://blog.csdn.net/win7system/article/details/53579500)\n\n关于项目的上传,如果你本地编写了代码,想上传至服务器,第一个方式,可以是使用 ftp 上传文件。 第二个方式,就是在你的服务器上搭建一个 git 服务器,通过从服务器推送和克隆项目来获取文件。这里我使用的是第二种方法,参见教程:\n[https://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000/00137583770360579bc4b458f044ce7afed3df579123eca000](https://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000/00137583770360579bc4b458f044ce7afed3df579123eca000)\n这里注意一下, 关于 设置 ssh 登录,一定要把创建的 .ssh 文件放到你创建的用户下,如我这里是 git 用户,路径就是\n![这里写图片描述](https://img-blog.csdn.net/20180107174529969?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\n\n放置在正确位置之后,还要注意项目的归属者也要是 git 用户,这样才会在 git 用户里匹配到对应的 ssh key。也就是下面这一个步骤\n![这里写图片描述](https://img-blog.csdn.net/20180107174749168?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)\n\n还有一点要注意的就是,你再本地推送了代码上 git 服务器之后,想要在云服务器上获取到代码, 需要在服务器上再次克隆 `git clone git@server:/srv/sample.git` 项目,git pull 获取到代码。 这里也可以通过自己配置 git 服务器的钩子函数,使其自动更新代码,我还没配置,就先不说了 - -。\n\n好了,现在现在基本环境配置好了就可以开始开发你的项目啦。\n\n另外附: \n项目在服务器上启动了,发现在本地电脑无法通过 ip 访问,那么可能是你的端口号没有开放,需要去服务器上设置安全组。\n具体添加方法 ,以及其他一些关于服务器的配置,都可以随时点击右侧的 **点我提问**,像云博士提问。 = =\n![这里写图片描述](https://img-blog.csdn.net/20180107175548703?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZGFkYWRlZ2FuaHVv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)"}}]);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
\ No newline at end of file
diff --git a/72.bundle.js b/72.bundle.js
deleted file mode 100644
index 43b71e9..0000000
--- a/72.bundle.js
+++ /dev/null
@@ -1,2 +0,0 @@
-"use strict";(self.webpackChunkreact_wyz=self.webpackChunkreact_wyz||[]).push([[72],{72:(s,t,e)=>{e.r(t),e.d(t,{default:()=>c});const c="## 写 css 遇到了问题怎么办?\n\n### 如何让 css 写的更轻松?\n#### [postcss-ui-theme](https://github.com/cleverboy32/postcss-ui-theme),让你实现类 sass 语法,一个插件就能做到!\n\n### 如何改变 css 主题 ?\n\n#### [postcss-ui-theme ](https://github.com/cleverboy32/postcss-ui-theme), 可打包 css4 变量被保留,不仅可在引用时直接使用新的变量文件覆盖改变主题,还可以通过 js 进行更改!!!\n### css 在别的项目被编译,文件路径找不到?\n\n#### [postcss-ui-theme](https://github.com/cleverboy32/postcss-ui-theme), 集成 postcss-assets 插件,通过配置 文件查找路径,解决引用文件找不到问题!!\n\n\n### [postcss-ui-theme](https://github.com/cleverboy32/postcss-ui-theme) 插件,就是你的 css 管理方案的最佳选择! 点 star 收藏!!! 茫茫前端路,你真的会用到它的!\n\n\n"}}]);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiNzIuYnVuZGxlLmpzIiwibWFwcGluZ3MiOiJnSUFBQSw4a0IiLCJzb3VyY2VzIjpbIndlYnBhY2s6Ly9yZWFjdF93eXovLi4vLi4vYmxvZ3MvbWFya2Rvd24vcG9zdGNzcy1wbHVnaW4ubWQiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQgXCIjIyDlhpkgY3NzIOmBh+WIsOS6humXrumimOaAjuS5iOWKnu+8n1xcblxcbiMjIyDlpoLkvZXorqkgY3NzIOWGmeeahOabtOi9u+advu+8n1xcbiMjIyMgW3Bvc3Rjc3MtdWktdGhlbWVdKGh0dHBzOi8vZ2l0aHViLmNvbS9jbGV2ZXJib3kzMi9wb3N0Y3NzLXVpLXRoZW1lKe+8jOiuqeS9oOWunueOsOexuyBzYXNzIOivreazle+8jOS4gOS4quaPkuS7tuWwseiDveWBmuWIsO+8gVxcblxcbiMjIyDlpoLkvZXmlLnlj5ggY3NzIOS4u+mimCDvvJ9cXG5cXG4jIyMjIFtwb3N0Y3NzLXVpLXRoZW1lIF0oaHR0cHM6Ly9naXRodWIuY29tL2NsZXZlcmJveTMyL3Bvc3Rjc3MtdWktdGhlbWUp77yMIOWPr+aJk+WMhSBjc3M0IOWPmOmHj+iiq+S/neeVme+8jOS4jeS7heWPr+WcqOW8leeUqOaXtuebtOaOpeS9v+eUqOaWsOeahOWPmOmHj+aWh+S7tuimhuebluaUueWPmOS4u+mimO+8jOi/mOWPr+S7pemAmui/hyBqcyDov5vooYzmm7TmlLnvvIHvvIHvvIFcXG4jIyMgIGNzcyDlnKjliKvnmoTpobnnm67ooqvnvJbor5HvvIzmlofku7bot6/lvoTmib7kuI3liLDvvJ9cXG5cXG4jIyMjIFtwb3N0Y3NzLXVpLXRoZW1lXShodHRwczovL2dpdGh1Yi5jb20vY2xldmVyYm95MzIvcG9zdGNzcy11aS10aGVtZSnvvIwg6ZuG5oiQIHBvc3Rjc3MtYXNzZXRzIOaPkuS7tu+8jOmAmui/h+mFjee9riDmlofku7bmn6Xmib7ot6/lvoTvvIzop6PlhrPlvJXnlKjmlofku7bmib7kuI3liLDpl67popjvvIHvvIFcXG5cXG5cXG4jIyMgW3Bvc3Rjc3MtdWktdGhlbWVdKGh0dHBzOi8vZ2l0aHViLmNvbS9jbGV2ZXJib3kzMi9wb3N0Y3NzLXVpLXRoZW1lKSDmj5Lku7bvvIzlsLHmmK/kvaDnmoQgY3NzIOeuoeeQhuaWueahiOeahOacgOS9s+mAieaLqSEg54K5IHN0YXIg5pS26JeP77yB77yB77yBIOiMq+iMq+WJjeerr+i3r++8jOS9oOecn+eahOS8mueUqOWIsOWug+eahO+8gVxcblxcblxcblwiOyJdLCJuYW1lcyI6W10sInNvdXJjZVJvb3QiOiIifQ==
\ No newline at end of file
diff --git a/966.bundle.js b/739.bundle.js
similarity index 57%
rename from 966.bundle.js
rename to 739.bundle.js
index b64d0bf..712f271 100644
--- a/966.bundle.js
+++ b/739.bundle.js
@@ -1,2 +1,2 @@
-"use strict";(self.webpackChunkreact_wyz=self.webpackChunkreact_wyz||[]).push([[966],{966:(n,s,e)=>{e.r(s),e.d(s,{default:()=>t});const t="# 安全意识\n\n你要离开家了, 所有的父母都会说,路上注意安全,可见安全是多么的重要!那么作为软件开发,有哪些危险使我们要知道并避免的呢?\n下面我说一些基本的需要知道的安全攻击, 以及应对方案。\n\n> ps 作为一个安全小白,了解各种各样的防范方案真的太难了,我是真的水🤭。欢迎补充,以增长见识\n\n## XSS: 跨站脚本攻击\n\n在用户可以输入的地方,并且将作为代码编译时,攻击者可以通过输入一个脚本地址的方式进行对页面注入脚本攻击。解决方式: 任何用户输入的地方都不要相信,对用户输入内容进行转义,如 `<` 使用转义字符串 `<` 代替。\n\n## CSRF: 跨站伪装请求攻击\n\n在用户已登录的情况下,伪装用户的身份发起请求,进行相关攻击。解决方式,确认用户的身份。比较好理解的解决方式是: 二次确认,通过用户的二次确认确认请求方为真实用户。然后就是 X-Requested-With 请求标志,通过该请求头设置标志位 `ajax` 请求,可以一定程度阻止跨域的伪装。`Anti-CSRF TOKEN` 方案:通过服务端与客户端唯一的 token 值进行校验,可以看做一个暗号,让别人无法伪装!\n\n## 网络劫持\n\n### Jsonp 劫持\n\n我们都知道 `jsonp` 就是为了解决跨域的,如果传输信息设计到比较敏感的数据,那么别人可以很方便调用你的接口,获取你的数据,存储在自己的数据库中。解决方法,添加脚本可运行白名单,不要传输敏感信息。\n\n\n### HTTP 劫持。\n\nHTTP 是明文传输,所以运营商可以知道你的代码是什么,然后在里面加一点小广告什么的,改变你的内容。解决方法就是使用 https 协议,可耻的运营商\n\n### DNS 劫持 \n通过域名解析我们才能找到对域名的服务器 ip 地址,劫持了 DNS 就可以给你返回一个错误的 ip 地址。在 dns 解析中,会先在本机搜索域名解析记录,无相关记录像 dns 服务商发起请求。所以要么你本地信息被篡改,要么服务商欺骗你。\n[转一篇 DNS 劫持详解链接](https://juejin.im/post/5cff858a6fb9a07ed84238ec)\n\n## 接口安全\n\n### 数据库\n\n数据库,插入数据库的参数,在执行 sql 的时候小心它把你整个数据库表给删了。这里的攻击类似 `xss` 攻击,通过传输、拼接一些字符串改变原本的 sql 语义\n\n### 推送消息\n\n比如短信发送消息,非常的有代表性。通过接口的参数传递,以及最后的发送内容,可以推测出你的推送内容的组合相关方式,就可以通过不良参数,很方便的发送的一些不合法的信息,或有毒链接给用户。解决方式就是不要相信用户传入的任何参数,对参数进行校验,发送内容尽量可选择匹配模式,如 code 值映射,对不合法的参数才有默认内容发送。\n\n## DDOS:分布式拒绝服务\n\n就是很多请求大量涌入你的服务器,导致它们都没有空闲可以响应真正的用户请求。通过 TCP 连接,我们知道建立连接需要三次确认,一般攻击者可以伪造 ip, 发起大量连接请求,却又不确认 = = 导致服务器白白等待直到超时。其次可以借用别的用户,在一个大流量用户网站地方的某一个页面上了,通过 `xss` 默认发起对攻击网站的请求,并发送很大的数据,但每次发送很少的字节,这些用户就被当成了肉鸡,然后使其瘫痪。解决防范:增加机器, 对同一个ip 的过多请求进行防范。 \n"}}]);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
\ No newline at end of file
+"use strict";(self.webpackChunkreact_wyz=self.webpackChunkreact_wyz||[]).push([[739],{6739:(n,s,e)=>{e.r(s),e.d(s,{default:()=>t});const t="# 安全意识\n\n你要离开家了, 所有的父母都会说,路上注意安全,可见安全是多么的重要!那么作为软件开发,有哪些危险使我们要知道并避免的呢?\n下面我说一些基本的需要知道的安全攻击, 以及应对方案。\n\n> ps 作为一个安全小白,了解各种各样的防范方案真的太难了,我是真的水🤭。欢迎补充,以增长见识\n\n## XSS: 跨站脚本攻击\n\n在用户可以输入的地方,并且将作为代码编译时,攻击者可以通过输入一个脚本地址的方式进行对页面注入脚本攻击。解决方式: 任何用户输入的地方都不要相信,对用户输入内容进行转义,如 `<` 使用转义字符串 `<` 代替。\n\n## CSRF: 跨站伪装请求攻击\n\n在用户已登录的情况下,伪装用户的身份发起请求,进行相关攻击。解决方式,确认用户的身份。比较好理解的解决方式是: 二次确认,通过用户的二次确认确认请求方为真实用户。然后就是 X-Requested-With 请求标志,通过该请求头设置标志位 `ajax` 请求,可以一定程度阻止跨域的伪装。`Anti-CSRF TOKEN` 方案:通过服务端与客户端唯一的 token 值进行校验,可以看做一个暗号,让别人无法伪装!\n\n## 网络劫持\n\n### Jsonp 劫持\n\n我们都知道 `jsonp` 就是为了解决跨域的,如果传输信息设计到比较敏感的数据,那么别人可以很方便调用你的接口,获取你的数据,存储在自己的数据库中。解决方法,添加脚本可运行白名单,不要传输敏感信息。\n\n\n### HTTP 劫持。\n\nHTTP 是明文传输,所以运营商可以知道你的代码是什么,然后在里面加一点小广告什么的,改变你的内容。解决方法就是使用 https 协议,可耻的运营商\n\n### DNS 劫持 \n通过域名解析我们才能找到对域名的服务器 ip 地址,劫持了 DNS 就可以给你返回一个错误的 ip 地址。在 dns 解析中,会先在本机搜索域名解析记录,无相关记录像 dns 服务商发起请求。所以要么你本地信息被篡改,要么服务商欺骗你。\n[转一篇 DNS 劫持详解链接](https://juejin.im/post/5cff858a6fb9a07ed84238ec)\n\n## 接口安全\n\n### 数据库\n\n数据库,插入数据库的参数,在执行 sql 的时候小心它把你整个数据库表给删了。这里的攻击类似 `xss` 攻击,通过传输、拼接一些字符串改变原本的 sql 语义\n\n### 推送消息\n\n比如短信发送消息,非常的有代表性。通过接口的参数传递,以及最后的发送内容,可以推测出你的推送内容的组合相关方式,就可以通过不良参数,很方便的发送的一些不合法的信息,或有毒链接给用户。解决方式就是不要相信用户传入的任何参数,对参数进行校验,发送内容尽量可选择匹配模式,如 code 值映射,对不合法的参数才有默认内容发送。\n\n## DDOS:分布式拒绝服务\n\n就是很多请求大量涌入你的服务器,导致它们都没有空闲可以响应真正的用户请求。通过 TCP 连接,我们知道建立连接需要三次确认,一般攻击者可以伪造 ip, 发起大量连接请求,却又不确认 = = 导致服务器白白等待直到超时。其次可以借用别的用户,在一个大流量用户网站地方的某一个页面上了,通过 `xss` 默认发起对攻击网站的请求,并发送很大的数据,但每次发送很少的字节,这些用户就被当成了肉鸡,然后使其瘫痪。解决防范:增加机器, 对同一个ip 的过多请求进行防范。 \n"}}]);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
\ No newline at end of file
diff --git a/721.bundle.js b/772.bundle.js
similarity index 55%
rename from 721.bundle.js
rename to 772.bundle.js
index c5b5309..a76ffc5 100644
--- a/721.bundle.js
+++ b/772.bundle.js
@@ -1,2 +1,2 @@
-"use strict";(self.webpackChunkreact_wyz=self.webpackChunkreact_wyz||[]).push([[721],{721:(e,c,s)=>{s.r(c),s.d(c,{default:()=>t});const t="# cleverboy 的学习笔记"}}]);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiNzIxLmJ1bmRsZS5qcyIsIm1hcHBpbmdzIjoia0lBQUEsMkIiLCJzb3VyY2VzIjpbIndlYnBhY2s6Ly9yZWFjdF93eXovLi4vLi4vYmxvZ3MvbWFya2Rvd24vcmVhZG1lLm1kIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IFwiIyBjbGV2ZXJib3kg55qE5a2m5Lmg56yU6K6wXCI7Il0sIm5hbWVzIjpbXSwic291cmNlUm9vdCI6IiJ9
\ No newline at end of file
+"use strict";(self.webpackChunkreact_wyz=self.webpackChunkreact_wyz||[]).push([[772],{5772:(e,c,s)=>{s.r(c),s.d(c,{default:()=>t});const t="# cleverboy 的学习笔记"}}]);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiNzcyLmJ1bmRsZS5qcyIsIm1hcHBpbmdzIjoibUlBQUEsMkIiLCJzb3VyY2VzIjpbIndlYnBhY2s6Ly9yZWFjdF93eXovLi4vLi4vYmxvZ3MvbWFya2Rvd24vcmVhZG1lLm1kIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IFwiIyBjbGV2ZXJib3kg55qE5a2m5Lmg56yU6K6wXCI7Il0sIm5hbWVzIjpbXSwic291cmNlUm9vdCI6IiJ9
\ No newline at end of file
diff --git a/344.bundle.js b/867.bundle.js
similarity index 57%
rename from 344.bundle.js
rename to 867.bundle.js
index 782c780..7aba7ba 100644
--- a/344.bundle.js
+++ b/867.bundle.js
@@ -1,2 +1,2 @@
-"use strict";(self.webpackChunkreact_wyz=self.webpackChunkreact_wyz||[]).push([[344],{344:(e,n,t)=>{t.r(n),t.d(n,{default:()=>s});const s="#### 一 webpack 是什么?\n它是一个打包工具。 噗,完啦?\n\n来,我们看官方概念: webpack 是一个现代 JavaScript 应用程序的静态模块打包工具。当 webpack 处理应用程序时,它会在内部构建一个 依赖图(dependency graph),此依赖图会映射项目所需的每个模块,并生成一个或多个 bundle。\n\n内部如何构建一个依赖图,我们知道 webpack 会配置一个入口,这就是从这入口文件开始, 找到所有被依赖到的文件,比如其他 js / image / json 文件等,然后通过 loader 对这些文件进行处理、编译、打包、优化,生成一个 bundle 或者多个 bundle。\n\n#### 它的原理\n通过以上,主要就是找依赖, 通过配置处理相应环境,根据你的需要配置插件进行优化(如 profill、babel、 miniSize etc) 打包出文件,可以放到服务器上运行。 \n\n关于找依赖,可以想到关于模块化的语法: import 、require、@import etc, 通过解析对应的语法寻找相应的依赖。然后通过读取依赖到的文件,根据对应的 loader 进行处理文件,最后根据你的插件配置,分割,压缩或注入等,根据 output config输出到对应的文件夹。\n\n这里推荐一篇 [webpack原理](https://juejin.im/entry/5b0e3eba5188251534379615) 文章, 下面就提一提我最近遇到的一个很神奇的问题吧\n\n#### 关于 [tree shaking](https://webpack.docschina.org/guides/tree-shaking/)\n想象抖一抖树,枯萎的叶子就会脱落。 这里指的是把没有用到的代码删除掉,从而减小文件的大小。通过这一优化,在引用多个第三方库时,能够大大的减少你的文件大小,但请确定这个包是没有副作用的。\n>什么是副作用?\n就是在导入时会自行运行一段函数,从而改变了 window 变量啊或者其他的变量以供导入的包能正常运行, 而不是只单单 export 了变量。\n\n它是依赖于 es2015 的 `静态导入导出( import / export)`。在打包时就会通过 import 确定引用包的 export 导出的某一个变量之一, 在告知没有副作用的情况下,删除掉没有用到的其他的导出代码。 \n> 静态导入是指一开始就默认加载这个文件,而不是一步一步执行代码判断逻辑,去导入对应文件\n\nwebpack 在生成环境下,默认打开树抖动配置, 如下配置。\n```\noptimization: {\n\tprovidedExports: true,\n\tusedExports: true,\n\tsideEffects: true,\n\tconcatenateModules: true,\n }\n ```\n \n `providedExports` 开启 export 导出收集;\n` usedExportts` 告诉webpack确定每个模块的已使用导出;\n` concatenateModules` 告诉webpack查找模块图的各个部分,这些部分可以安全地连接成一个模块;\n`sideEffects` 告诉webpack识别 sideEffects 标志的 package.json 或规则以跳过模块,这些模块在未使用导出时被标记为不包含副作用, 则可以把无副作用的未使用的导出进行删除。\n\n所以如果你的包无副作用,推荐在 package.json 设置 `sideEffects: false` 开启树抖动。\n注意, 它会删掉样式文件,因为样式文件是没有 export 的。所以我们需要声明样式文件是有副作用的。\n在 package.json 中设置:\n```\nsideEffects: [\n\t'*.css'\n]\n```\n>总结,为了利用树木摇晃,你必须:\n> 1 使用ES2015模块语法 (配置 babel 禁止转义 es6 模块语义)\n> 2 将\"sideEffects\"属性添加到项目的 package.json文件中。\n> 3 配合压缩工具一起使用\n\n\n[demo](https://github.com/cleverboy32/tree-shaking-css)\n通过配置 `webpack.prod.js` sideEffects 值, 你可以看到 build 时 main.js 文件的大小发生改变。"}}]);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMzQ0LmJ1bmRsZS5qcyIsIm1hcHBpbmdzIjoia0lBQUEsZzZEIiwic291cmNlcyI6WyJ3ZWJwYWNrOi8vcmVhY3Rfd3l6Ly4uLy4uL2Jsb2dzL21hcmtkb3duL3dlYnBhY2subWQiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQgXCIjIyMjIOS4gCAgd2VicGFjayDmmK/ku4DkuYjvvJ9cXG7lroPmmK/kuIDkuKrmiZPljIXlt6XlhbfjgIIg5ZmX77yM5a6M5ZWm77yfXFxuXFxu5p2l77yM5oiR5Lus55yL5a6Y5pa55qaC5b+1OiAgd2VicGFjayDmmK/kuIDkuKrnjrDku6MgSmF2YVNjcmlwdCDlupTnlKjnqIvluo/nmoTpnZnmgIHmqKHlnZfmiZPljIXlt6XlhbfjgILlvZMgd2VicGFjayDlpITnkIblupTnlKjnqIvluo/ml7bvvIzlroPkvJrlnKjlhoXpg6jmnoTlu7rkuIDkuKog5L6d6LWW5Zu+KGRlcGVuZGVuY3kgZ3JhcGgp77yM5q2k5L6d6LWW5Zu+5Lya5pig5bCE6aG555uu5omA6ZyA55qE5q+P5Liq5qih5Z2X77yM5bm255Sf5oiQ5LiA5Liq5oiW5aSa5LiqIGJ1bmRsZeOAglxcblxcbuWGhemDqOWmguS9leaehOW7uuS4gOS4quS+nei1luWbvu+8jOaIkeS7rOefpemBkyB3ZWJwYWNrIOS8mumFjee9ruS4gOS4quWFpeWPo++8jOi/meWwseaYr+S7jui/meWFpeWPo+aWh+S7tuW8gOWni++8jCDmib7liLDmiYDmnInooqvkvp3otZbliLDnmoTmlofku7bvvIzmr5TlpoLlhbbku5YganMgLyBpbWFnZSAvIGpzb24g5paH5Lu2562J77yM54S25ZCO6YCa6L+HIGxvYWRlciDlr7nov5nkupvmlofku7bov5vooYzlpITnkIbjgIHnvJbor5HjgIHmiZPljIXjgIHkvJjljJbvvIznlJ/miJDkuIDkuKogYnVuZGxlIOaIluiAheWkmuS4qiBidW5kbGXjgIJcXG5cXG4jIyMjIOWug+eahOWOn+eQhlxcbumAmui/h+S7peS4iu+8jOS4u+imgeWwseaYr+aJvuS+nei1liwg6YCa6L+H6YWN572u5aSE55CG55u45bqU546v5aKD77yM5qC55o2u5L2g55qE6ZyA6KaB6YWN572u5o+S5Lu26L+b6KGM5LyY5YyW77yI5aaCIHByb2ZpbGzjgIFiYWJlbOOAgSBtaW5pU2l6ZSBldGMpIOaJk+WMheWHuuaWh+S7tu+8jOWPr+S7peaUvuWIsOacjeWKoeWZqOS4iui/kOihjOOAgiBcXG5cXG7lhbPkuo7mib7kvp3otZbvvIzlj6/ku6Xmg7PliLDlhbPkuo7mqKHlnZfljJbnmoTor63ms5U6IGltcG9ydCDjgIFyZXF1aXJl44CBQGltcG9ydCBldGPvvIwg6YCa6L+H6Kej5p6Q5a+55bqU55qE6K+t5rOV5a+75om+55u45bqU55qE5L6d6LWW44CC54S25ZCO6YCa6L+H6K+75Y+W5L6d6LWW5Yiw55qE5paH5Lu277yM5qC55o2u5a+55bqU55qEIGxvYWRlciDov5vooYzlpITnkIbmlofku7bvvIzmnIDlkI7moLnmja7kvaDnmoTmj5Lku7bphY3nva7vvIzliIblibLvvIzljovnvKnmiJbms6jlhaXnrYnvvIzmoLnmja4gb3V0cHV0IGNvbmZpZ+i+k+WHuuWIsOWvueW6lOeahOaWh+S7tuWkueOAglxcblxcbui/memHjOaOqOiNkOS4gOevhyBbd2VicGFja+WOn+eQhl0oaHR0cHM6Ly9qdWVqaW4uaW0vZW50cnkvNWIwZTNlYmE1MTg4MjUxNTM0Mzc5NjE1KSDmlofnq6AsIOS4i+mdouWwseaPkOS4gOaPkOaIkeacgOi/kemBh+WIsOeahOS4gOS4quW+iOelnuWlh+eahOmXrumimOWQp1xcblxcbiMjIyMg5YWz5LqOIFt0cmVlIHNoYWtpbmddKGh0dHBzOi8vd2VicGFjay5kb2NzY2hpbmEub3JnL2d1aWRlcy90cmVlLXNoYWtpbmcvKVxcbuaDs+ixoeaKluS4gOaKluagke+8jOaer+iQjueahOWPtuWtkOWwseS8muiEseiQveOAgiDov5nph4zmjIfnmoTmmK/miormsqHmnInnlKjliLDnmoTku6PnoIHliKDpmaTmjonvvIzku47ogIzlh4/lsI/mlofku7bnmoTlpKflsI/jgILpgJrov4fov5nkuIDkvJjljJbvvIzlnKjlvJXnlKjlpJrkuKrnrKzkuInmlrnlupPml7bvvIzog73lpJ/lpKflpKfnmoTlh4/lsJHkvaDnmoTmlofku7blpKflsI/vvIzkvYbor7fnoa7lrprov5nkuKrljIXmmK/msqHmnInlia/kvZznlKjnmoTjgIJcXG4+5LuA5LmI5piv5Ymv5L2c55SoP1xcbuWwseaYr+WcqOWvvOWFpeaXtuS8muiHquihjOi/kOihjOS4gOauteWHveaVsO+8jOS7juiAjOaUueWPmOS6hiB3aW5kb3cg5Y+Y6YeP5ZWK5oiW6ICF5YW25LuW55qE5Y+Y6YeP5Lul5L6b5a+85YWl55qE5YyF6IO95q2j5bi46L+Q6KGM77yMIOiAjOS4jeaYr+WPquWNleWNlSBleHBvcnQg5LqG5Y+Y6YeP44CCXFxuXFxu5a6D5piv5L6d6LWW5LqOIGVzMjAxNSDnmoQgYOmdmeaAgeWvvOWFpeWvvOWHuiggaW1wb3J0IC8gZXhwb3J0KWDjgILlnKjmiZPljIXml7blsLHkvJrpgJrov4cgaW1wb3J0IOehruWumuW8leeUqOWMheeahCBleHBvcnQg5a+85Ye655qE5p+Q5LiA5Liq5Y+Y6YeP5LmL5LiA77yMIOWcqOWRiuefpeayoeacieWJr+S9nOeUqOeahOaDheWGteS4i++8jOWIoOmZpOaOieayoeacieeUqOWIsOeahOWFtuS7lueahOWvvOWHuuS7o+eggeOAgiBcXG4+IOmdmeaAgeWvvOWFpeaYr+aMh+S4gOW8gOWni+Wwsem7mOiupOWKoOi9vei/meS4quaWh+S7tu+8jOiAjOS4jeaYr+S4gOatpeS4gOatpeaJp+ihjOS7o+eggeWIpOaWremAu+i+ke+8jOWOu+WvvOWFpeWvueW6lOaWh+S7tlxcblxcbndlYnBhY2sg5Zyo55Sf5oiQ546v5aKD5LiL77yM6buY6K6k5omT5byA5qCR5oqW5Yqo6YWN572uLCDlpoLkuIvphY3nva7jgIJcXG5gYGBcXG5vcHRpbWl6YXRpb27vvJoge1xcblxcdHByb3ZpZGVkRXhwb3J0czogdHJ1ZSxcXG5cXHR1c2VkRXhwb3J0czogdHJ1ZSxcXG5cXHRzaWRlRWZmZWN0czogdHJ1ZSxcXG5cXHRjb25jYXRlbmF0ZU1vZHVsZXM6IHRydWUsXFxuIH1cXG4gYGBgXFxuIFxcbiBgcHJvdmlkZWRFeHBvcnRzYCDlvIDlkK8gZXhwb3J0IOWvvOWHuuaUtumbhu+8m1xcbmAgdXNlZEV4cG9ydHRzYCDlkYror4l3ZWJwYWNr56Gu5a6a5q+P5Liq5qih5Z2X55qE5bey5L2/55So5a+85Ye677ybXFxuYCBjb25jYXRlbmF0ZU1vZHVsZXNgICDlkYror4l3ZWJwYWNr5p+l5om+5qih5Z2X5Zu+55qE5ZCE5Liq6YOo5YiG77yM6L+Z5Lqb6YOo5YiG5Y+v5Lul5a6J5YWo5Zyw6L+e5o6l5oiQ5LiA5Liq5qih5Z2X77ybXFxuYHNpZGVFZmZlY3RzYCDlkYror4l3ZWJwYWNr6K+G5YirIHNpZGVFZmZlY3RzIOagh+W/l+eahCBwYWNrYWdlLmpzb24g5oiW6KeE5YiZ5Lul6Lez6L+H5qih5Z2X77yM6L+Z5Lqb5qih5Z2X5Zyo5pyq5L2/55So5a+85Ye65pe26KKr5qCH6K6w5Li65LiN5YyF5ZCr5Ymv5L2c55So77yMIOWImeWPr+S7peaKiuaXoOWJr+S9nOeUqOeahOacquS9v+eUqOeahOWvvOWHuui/m+ihjOWIoOmZpOOAglxcblxcbuaJgOS7peWmguaenOS9oOeahOWMheaXoOWJr+S9nOeUqO+8jOaOqOiNkOWcqCBwYWNrYWdlLmpzb24g6K6+572uIGBzaWRlRWZmZWN0czogZmFsc2VgIOW8gOWQr+agkeaKluWKqOOAglxcbuazqOaEjywg5a6D5Lya5Yig5o6J5qC35byP5paH5Lu277yM5Zug5Li65qC35byP5paH5Lu25piv5rKh5pyJIGV4cG9ydCDnmoTjgILmiYDku6XmiJHku6zpnIDopoHlo7DmmI7moLflvI/mlofku7bmmK/mnInlia/kvZznlKjnmoTjgIJcXG7lnKggcGFja2FnZS5qc29uIOS4reiuvue9ru+8mlxcbmBgYFxcbnNpZGVFZmZlY3RzOiBbXFxuXFx0JyouY3NzJ1xcbl1cXG5gYGBcXG4+5oC757uT77yM5Li65LqG5Yip55So5qCR5pyo5pGH5pmD77yM5L2g5b+F6aG777yaXFxuPiAxIOS9v+eUqEVTMjAxNeaooeWdl+ivreazlSAo6YWN572uIGJhYmVsIOemgeatoui9rOS5iSBlczYg5qih5Z2X6K+t5LmJ77yJXFxuPiAyIOWwhlxcXCJzaWRlRWZmZWN0c1xcXCLlsZ7mgKfmt7vliqDliLDpobnnm67nmoQgcGFja2FnZS5qc29u5paH5Lu25Lit44CCXFxuPiAgMyDphY3lkIjljovnvKnlt6XlhbfkuIDotbfkvb/nlKhcXG5cXG5cXG5bZGVtb10oaHR0cHM6Ly9naXRodWIuY29tL2NsZXZlcmJveTMyL3RyZWUtc2hha2luZy1jc3MpXFxu6YCa6L+H6YWN572uICBgd2VicGFjay5wcm9kLmpzYCBzaWRlRWZmZWN0cyDlgLzvvIwg5L2g5Y+v5Lul55yL5YiwIGJ1aWxkIOaXtiBtYWluLmpzIOaWh+S7tueahOWkp+Wwj+WPkeeUn+aUueWPmOOAglwiOyJdLCJuYW1lcyI6W10sInNvdXJjZVJvb3QiOiIifQ==
\ No newline at end of file
+"use strict";(self.webpackChunkreact_wyz=self.webpackChunkreact_wyz||[]).push([[867],{1867:(e,n,t)=>{t.r(n),t.d(n,{default:()=>s});const s="#### 一 webpack 是什么?\n它是一个打包工具。 噗,完啦?\n\n来,我们看官方概念: webpack 是一个现代 JavaScript 应用程序的静态模块打包工具。当 webpack 处理应用程序时,它会在内部构建一个 依赖图(dependency graph),此依赖图会映射项目所需的每个模块,并生成一个或多个 bundle。\n\n内部如何构建一个依赖图,我们知道 webpack 会配置一个入口,这就是从这入口文件开始, 找到所有被依赖到的文件,比如其他 js / image / json 文件等,然后通过 loader 对这些文件进行处理、编译、打包、优化,生成一个 bundle 或者多个 bundle。\n\n#### 它的原理\n通过以上,主要就是找依赖, 通过配置处理相应环境,根据你的需要配置插件进行优化(如 profill、babel、 miniSize etc) 打包出文件,可以放到服务器上运行。 \n\n关于找依赖,可以想到关于模块化的语法: import 、require、@import etc, 通过解析对应的语法寻找相应的依赖。然后通过读取依赖到的文件,根据对应的 loader 进行处理文件,最后根据你的插件配置,分割,压缩或注入等,根据 output config输出到对应的文件夹。\n\n这里推荐一篇 [webpack原理](https://juejin.im/entry/5b0e3eba5188251534379615) 文章, 下面就提一提我最近遇到的一个很神奇的问题吧\n\n#### 关于 [tree shaking](https://webpack.docschina.org/guides/tree-shaking/)\n想象抖一抖树,枯萎的叶子就会脱落。 这里指的是把没有用到的代码删除掉,从而减小文件的大小。通过这一优化,在引用多个第三方库时,能够大大的减少你的文件大小,但请确定这个包是没有副作用的。\n>什么是副作用?\n就是在导入时会自行运行一段函数,从而改变了 window 变量啊或者其他的变量以供导入的包能正常运行, 而不是只单单 export 了变量。\n\n它是依赖于 es2015 的 `静态导入导出( import / export)`。在打包时就会通过 import 确定引用包的 export 导出的某一个变量之一, 在告知没有副作用的情况下,删除掉没有用到的其他的导出代码。 \n> 静态导入是指一开始就默认加载这个文件,而不是一步一步执行代码判断逻辑,去导入对应文件\n\nwebpack 在生成环境下,默认打开树抖动配置, 如下配置。\n```\noptimization: {\n\tprovidedExports: true,\n\tusedExports: true,\n\tsideEffects: true,\n\tconcatenateModules: true,\n }\n ```\n \n `providedExports` 开启 export 导出收集;\n` usedExportts` 告诉webpack确定每个模块的已使用导出;\n` concatenateModules` 告诉webpack查找模块图的各个部分,这些部分可以安全地连接成一个模块;\n`sideEffects` 告诉webpack识别 sideEffects 标志的 package.json 或规则以跳过模块,这些模块在未使用导出时被标记为不包含副作用, 则可以把无副作用的未使用的导出进行删除。\n\n所以如果你的包无副作用,推荐在 package.json 设置 `sideEffects: false` 开启树抖动。\n注意, 它会删掉样式文件,因为样式文件是没有 export 的。所以我们需要声明样式文件是有副作用的。\n在 package.json 中设置:\n```\nsideEffects: [\n\t'*.css'\n]\n```\n>总结,为了利用树木摇晃,你必须:\n> 1 使用ES2015模块语法 (配置 babel 禁止转义 es6 模块语义)\n> 2 将\"sideEffects\"属性添加到项目的 package.json文件中。\n> 3 配合压缩工具一起使用\n\n\n[demo](https://github.com/cleverboy32/tree-shaking-css)\n通过配置 `webpack.prod.js` sideEffects 值, 你可以看到 build 时 main.js 文件的大小发生改变。"}}]);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
\ No newline at end of file
diff --git a/707.bundle.js b/870.bundle.js
similarity index 57%
rename from 707.bundle.js
rename to 870.bundle.js
index 4c09e75..88ef120 100644
--- a/707.bundle.js
+++ b/870.bundle.js
@@ -1,2 +1,2 @@
-"use strict";(self.webpackChunkreact_wyz=self.webpackChunkreact_wyz||[]).push([[707],{707:(n,e,t)=>{t.r(e),t.d(e,{default:()=>o});const o="当我们要完成一个应用的时候,会根据对应的功能划分为许多不同的模块,就像一个论坛,有发帖的模块,评论的模块,js 中的模块也正是如此,一个具体功能的代码抽成一个文件,当你做一个东西的时候需要用到这个功能的时,可以直接使用这个文件,实现功能的分离,并能在多个需要的地方使用。就像是螺丝钉、螺丝帽、垫片一样的,通过组合使用实现出你的产品。\n\n通过直白的描述,我们可以知道,模块化的好处就是,抽离代码,重复使用,如现在很直观的代表 npm 包。\n\n\n\n那么模块化到底是怎么实现的呢?\n\n先来了解一下历史,以前的 html 不知道大家还记不记的, 一个html 页面引入了多个 js 文件.\n```\n\n\n\n \n So UI - A Component Library for Vue.js. \n\n\n
\n