ngx-markdown
Version:
Angular library that uses marked to parse markdown to html combined with Prism.js for synthax highlights
541 lines (524 loc) • 57.8 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/common'), require('@angular/common/http'), require('@angular/platform-browser'), require('marked'), require('rxjs/operators')) :
typeof define === 'function' && define.amd ? define('ngx-markdown', ['exports', '@angular/core', '@angular/common', '@angular/common/http', '@angular/platform-browser', 'marked', 'rxjs/operators'], factory) :
(factory((global['ngx-markdown'] = {}),global.ng.core,global.ng.common,global.ng.common.http,global.ng.platformBrowser,null,global.rxjs.operators));
}(this, (function (exports,core,common,http,platformBrowser,marked,operators) { 'use strict';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var LanguagePipe = /** @class */ (function () {
function LanguagePipe() {
}
/**
* @param {?} value
* @param {?} language
* @return {?}
*/
LanguagePipe.prototype.transform = /**
* @param {?} value
* @param {?} language
* @return {?}
*/
function (value, language) {
if (typeof value !== 'string') {
console.error("LanguagePipe has been invoked with an invalid value type [" + value + "]");
return value;
}
if (typeof language !== 'string') {
console.error("LanguagePipe has been invoked with an invalid parameter [" + language + "]");
return value;
}
return '```' + language + '\n' + value + '\n```';
};
LanguagePipe.decorators = [
{ type: core.Pipe, args: [{
name: 'language',
},] },
];
return LanguagePipe;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var MarkedOptions = /** @class */ (function () {
function MarkedOptions() {
}
return MarkedOptions;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/** @type {?} */
var errorSrcWithoutHttpClient = '[ngx-markdown] When using the [src] attribute you *have to* pass the `HttpClient` as a parameter of the `forRoot` method. See README for more information';
var MarkdownService = /** @class */ (function () {
function MarkdownService(platform, http$$1, domSanitizer, options) {
this.platform = platform;
this.http = http$$1;
this.domSanitizer = domSanitizer;
this.options = options;
if (!this.renderer) {
this.renderer = new marked.Renderer();
}
}
Object.defineProperty(MarkdownService.prototype, "renderer", {
get: /**
* @return {?}
*/ function () { return this.options.renderer; },
set: /**
* @param {?} value
* @return {?}
*/ function (value) {
this.options.renderer = value;
},
enumerable: true,
configurable: true
});
/**
* @param {?} markdown
* @param {?=} decodeHtml
* @param {?=} markedOptions
* @return {?}
*/
MarkdownService.prototype.compile = /**
* @param {?} markdown
* @param {?=} decodeHtml
* @param {?=} markedOptions
* @return {?}
*/
function (markdown, decodeHtml, markedOptions) {
if (decodeHtml === void 0) {
decodeHtml = false;
}
if (markedOptions === void 0) {
markedOptions = this.options;
}
/** @type {?} */
var precompiled = this.precompile(markdown);
/** @type {?} */
var compiled = marked.parse(decodeHtml ? this.decodeHtml(precompiled) : precompiled, markedOptions);
return markedOptions.sanitize && !markedOptions.sanitizer
? this.domSanitizer.sanitize(core.SecurityContext.HTML, compiled)
: compiled;
};
/**
* @param {?} src
* @return {?}
*/
MarkdownService.prototype.getSource = /**
* @param {?} src
* @return {?}
*/
function (src) {
var _this = this;
if (!this.http) {
throw new Error(errorSrcWithoutHttpClient);
}
return this.http
.get(src, { responseType: 'text' })
.pipe(operators.map(function (markdown) { return _this.handleExtension(src, markdown); }));
};
/**
* @return {?}
*/
MarkdownService.prototype.highlight = /**
* @return {?}
*/
function () {
if (common.isPlatformBrowser(this.platform) && typeof Prism !== 'undefined') {
Prism.highlightAll(false);
}
};
/**
* @param {?} html
* @return {?}
*/
MarkdownService.prototype.decodeHtml = /**
* @param {?} html
* @return {?}
*/
function (html) {
if (common.isPlatformBrowser(this.platform)) {
/** @type {?} */
var textarea = document.createElement('textarea');
textarea.innerHTML = html;
return textarea.value;
}
return html;
};
/**
* @param {?} src
* @param {?} markdown
* @return {?}
*/
MarkdownService.prototype.handleExtension = /**
* @param {?} src
* @param {?} markdown
* @return {?}
*/
function (src, markdown) {
/** @type {?} */
var extension = src
? src.split('.').splice(-1).join()
: null;
return extension !== 'md'
? '```' + extension + '\n' + markdown + '\n```'
: markdown;
};
/**
* @param {?} markdown
* @return {?}
*/
MarkdownService.prototype.precompile = /**
* @param {?} markdown
* @return {?}
*/
function (markdown) {
if (!markdown) {
return '';
}
/** @type {?} */
var indentStart;
return markdown
.split('\n')
.map(function (line) {
/** @type {?} */
var lineIdentStart = indentStart;
// find position of 1st non-whitespace character
// to determine the current line indentation start
if (line.length > 0) {
lineIdentStart = isNaN(lineIdentStart)
? line.search(/\S|$/)
: Math.min(line.search(/\S|$/), lineIdentStart);
}
// keep 1st non-whitespace line indentation
// as base reference for other lines
if (isNaN(indentStart)) {
indentStart = lineIdentStart;
}
// remove whitespaces before current line indentation
return !!lineIdentStart
? line.substring(lineIdentStart)
: line;
}).join('\n');
};
MarkdownService.decorators = [
{ type: core.Injectable },
];
/** @nocollapse */
MarkdownService.ctorParameters = function () {
return [
{ type: Object, decorators: [{ type: core.Inject, args: [core.PLATFORM_ID,] }] },
{ type: http.HttpClient, decorators: [{ type: core.Optional }] },
{ type: platformBrowser.DomSanitizer },
{ type: MarkedOptions }
];
};
return MarkdownService;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var MarkdownComponent = /** @class */ (function () {
function MarkdownComponent(element, markdownService) {
this.element = element;
this.markdownService = markdownService;
this.error = new core.EventEmitter();
this.load = new core.EventEmitter();
}
Object.defineProperty(MarkdownComponent.prototype, "_isTranscluded", {
get: /**
* @return {?}
*/ function () {
return !this._data && !this._src;
},
enumerable: true,
configurable: true
});
Object.defineProperty(MarkdownComponent.prototype, "data", {
get: /**
* @return {?}
*/ function () { return this._data; },
set: /**
* @param {?} value
* @return {?}
*/ function (value) {
this._data = value;
this.render(value);
},
enumerable: true,
configurable: true
});
Object.defineProperty(MarkdownComponent.prototype, "src", {
get: /**
* @return {?}
*/ function () { return this._src; },
set: /**
* @param {?} value
* @return {?}
*/ function (value) {
var _this = this;
this._src = value;
this.markdownService
.getSource(value)
.subscribe(function (markdown) {
_this.render(markdown);
_this.load.emit(markdown);
}, function (error) { return _this.error.emit(error); });
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
MarkdownComponent.prototype.ngAfterViewInit = /**
* @return {?}
*/
function () {
if (this._isTranscluded) {
this.render(this.element.nativeElement.innerHTML, true);
}
};
/**
* @param {?} markdown
* @param {?=} decodeHtml
* @return {?}
*/
MarkdownComponent.prototype.render = /**
* @param {?} markdown
* @param {?=} decodeHtml
* @return {?}
*/
function (markdown, decodeHtml) {
if (decodeHtml === void 0) {
decodeHtml = false;
}
this.element.nativeElement.innerHTML = this.markdownService.compile(markdown, decodeHtml);
this.markdownService.highlight();
};
MarkdownComponent.decorators = [
{ type: core.Component, args: [{
// tslint:disable-next-line:component-selector
selector: 'markdown, [markdown]',
template: '<ng-content></ng-content>',
},] },
];
/** @nocollapse */
MarkdownComponent.ctorParameters = function () {
return [
{ type: core.ElementRef },
{ type: MarkdownService }
];
};
MarkdownComponent.propDecorators = {
data: [{ type: core.Input }],
src: [{ type: core.Input }],
error: [{ type: core.Output }],
load: [{ type: core.Output }]
};
return MarkdownComponent;
}());
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b)
if (b.hasOwnProperty(p))
d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m)
return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
ar.push(r.value);
}
catch (error) {
e = { error: error };
}
finally {
try {
if (r && !r.done && (m = i["return"]))
m.call(i);
}
finally {
if (e)
throw e.error;
}
}
return ar;
}
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var MarkdownPipe = /** @class */ (function () {
function MarkdownPipe(markdownService, zone) {
this.markdownService = markdownService;
this.zone = zone;
}
/**
* @param {?} value
* @return {?}
*/
MarkdownPipe.prototype.transform = /**
* @param {?} value
* @return {?}
*/
function (value) {
var _this = this;
if (typeof value !== 'string') {
console.error("MarkdownPipe has been invoked with an invalid value type [" + value + "]");
return value;
}
/** @type {?} */
var markdown = this.markdownService.compile(value);
this.zone.onStable
.pipe(operators.first())
.subscribe(function () { return _this.markdownService.highlight(); });
return markdown;
};
MarkdownPipe.decorators = [
{ type: core.Pipe, args: [{
name: 'markdown',
},] },
];
/** @nocollapse */
MarkdownPipe.ctorParameters = function () {
return [
{ type: MarkdownService },
{ type: core.NgZone }
];
};
return MarkdownPipe;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/** @type {?} */
var initialMarkedOptions = {
provide: MarkedOptions,
useValue: {
gfm: true,
tables: true,
breaks: false,
pedantic: false,
sanitize: false,
smartLists: true,
smartypants: false,
},
};
/** @type {?} */
var sharedDeclarations = [
LanguagePipe,
MarkdownComponent,
MarkdownPipe,
];
var MarkdownModule = /** @class */ (function () {
function MarkdownModule() {
}
/**
* @param {?=} markdownModuleConfig
* @return {?}
*/
MarkdownModule.forRoot = /**
* @param {?=} markdownModuleConfig
* @return {?}
*/
function (markdownModuleConfig) {
return {
ngModule: MarkdownModule,
providers: __spread([
MarkdownService
], (markdownModuleConfig
? [
markdownModuleConfig.loader || [],
markdownModuleConfig.markedOptions || initialMarkedOptions,
]
: [initialMarkedOptions])),
};
};
/**
* @return {?}
*/
MarkdownModule.forChild = /**
* @return {?}
*/
function () {
return {
ngModule: MarkdownModule,
};
};
MarkdownModule.decorators = [
{ type: core.NgModule, args: [{
exports: __spread(sharedDeclarations),
declarations: __spread(sharedDeclarations),
},] },
];
return MarkdownModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var MarkedRenderer = /** @class */ (function (_super) {
__extends(MarkedRenderer, _super);
function MarkedRenderer() {
return _super !== null && _super.apply(this, arguments) || this;
}
return MarkedRenderer;
}(marked.Renderer));
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
exports.LanguagePipe = LanguagePipe;
exports.MarkdownComponent = MarkdownComponent;
exports.initialMarkedOptions = initialMarkedOptions;
exports.MarkdownModule = MarkdownModule;
exports.MarkdownPipe = MarkdownPipe;
exports.errorSrcWithoutHttpClient = errorSrcWithoutHttpClient;
exports.MarkdownService = MarkdownService;
exports.MarkedOptions = MarkedOptions;
exports.MarkedRenderer = MarkedRenderer;
Object.defineProperty(exports, '__esModule', { value: true });
})));
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ngx-markdown.umd.js.map","sources":["ng://ngx-markdown/src/language.pipe.ts","ng://ngx-markdown/src/marked-options.ts","ng://ngx-markdown/src/markdown.service.ts","ng://ngx-markdown/src/markdown.component.ts",null,"ng://ngx-markdown/src/markdown.pipe.ts","ng://ngx-markdown/src/markdown.module.ts","ng://ngx-markdown/src/marked-renderer.ts"],"sourcesContent":["import { Pipe, PipeTransform } from '@angular/core';\r\n\r\n@Pipe({\r\n  name: 'language',\r\n})\r\nexport class LanguagePipe implements PipeTransform {\r\n\r\n  transform(value: string, language: string): string {\r\n    if (typeof value !== 'string') {\r\n      console.error(`LanguagePipe has been invoked with an invalid value type [${value}]`);\r\n      return value;\r\n    }\r\n    if (typeof language !== 'string') {\r\n      console.error(`LanguagePipe has been invoked with an invalid parameter [${language}]`);\r\n      return value;\r\n    }\r\n    return '```' + language + '\\n' +  value + '\\n```';\r\n  }\r\n}\r\n","import { Renderer } from 'marked';\r\n\r\nexport class MarkedOptions implements marked.MarkedOptions {\r\n  /**\r\n   * A prefix URL for any relative link.\r\n   */\r\n  baseUrl?: string;\r\n\r\n  /**\r\n   * Enable GFM line breaks. This option requires the gfm option to be true.\r\n   */\r\n  breaks?: boolean;\r\n\r\n  /**\r\n   * Enable GitHub flavored markdown.\r\n   */\r\n  gfm?: boolean;\r\n\r\n  /**\r\n   * Include an id attribute when emitting headings.\r\n   */\r\n  headerIds?: boolean;\r\n\r\n  /**\r\n   * Set the prefix for header tag ids.\r\n   */\r\n  headerPrefix?: string;\r\n\r\n  /**\r\n   * Set the prefix for code block classes.\r\n   */\r\n  langPrefix?: string;\r\n\r\n  /**\r\n   * Mangle autolinks (<email@domain.com>).\r\n   */\r\n  mangle?: boolean;\r\n\r\n  /**\r\n   * Conform to obscure parts of markdown.pl as much as possible. Don't fix any of the original markdown bugs or poor behavior.\r\n   */\r\n  pedantic?: boolean;\r\n\r\n  /**\r\n   * Type: object Default: new Renderer()\r\n   *\r\n   * An object containing functions to render tokens to HTML.\r\n   */\r\n  renderer?: Renderer;\r\n\r\n  /**\r\n   * Sanitize the output. Ignore any HTML that has been input.\r\n   */\r\n  sanitize?: boolean;\r\n\r\n  /**\r\n   * Shows an HTML error message when rendering fails.\r\n   */\r\n  silent?: boolean;\r\n\r\n  /**\r\n   * Use smarter list behavior than the original markdown. May eventually be default with the old behavior moved into pedantic.\r\n   */\r\n  smartLists?: boolean;\r\n\r\n  /**\r\n   * Use \"smart\" typograhic punctuation for things like quotes and dashes.\r\n   */\r\n  smartypants?: boolean;\r\n\r\n  /**\r\n   * Enable GFM tables. This option requires the gfm option to be true.\r\n   */\r\n  tables?: boolean;\r\n\r\n  /**\r\n   * Generate closing slash for self-closing tags (<br/> instead of <br>)\r\n   */\r\n  xhtml?: boolean;\r\n\r\n  /**\r\n   * A function to highlight code blocks. The function takes three arguments: code, lang, and callback.\r\n   */\r\n  highlight?(code: string, lang: string, callback?: (error: any | undefined, code: string) => void): string;\r\n\r\n  /**\r\n   * Optionally sanitize found HTML with a sanitizer function.\r\n   */\r\n  sanitizer?(html: string): string;\r\n}\r\n","import { isPlatformBrowser } from '@angular/common';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { Inject, Injectable, Optional, PLATFORM_ID, SecurityContext } from '@angular/core';\r\nimport { DomSanitizer } from '@angular/platform-browser';\r\nimport { parse, Renderer } from 'marked';\r\nimport { Observable } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\n\r\nimport { MarkedOptions } from './marked-options';\r\n\r\ndeclare var Prism: {\r\n  highlightAll: (async: boolean) => void;\r\n};\r\n\r\n// tslint:disable-next-line:max-line-length\r\nexport const errorSrcWithoutHttpClient = '[ngx-markdown] When using the [src] attribute you *have to* pass the `HttpClient` as a parameter of the `forRoot` method. See README for more information';\r\n\r\n@Injectable()\r\nexport class MarkdownService {\r\n  get renderer(): Renderer { return this.options.renderer; }\r\n  set renderer(value: marked.Renderer) {\r\n    this.options.renderer = value;\r\n  }\r\n\r\n  constructor(\r\n    @Inject(PLATFORM_ID) private platform: Object,\r\n    @Optional() private http: HttpClient,\r\n    private domSanitizer: DomSanitizer,\r\n    public options: MarkedOptions,\r\n  ) {\r\n    if (!this.renderer) {\r\n      this.renderer = new Renderer();\r\n    }\r\n  }\r\n\r\n  compile(markdown: string, decodeHtml = false, markedOptions = this.options): string {\r\n    const precompiled = this.precompile(markdown);\r\n    const compiled = parse(\r\n      decodeHtml ? this.decodeHtml(precompiled) : precompiled,\r\n      markedOptions);\r\n    return markedOptions.sanitize && !markedOptions.sanitizer\r\n      ? this.domSanitizer.sanitize(SecurityContext.HTML, compiled)\r\n      : compiled;\r\n  }\r\n\r\n  getSource(src: string): Observable<string> {\r\n    if (!this.http) {\r\n      throw new Error(errorSrcWithoutHttpClient);\r\n    }\r\n    return this.http\r\n      .get(src, { responseType: 'text' })\r\n      .pipe(map(markdown => this.handleExtension(src, markdown)));\r\n  }\r\n\r\n  highlight() {\r\n    if (isPlatformBrowser(this.platform) && typeof Prism !== 'undefined') {\r\n      Prism.highlightAll(false);\r\n    }\r\n  }\r\n\r\n  private decodeHtml(html: string) {\r\n    if (isPlatformBrowser(this.platform)) {\r\n      const textarea = document.createElement('textarea');\r\n      textarea.innerHTML = html;\r\n      return textarea.value;\r\n    }\r\n    return html;\r\n  }\r\n\r\n  private handleExtension(src: string, markdown: string): string {\r\n    const extension = src\r\n      ? src.split('.').splice(-1).join()\r\n      : null;\r\n    return extension !== 'md'\r\n      ? '```' + extension + '\\n' + markdown + '\\n```'\r\n      : markdown;\r\n  }\r\n\r\n  private precompile(markdown: string): string {\r\n    if (!markdown) {\r\n      return '';\r\n    }\r\n    let indentStart: number;\r\n    return markdown\r\n      .split('\\n')\r\n      .map(line => {\r\n        // set current line ident start to base reference indentation\r\n        let lineIdentStart = indentStart;\r\n        // find position of 1st non-whitespace character\r\n        // to determine the current line indentation start\r\n        if (line.length > 0) {\r\n          lineIdentStart = isNaN(lineIdentStart)\r\n            ? line.search(/\\S|$/)\r\n            : Math.min(line.search(/\\S|$/), lineIdentStart);\r\n        }\r\n        // keep 1st non-whitespace line indentation\r\n        // as base reference for other lines\r\n        if (isNaN(indentStart)) {\r\n          indentStart = lineIdentStart;\r\n        }\r\n        // remove whitespaces before current line indentation\r\n        return !!lineIdentStart\r\n          ? line.substring(lineIdentStart)\r\n          : line;\r\n      }).join('\\n');\r\n  }\r\n}\r\n","import { AfterViewInit, Component, ElementRef, EventEmitter, Input, Output } from '@angular/core';\r\n\r\nimport { MarkdownService } from './markdown.service';\r\n\r\n@Component({\r\n  // tslint:disable-next-line:component-selector\r\n  selector: 'markdown, [markdown]',\r\n  template: '<ng-content></ng-content>',\r\n})\r\nexport class MarkdownComponent implements AfterViewInit {\r\n  private _data: string;\r\n  private _src: string;\r\n\r\n  private get _isTranscluded() {\r\n    return !this._data && !this._src;\r\n  }\r\n\r\n  @Input()\r\n  get data(): string { return this._data; }\r\n  set data(value: string) {\r\n    this._data = value;\r\n    this.render(value);\r\n  }\r\n\r\n  @Input()\r\n  get src(): string { return this._src; }\r\n  set src(value: string) {\r\n    this._src = value;\r\n    this.markdownService\r\n      .getSource(value)\r\n      .subscribe(\r\n        markdown => {\r\n          this.render(markdown);\r\n          this.load.emit(markdown);\r\n        },\r\n        error => this.error.emit(error),\r\n      );\r\n  }\r\n\r\n  @Output() error = new EventEmitter<string>();\r\n  @Output() load = new EventEmitter<string>();\r\n\r\n  constructor(\r\n    public element: ElementRef,\r\n    public markdownService: MarkdownService,\r\n  ) { }\r\n\r\n  ngAfterViewInit() {\r\n    if (this._isTranscluded) {\r\n      this.render(this.element.nativeElement.innerHTML, true);\r\n    }\r\n  }\r\n\r\n  render(markdown: string, decodeHtml = false) {\r\n    this.element.nativeElement.innerHTML = this.markdownService.compile(markdown, decodeHtml);\r\n    this.markdownService.highlight();\r\n  }\r\n}\r\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n","import { NgZone, Pipe, PipeTransform } from '@angular/core';\r\nimport { first } from 'rxjs/operators';\r\n\r\nimport { MarkdownService } from './markdown.service';\r\n\r\n@Pipe({\r\n  name: 'markdown',\r\n})\r\nexport class MarkdownPipe implements PipeTransform {\r\n\r\n  constructor(\r\n    private markdownService: MarkdownService,\r\n    private zone: NgZone,\r\n  ) { }\r\n\r\n  transform(value: string): string {\r\n    if (typeof value !== 'string') {\r\n      console.error(`MarkdownPipe has been invoked with an invalid value type [${value}]`);\r\n      return value;\r\n    }\r\n\r\n    const markdown = this.markdownService.compile(value);\r\n\r\n    this.zone.onStable\r\n      .pipe(first())\r\n      .subscribe(() => this.markdownService.highlight());\r\n\r\n    return markdown;\r\n  }\r\n}\r\n","import { ModuleWithProviders, NgModule, Provider } from '@angular/core';\r\n\r\nimport { LanguagePipe } from './language.pipe';\r\nimport { MarkdownComponent } from './markdown.component';\r\nimport { MarkdownPipe } from './markdown.pipe';\r\nimport { MarkdownService } from './markdown.service';\r\nimport { MarkedOptions } from './marked-options';\r\n\r\n// having a dependency on `HttpClientModule` within a library\r\n// breaks all the interceptors from the app consuming the library\r\n// here, we explicitely ask the user to pass a provider with\r\n// their own instance of `HttpClientModule`\r\nexport interface MarkdownModuleConfig {\r\n  loader?: Provider;\r\n  markedOptions?: Provider;\r\n}\r\n\r\nexport const initialMarkedOptions: Provider = {\r\n  provide: MarkedOptions,\r\n  useValue: {\r\n    gfm: true,\r\n    tables: true,\r\n    breaks: false,\r\n    pedantic: false,\r\n    sanitize: false,\r\n    smartLists: true,\r\n    smartypants: false,\r\n  },\r\n};\r\n\r\nconst sharedDeclarations = [\r\n  LanguagePipe,\r\n  MarkdownComponent,\r\n  MarkdownPipe,\r\n];\r\n\r\n@NgModule({\r\n  exports: [\r\n    ...sharedDeclarations,\r\n  ],\r\n  declarations: [\r\n    ...sharedDeclarations,\r\n  ],\r\n})\r\nexport class MarkdownModule {\r\n  static forRoot(markdownModuleConfig?: MarkdownModuleConfig): ModuleWithProviders {\r\n    return {\r\n      ngModule: MarkdownModule,\r\n      providers: [\r\n        MarkdownService,\r\n        ...(markdownModuleConfig\r\n          ? [\r\n              markdownModuleConfig.loader || [],\r\n              markdownModuleConfig.markedOptions || initialMarkedOptions,\r\n            ]\r\n          : [initialMarkedOptions]),\r\n      ],\r\n    };\r\n  }\r\n\r\n  static forChild(): ModuleWithProviders {\r\n    return {\r\n      ngModule: MarkdownModule,\r\n    };\r\n  }\r\n}\r\n","import { Renderer } from 'marked';\r\n\r\nexport class MarkedRenderer extends Renderer { }\r\n"],"names":["Pipe","http","Renderer","parse","SecurityContext","map","isPlatformBrowser","Injectable","Inject","PLATFORM_ID","HttpClient","Optional","DomSanitizer","EventEmitter","Component","ElementRef","Input","Output","first","NgZone","NgModule","tslib_1.__extends"],"mappings":";;;;;;;;;;AAAA;;;;;;;;QAOE,gCAAS;;;;;YAAT,UAAU,KAAa,EAAE,QAAgB;gBACvC,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;oBAC7B,OAAO,CAAC,KAAK,CAAC,+DAA6D,KAAK,MAAG,CAAC,CAAC;oBACrF,OAAO,KAAK,CAAC;iBACd;gBACD,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE;oBAChC,OAAO,CAAC,KAAK,CAAC,8DAA4D,QAAQ,MAAG,CAAC,CAAC;oBACvF,OAAO,KAAK,CAAC;iBACd;gBACD,OAAO,KAAK,GAAG,QAAQ,GAAG,IAAI,GAAI,KAAK,GAAG,OAAO,CAAC;aACnD;;oBAfFA,SAAI,SAAC;wBACJ,IAAI,EAAE,UAAU;qBACjB;;2BAJD;;;;;;;ACEA,QAAA;;;4BAFA;QAyFC;;;;;;ACzFD;AAeA,QAAa,yBAAyB,GAAG,2JAA2J,CAAC;;QASnM,yBAC+B,QAAgB,EACzBC,OAAgB,EAC5B,cACD;YAHsB,aAAQ,GAAR,QAAQ,CAAQ;YACzB,SAAI,GAAJA,OAAI,CAAY;YAC5B,iBAAY,GAAZ,YAAY;YACb,YAAO,GAAP,OAAO;YAEd,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;gBAClB,IAAI,CAAC,QAAQ,GAAG,IAAIC,eAAQ,EAAE,CAAC;aAChC;SACF;QAdD,sBAAI,qCAAQ;;;gBAAZ,cAA2B,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;;;;gBAC1D,UAAa,KAAsB;gBACjC,IAAI,CAAC,OAAO,CAAC,QAAQ,GAAG,KAAK,CAAC;aAC/B;;;WAHyD;;;;;;;QAgB1D,iCAAO;;;;;;YAAP,UAAQ,QAAgB,EAAE,UAAkB,EAAE,aAA4B;gBAAhD,2BAAA;oBAAA,kBAAkB;;gBAAE,8BAAA;oBAAA,gBAAgB,IAAI,CAAC,OAAO;;;gBACxE,IAAM,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;;gBAC9C,IAAM,QAAQ,GAAGC,YAAK,CACpB,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,GAAG,WAAW,EACvD,aAAa,CAAC,CAAC;gBACjB,OAAO,aAAa,CAAC,QAAQ,IAAI,CAAC,aAAa,CAAC,SAAS;sBACrD,IAAI,CAAC,YAAY,CAAC,QAAQ,CAACC,oBAAe,CAAC,IAAI,EAAE,QAAQ,CAAC;sBAC1D,QAAQ,CAAC;aACd;;;;;QAED,mCAAS;;;;YAAT,UAAU,GAAW;gBAArB,iBAOC;gBANC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;oBACd,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;iBAC5C;gBACD,OAAO,IAAI,CAAC,IAAI;qBACb,GAAG,CAAC,GAAG,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC;qB