@papillonarts/components 0.34.0 → 0.35.0

package/build/Legacy/Alert/__tests__/{Alert.markdown.docs.md → Alert.doc.md}

@@ -5,23 +5,23 @@
 ```
 # Featues
 
-> Regular, RegularMultipleParagraphs
+> Default, DefaultMultipleParagraphs
 > Info, Warning, Error, Success
 > Full, Banner
-> RegularConsentWithInput, RegularConsentWithoutInput
+> DefaultConsentWithInput, DefaultConsentWithoutInput
 ```
 
-## Regular
+## Default
 
-> Alert component regular feature
+> Alert component default feature
 
 ```jsx
 <Alert variant={AlertVariant.Default}>{children}</Alert>
 ```
 
-## RegularMultipleParagraphs
+## DefaultMultipleParagraphs
 
-> Alert component regular multiple paragraphs feature
+> Alert component default multiple paragraphs feature
 
 ```jsx
 <Alert variant={AlertVariant.Default}>
@@ -81,9 +81,9 @@
 <Alert variant={AlertVariant.Banner}>{children}</Alert>
 ```
 
-## RegularConsentWithInput
+## DefaultConsentWithInput
 
-> Alert component regular consent with input feature
+> Alert component default consent with input feature
 
 ```jsx
 <Alert variant={AlertVariant.Default} consent={getConsent({ hasInput: true })}>
@@ -91,9 +91,9 @@
 </Alert>
 ```
 
-## RegularConsentWithoutInput
+## DefaultConsentWithoutInput
 
-> Alert component regular consent without input feature
+> Alert component default consent without input feature
 
 ```jsx
 <Alert variant={AlertVariant.Default} consent={getConsent({ hasInput: false })}>
@@ -101,9 +101,9 @@
 </Alert>
 ```
 
-## RegularConsentCustom
+## DefaultConsentCustom
 
-> Alert component regular consent custom feature
+> Alert component default consent custom feature
 
 ```jsx
 <Alert variant={AlertVariant.Default} consent={consent}>

package/build/Legacy/Markdown/Markdown.d.ts

@@ -0,0 +1,3 @@
+import { IMarkdown } from './Markdown.type';
+export declare function Markdown({ highlighter, children }: IMarkdown): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Markdown.d.ts.map

package/build/Legacy/Markdown/Markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Markdown.d.ts","sourceRoot":"","sources":["../../../src/Legacy/Markdown/Markdown.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAwC,MAAM,iBAAiB,CAAA;AAEjF,wBAAgB,QAAQ,CAAC,EAAE,WAAyC,EAAE,QAAQ,EAAE,EAAE,SAAS,2CAgD1F"}

package/build/Legacy/{MarkdownDocs/MarkdownDocs.js → Markdown/Markdown.js}

@@ -4,26 +4,26 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.MarkdownDocs = MarkdownDocs;
+exports.Markdown = Markdown;
 var _reactMarkdown = _interopRequireDefault(require("react-markdown"));
 var _remarkGfm = _interopRequireDefault(require("remark-gfm"));
-var _PreformattedCode = require("../PreformattedCode");
-var _MarkdownDocs = require("./MarkdownDocs.type");
+var _SyntaxHighlighter = require("../SyntaxHighlighter");
+var _Markdown = require("./Markdown.type");
 var _jsxRuntime = require("react/jsx-runtime");
-function MarkdownDocs(_ref) {
+function Markdown(_ref) {
   var _ref$highlighter = _ref.highlighter,
-    highlighter = _ref$highlighter === void 0 ? _MarkdownDocs.MarkdownDocsDefault.Highlighter : _ref$highlighter,
+    highlighter = _ref$highlighter === void 0 ? _Markdown.MarkdownDefault.Highlighter : _ref$highlighter,
     children = _ref.children;
-  if (highlighter == _MarkdownDocs.MarkdownDocsHighlighter.HLJS) {
+  if (highlighter == _Markdown.MarkdownHighlighter.HLJS) {
     return /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactMarkdown["default"], {
       remarkPlugins: [_remarkGfm["default"]],
       components: {
         code: function code(props) {
           var propsChildren = props.children;
-          return /*#__PURE__*/(0, _jsxRuntime.jsx)(_PreformattedCode.PreformattedCode, {
-            highlighter: _PreformattedCode.PreformattedCodeHighlighter.HLJS,
-            language: _PreformattedCode.PreformattedCodeLanguage.Markdown,
-            style: _PreformattedCode.PreformattedCodeStyle.Ocean,
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(_SyntaxHighlighter.SyntaxHighlighter, {
+            highlighter: _SyntaxHighlighter.SyntaxHighlighterHighlighter.HLJS,
+            language: _SyntaxHighlighter.SyntaxHighlighterLanguage.Markdown,
+            style: _SyntaxHighlighter.SyntaxHighlighterStyle.Ocean,
             children: String(propsChildren).replace(/\n$/, '')
           });
         }
@@ -31,16 +31,16 @@ function MarkdownDocs(_ref) {
       children: children
     });
   }
-  if (highlighter == _MarkdownDocs.MarkdownDocsHighlighter.PRISM) {
+  if (highlighter == _Markdown.MarkdownHighlighter.PRISM) {
     return /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactMarkdown["default"], {
       remarkPlugins: [_remarkGfm["default"]],
       components: {
         code: function code(props) {
           var propsChildren = props.children;
-          return /*#__PURE__*/(0, _jsxRuntime.jsx)(_PreformattedCode.PreformattedCode, {
-            highlighter: _PreformattedCode.PreformattedCodeHighlighter.PRISM,
-            language: _PreformattedCode.PreformattedCodeLanguage.Markdown,
-            style: _PreformattedCode.PreformattedCodeStyle.Nord,
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(_SyntaxHighlighter.SyntaxHighlighter, {
+            highlighter: _SyntaxHighlighter.SyntaxHighlighterHighlighter.PRISM,
+            language: _SyntaxHighlighter.SyntaxHighlighterLanguage.Markdown,
+            style: _SyntaxHighlighter.SyntaxHighlighterStyle.Nord,
             children: String(propsChildren).replace(/\n$/, '')
           });
         }

package/build/Legacy/Markdown/Markdown.type.d.ts

@@ -0,0 +1,15 @@
+export interface IMarkdownHighlighter {
+    HLJS: string;
+    PRISM: string;
+}
+export declare const MarkdownHighlighter: IMarkdownHighlighter;
+export interface IMarkdownDefault {
+    Highlighter?: string;
+    Children: string;
+}
+export declare const MarkdownDefault: IMarkdownDefault;
+export interface IMarkdown {
+    highlighter?: string;
+    children?: string;
+}
+//# sourceMappingURL=Markdown.type.d.ts.map

package/build/Legacy/Markdown/Markdown.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Markdown.type.d.ts","sourceRoot":"","sources":["../../../src/Legacy/Markdown/Markdown.type.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd;AAED,eAAO,MAAM,mBAAmB,EAAE,oBAGjC,CAAA;AAED,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,eAAO,MAAM,eAAe,EAAE,gBAG7B,CAAA;AAED,MAAM,WAAW,SAAS;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB"}

package/build/Legacy/Markdown/Markdown.type.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MarkdownHighlighter = exports.MarkdownDefault = void 0;
+var MarkdownHighlighter = exports.MarkdownHighlighter = {
+  HLJS: 'HLJS',
+  PRISM: 'PRISM'
+};
+var MarkdownDefault = exports.MarkdownDefault = {
+  Highlighter: MarkdownHighlighter.PRISM,
+  Children: ''
+};

package/build/Legacy/Markdown/__tests__/Markdown.doc.md

@@ -0,0 +1,33 @@
+# Markdown
+
+> Markdown component all features
+
+```
+# Features
+
+> Default
+```
+
+## Default
+
+> Markdown component default feature
+
+```jsx
+<Markdown>{MarkdownUnformattedCode}</Markdown>
+```
+
+## HLJS
+
+> Markdown component hljs feature
+
+```jsx
+<Markdown highlighter={MarkdownHighlighter.HLJS}>{MarkdownUnformattedCode}</Markdown>
+```
+
+## Prism
+
+> Markdown component prism feature
+
+```jsx
+<Markdown highlighter={MarkdownHighlighter.PRISM}>{MarkdownUnformattedCode}</Markdown>
+```

package/build/Legacy/Markdown/index.d.ts

@@ -0,0 +1,2 @@
+export { Markdown } from './Markdown';
+//# sourceMappingURL=index.d.ts.map

package/build/Legacy/Markdown/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/Legacy/Markdown/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA"}

package/build/Legacy/Markdown/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Markdown", {
+  enumerable: true,
+  get: function get() {
+    return _Markdown.Markdown;
+  }
+});
+var _Markdown = require("./Markdown");

package/build/Legacy/SyntaxHighlighter/SyntaxHighlighter.d.ts

@@ -0,0 +1,3 @@
+import { ISyntaxHighlighter } from './SyntaxHighlighter.type';
+export declare function SyntaxHighlighter({ highlighter, language, style, children, }: ISyntaxHighlighter): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SyntaxHighlighter.d.ts.map

package/build/Legacy/SyntaxHighlighter/SyntaxHighlighter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SyntaxHighlighter.d.ts","sourceRoot":"","sources":["../../../src/Legacy/SyntaxHighlighter/SyntaxHighlighter.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,kBAAkB,EAA0D,MAAM,0BAA0B,CAAA;AAIrH,wBAAgB,iBAAiB,CAAC,EAChC,WAAkD,EAClD,QAA4C,EAC5C,KAAsC,EACtC,QAAQ,GACT,EAAE,kBAAkB,2CAgBpB"}

package/build/Legacy/SyntaxHighlighter/SyntaxHighlighter.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SyntaxHighlighter = SyntaxHighlighter;
+var _SyntaxHighlighter = require("./SyntaxHighlighter.type");
+var _SyntaxHighlighterHLJS = require("./SyntaxHighlighterHLJS");
+var _SyntaxHighlighterPrism = require("./SyntaxHighlighterPrism");
+var _jsxRuntime = require("react/jsx-runtime");
+// https://github.com/react-syntax-highlighter/react-syntax-highlighter
+// https://github.com/react-syntax-highlighter/react-syntax-highlighter/blob/master/AVAILABLE_LANGUAGES_HLJS.MD
+// https://github.com/react-syntax-highlighter/react-syntax-highlighter/blob/master/AVAILABLE_STYLES_HLJS.MD
+// https://github.com/react-syntax-highlighter/react-syntax-highlighter/blob/master/AVAILABLE_LANGUAGES_PRISM.MD
+// https://github.com/react-syntax-highlighter/react-syntax-highlighter/blob/master/AVAILABLE_STYLES_PRISM.MD
+
+function SyntaxHighlighter(_ref) {
+  var _ref$highlighter = _ref.highlighter,
+    highlighter = _ref$highlighter === void 0 ? _SyntaxHighlighter.SyntaxHighlighterDefault.Highlighter : _ref$highlighter,
+    _ref$language = _ref.language,
+    language = _ref$language === void 0 ? _SyntaxHighlighter.SyntaxHighlighterDefault.Language : _ref$language,
+    _ref$style = _ref.style,
+    style = _ref$style === void 0 ? _SyntaxHighlighter.SyntaxHighlighterDefault.Style : _ref$style,
+    children = _ref.children;
+  if (highlighter == _SyntaxHighlighter.SyntaxHighlighterHighlighter.HLJS) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_SyntaxHighlighterHLJS.SyntaxHighlighterHLJS, {
+      language: language,
+      style: style,
+      children: children
+    });
+  }
+  if (highlighter == _SyntaxHighlighter.SyntaxHighlighterHighlighter.PRISM) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_SyntaxHighlighterPrism.SyntaxHighlighterPrism, {
+      language: language,
+      style: style,
+      children: children
+    });
+  }
+}

package/build/Legacy/SyntaxHighlighter/SyntaxHighlighter.type.d.ts

@@ -0,0 +1,32 @@
+export interface ISyntaxHighlighterHighlighter {
+    HLJS: string;
+    PRISM: string;
+}
+export declare const SyntaxHighlighterHighlighter: ISyntaxHighlighterHighlighter;
+export interface ISyntaxHighlighterLanguage {
+    TypeScript: string;
+    JavaScript: string;
+    Markdown: string;
+}
+export declare const SyntaxHighlighterLanguage: ISyntaxHighlighterLanguage;
+export interface ISyntaxHighlighterStyle {
+    Ocean: string;
+    Nord: string;
+}
+export declare const SyntaxHighlighterStyle: ISyntaxHighlighterStyle;
+export interface ISyntaxHighlighterDefault {
+    Highlighter?: string;
+    Language: string;
+    Style: string;
+    Children: string;
+}
+export declare const SyntaxHighlighterDefault: ISyntaxHighlighterDefault;
+export interface ISyntaxHighlighter extends ISyntaxHighlighterBase {
+    highlighter?: string;
+}
+export interface ISyntaxHighlighterBase {
+    language?: string;
+    style?: string;
+    children?: string;
+}
+//# sourceMappingURL=SyntaxHighlighter.type.d.ts.map

package/build/Legacy/SyntaxHighlighter/SyntaxHighlighter.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SyntaxHighlighter.type.d.ts","sourceRoot":"","sources":["../../../src/Legacy/SyntaxHighlighter/SyntaxHighlighter.type.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,6BAA6B;IAC5C,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd;AAED,eAAO,MAAM,4BAA4B,EAAE,6BAG1C,CAAA;AAED,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,eAAO,MAAM,yBAAyB,EAAE,0BAIvC,CAAA;AAED,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;CACb;AAED,eAAO,MAAM,sBAAsB,EAAE,uBAGpC,CAAA;AAED,MAAM,WAAW,yBAAyB;IACxC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,eAAO,MAAM,wBAAwB,EAAE,yBAKtC,CAAA;AAED,MAAM,WAAW,kBAAmB,SAAQ,sBAAsB;IAChE,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB"}

package/build/Legacy/SyntaxHighlighter/SyntaxHighlighter.type.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SyntaxHighlighterStyle = exports.SyntaxHighlighterLanguage = exports.SyntaxHighlighterHighlighter = exports.SyntaxHighlighterDefault = void 0;
+var SyntaxHighlighterHighlighter = exports.SyntaxHighlighterHighlighter = {
+  HLJS: 'HLJS',
+  PRISM: 'PRISM'
+};
+var SyntaxHighlighterLanguage = exports.SyntaxHighlighterLanguage = {
+  TypeScript: 'typescript',
+  JavaScript: 'javascript',
+  Markdown: 'markdown'
+};
+var SyntaxHighlighterStyle = exports.SyntaxHighlighterStyle = {
+  Ocean: 'ocean',
+  Nord: 'nord'
+};
+var SyntaxHighlighterDefault = exports.SyntaxHighlighterDefault = {
+  Highlighter: SyntaxHighlighterHighlighter.HLJS,
+  Language: SyntaxHighlighterLanguage.TypeScript,
+  Style: SyntaxHighlighterStyle.Ocean,
+  Children: ''
+};

package/build/Legacy/SyntaxHighlighter/SyntaxHighlighterHLJS.d.ts

@@ -0,0 +1,3 @@
+import { ISyntaxHighlighterBase } from './SyntaxHighlighter.type';
+export declare function SyntaxHighlighterHLJS({ language, style, children, }: ISyntaxHighlighterBase): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SyntaxHighlighterHLJS.d.ts.map

package/build/Legacy/SyntaxHighlighter/SyntaxHighlighterHLJS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SyntaxHighlighterHLJS.d.ts","sourceRoot":"","sources":["../../../src/Legacy/SyntaxHighlighter/SyntaxHighlighterHLJS.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,sBAAsB,EAAoD,MAAM,0BAA0B,CAAA;AAInH,wBAAgB,qBAAqB,CAAC,EACpC,QAA4C,EAC5C,KAAsC,EACtC,QAAQ,GACT,EAAE,sBAAsB,2CAYxB"}

package/build/Legacy/{PreformattedCode/PreformattedCodeHLJS.js → SyntaxHighlighter/SyntaxHighlighterHLJS.js}

@@ -4,23 +4,23 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.PreformattedCodeHLJS = PreformattedCodeHLJS;
+exports.SyntaxHighlighterHLJS = SyntaxHighlighterHLJS;
 var _reactSyntaxHighlighter = require("react-syntax-highlighter");
 var _typescript = _interopRequireDefault(require("react-syntax-highlighter/dist/esm/languages/hljs/typescript"));
 var _hljs = require("react-syntax-highlighter/dist/esm/styles/hljs");
-var _PreformattedCode = require("./PreformattedCode.type");
+var _SyntaxHighlighter = require("./SyntaxHighlighter.type");
 var _jsxRuntime = require("react/jsx-runtime");
 // https://github.com/react-syntax-highlighter/react-syntax-highlighter?tab=readme-ov-file#light-build
 
 _reactSyntaxHighlighter.Light.registerLanguage('typescript', _typescript["default"]);
-function PreformattedCodeHLJS(_ref) {
+function SyntaxHighlighterHLJS(_ref) {
   var _ref$language = _ref.language,
-    language = _ref$language === void 0 ? _PreformattedCode.PreformattedCodeDefault.Language : _ref$language,
+    language = _ref$language === void 0 ? _SyntaxHighlighter.SyntaxHighlighterDefault.Language : _ref$language,
     _ref$style = _ref.style,
-    style = _ref$style === void 0 ? _PreformattedCode.PreformattedCodeDefault.Style : _ref$style,
+    style = _ref$style === void 0 ? _SyntaxHighlighter.SyntaxHighlighterDefault.Style : _ref$style,
     children = _ref.children;
   var highlighterStyle;
-  if (style == _PreformattedCode.PreformattedCodeStyle.Ocean) {
+  if (style == _SyntaxHighlighter.SyntaxHighlighterStyle.Ocean) {
     highlighterStyle = _hljs.ocean;
   }
   return /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactSyntaxHighlighter.Light, {

package/build/Legacy/SyntaxHighlighter/SyntaxHighlighterPrism.d.ts

@@ -0,0 +1,3 @@
+import { ISyntaxHighlighterBase } from './SyntaxHighlighter.type';
+export declare function SyntaxHighlighterPrism({ language, style, children, }: ISyntaxHighlighterBase): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SyntaxHighlighterPrism.d.ts.map

package/build/Legacy/SyntaxHighlighter/SyntaxHighlighterPrism.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SyntaxHighlighterPrism.d.ts","sourceRoot":"","sources":["../../../src/Legacy/SyntaxHighlighter/SyntaxHighlighterPrism.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,sBAAsB,EAAoD,MAAM,0BAA0B,CAAA;AAKnH,wBAAgB,sBAAsB,CAAC,EACrC,QAA4C,EAC5C,KAAsC,EACtC,QAAQ,GACT,EAAE,sBAAsB,2CAWxB"}

package/build/Legacy/{PreformattedCode/PreformattedCodePrism.js → SyntaxHighlighter/SyntaxHighlighterPrism.js}

@@ -4,25 +4,25 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.PreformattedCodePrism = PreformattedCodePrism;
+exports.SyntaxHighlighterPrism = SyntaxHighlighterPrism;
 var _reactSyntaxHighlighter = require("react-syntax-highlighter");
 var _markdown = _interopRequireDefault(require("react-syntax-highlighter/dist/esm/languages/prism/markdown"));
 var _typescript = _interopRequireDefault(require("react-syntax-highlighter/dist/esm/languages/prism/typescript"));
 var _prism = require("react-syntax-highlighter/dist/esm/styles/prism");
-var _PreformattedCode = require("./PreformattedCode.type");
+var _SyntaxHighlighter = require("./SyntaxHighlighter.type");
 var _jsxRuntime = require("react/jsx-runtime");
 // https://github.com/react-syntax-highlighter/react-syntax-highlighter?tab=readme-ov-file#light-build
 
 _reactSyntaxHighlighter.PrismLight.registerLanguage('typescript', _typescript["default"]);
 _reactSyntaxHighlighter.PrismLight.registerLanguage('markdown', _markdown["default"]);
-function PreformattedCodePrism(_ref) {
+function SyntaxHighlighterPrism(_ref) {
   var _ref$language = _ref.language,
-    language = _ref$language === void 0 ? _PreformattedCode.PreformattedCodeDefault.Language : _ref$language,
+    language = _ref$language === void 0 ? _SyntaxHighlighter.SyntaxHighlighterDefault.Language : _ref$language,
     _ref$style = _ref.style,
-    style = _ref$style === void 0 ? _PreformattedCode.PreformattedCodeDefault.Style : _ref$style,
+    style = _ref$style === void 0 ? _SyntaxHighlighter.SyntaxHighlighterDefault.Style : _ref$style,
     children = _ref.children;
   var highlighterStyle;
-  if (style == _PreformattedCode.PreformattedCodeStyle.Nord) {
+  if (style == _SyntaxHighlighter.SyntaxHighlighterStyle.Nord) {
     highlighterStyle = _prism.nord;
   }
   return /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactSyntaxHighlighter.PrismLight, {

package/build/Legacy/SyntaxHighlighter/__tests__/SyntaxHighlighter.doc.md

@@ -0,0 +1,61 @@
+# SyntaxHighlighter
+
+> SyntaxHighlighter component all features
+
+```
+# Features
+
+> Default
+```
+
+## Default
+
+> Markdown component default feature
+
+```jsx
+<SyntaxHighlighter>{TypeScriptUnformattedCode}</SyntaxHighlighter>
+```
+
+## HLJS TypeScript
+
+> Markdown component hljs typescript feature
+
+```jsx
+<SyntaxHighlighter
+  highlighter={SyntaxHighlighterHighlighter.HLJS}
+  language={SyntaxHighlighterLanguage.TypeScript}
+  style={SyntaxHighlighterStyle.Ocean}
+>
+  {TypeScriptUnformattedCode}
+</SyntaxHighlighter>
+```
+
+## HLJS Markdown
+
+> Markdown component hljs markdown feature
+
+```jsx
+<Markdown highlighter={MarkdownHighlighter.HLJS}>{SyntaxHighlighterMarkdown}</Markdown>
+```
+
+## Prism TypeScript
+
+> Markdown component prism typescript feature
+
+```jsx
+<SyntaxHighlighter
+  highlighter={SyntaxHighlighterHighlighter.PRISM}
+  language={SyntaxHighlighterLanguage.TypeScript}
+  style={SyntaxHighlighterStyle.Nord}
+>
+  {TypeScriptUnformattedCode}
+</SyntaxHighlighter>
+```
+
+## Prism Markdown
+
+> Markdown component prism markdown feature
+
+```jsx
+<Markdown highlighter={MarkdownHighlighter.PRISM}>{SyntaxHighlighterMarkdown}</Markdown>
+```

package/build/Legacy/SyntaxHighlighter/index.d.ts

@@ -0,0 +1,3 @@
+export { SyntaxHighlighter } from './SyntaxHighlighter';
+export { SyntaxHighlighterHighlighter, SyntaxHighlighterLanguage, SyntaxHighlighterStyle } from './SyntaxHighlighter.type';
+//# sourceMappingURL=index.d.ts.map

package/build/Legacy/SyntaxHighlighter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/Legacy/SyntaxHighlighter/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AACvD,OAAO,EAAE,4BAA4B,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAA"}

package/build/Legacy/SyntaxHighlighter/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "SyntaxHighlighter", {
+  enumerable: true,
+  get: function get() {
+    return _SyntaxHighlighter.SyntaxHighlighter;
+  }
+});
+Object.defineProperty(exports, "SyntaxHighlighterHighlighter", {
+  enumerable: true,
+  get: function get() {
+    return _SyntaxHighlighter2.SyntaxHighlighterHighlighter;
+  }
+});
+Object.defineProperty(exports, "SyntaxHighlighterLanguage", {
+  enumerable: true,
+  get: function get() {
+    return _SyntaxHighlighter2.SyntaxHighlighterLanguage;
+  }
+});
+Object.defineProperty(exports, "SyntaxHighlighterStyle", {
+  enumerable: true,
+  get: function get() {
+    return _SyntaxHighlighter2.SyntaxHighlighterStyle;
+  }
+});
+var _SyntaxHighlighter = require("./SyntaxHighlighter");
+var _SyntaxHighlighter2 = require("./SyntaxHighlighter.type");

package/build/Legacy/index.d.ts

@@ -8,13 +8,13 @@ import { ErrorBoundary } from './ErrorBoundary';
 import { Icon } from './Icon';
 import { Label } from './Label';
 import { Loader } from './Loader';
-import { MarkdownDocs } from './MarkdownDocs';
+import { Markdown } from './Markdown';
 import { Popover } from './Popover';
-import { PreformattedCode } from './PreformattedCode';
 import { Progress } from './Progress';
 import { Select } from './Select';
 import { SelectMenu } from './SelectMenu';
 import { Subhead } from './Subhead';
+import { SyntaxHighlighter } from './SyntaxHighlighter';
 import { Toast } from './Toast';
 export type { IFlexGridItem } from './Grid';
 export declare const Legacy: {
@@ -719,7 +719,7 @@ export declare const Legacy: {
         Loader: typeof Loader;
         LoaderVariant: import("./Loader/Loader.type").ILoaderVariant;
     };
-    MarkdownDocs: typeof MarkdownDocs;
+    Markdown: typeof Markdown;
     Navigation: {
         Menu: typeof import("./Navigation/Menu").Menu;
         TabNav: typeof import("./Navigation/TabNav").TabNav;
@@ -737,7 +737,7 @@ export declare const Legacy: {
         PopoverVariant: import("./Popover/Popover.type").IPopoverVariant;
         PopoverSize: import("./Popover/Popover.type").IPopoverSize;
     };
-    PreformattedCode: typeof PreformattedCode;
+    SyntaxHighlighter: typeof SyntaxHighlighter;
     Progress: {
         Progress: typeof Progress;
         ProgressVariant: import("./Progress/Progress.type").IProgressVariant;

package/build/Legacy/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/Legacy/index.ts"],"names":[],"mappings":"AAAA,OAAO,2CAA2C,CAAA;AAClD,OAAO,EAAE,KAAK,EAAgB,MAAM,SAAS,CAAA;AAC7C,OAAO,EAAE,UAAU,EAAqB,MAAM,cAAc,CAAA;AAC5D,OAAO,EAAE,UAAU,EAAmB,MAAM,cAAc,CAAA;AAC1D,OAAO,EAAE,MAAM,EAAyF,MAAM,UAAU,CAAA;AACxH,OAAO,EAAE,QAAQ,EAAiB,MAAM,YAAY,CAAA;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAG/C,OAAO,EAAE,IAAI,EAAsB,MAAM,QAAQ,CAAA;AACjD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,MAAM,EAAiB,MAAM,UAAU,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAG7C,OAAO,EAAE,OAAO,EAA+B,MAAM,WAAW,CAAA;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,EAAE,QAAQ,EAAmB,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,MAAM,EAAe,MAAM,UAAU,CAAA;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,KAAK,EAAgB,MAAM,SAAS,CAAA;AAE7C,YAAY,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AAE3C,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8DlB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/Legacy/index.ts"],"names":[],"mappings":"AAAA,OAAO,2CAA2C,CAAA;AAClD,OAAO,EAAE,KAAK,EAAgB,MAAM,SAAS,CAAA;AAC7C,OAAO,EAAE,UAAU,EAAqB,MAAM,cAAc,CAAA;AAC5D,OAAO,EAAE,UAAU,EAAmB,MAAM,cAAc,CAAA;AAC1D,OAAO,EAAE,MAAM,EAAyF,MAAM,UAAU,CAAA;AACxH,OAAO,EAAE,QAAQ,EAAiB,MAAM,YAAY,CAAA;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAG/C,OAAO,EAAE,IAAI,EAAsB,MAAM,QAAQ,CAAA;AACjD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,MAAM,EAAiB,MAAM,UAAU,CAAA;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAGrC,OAAO,EAAE,OAAO,EAA+B,MAAM,WAAW,CAAA;AAChE,OAAO,EAAE,QAAQ,EAAmB,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,MAAM,EAAe,MAAM,UAAU,CAAA;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AACvD,OAAO,EAAE,KAAK,EAAgB,MAAM,SAAS,CAAA;AAE7C,YAAY,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AAE3C,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8DlB,CAAA"}

package/build/Legacy/index.js

@@ -16,15 +16,15 @@ var _Grid = require("./Grid");
 var _Icon = require("./Icon");
 var _Label = require("./Label");
 var _Loader = require("./Loader");
-var _MarkdownDocs = require("./MarkdownDocs");
+var _Markdown = require("./Markdown");
 var _Navigation = require("./Navigation");
 var _Pagination = require("./Pagination");
 var _Popover = require("./Popover");
-var _PreformattedCode = require("./PreformattedCode");
 var _Progress = require("./Progress");
 var _Select = require("./Select");
 var _SelectMenu = require("./SelectMenu");
 var _Subhead = require("./Subhead");
+var _SyntaxHighlighter = require("./SyntaxHighlighter");
 var _Toast = require("./Toast");
 var Legacy = exports.Legacy = {
   Alert: {
@@ -65,7 +65,7 @@ var Legacy = exports.Legacy = {
     Loader: _Loader.Loader,
     LoaderVariant: _Loader.LoaderVariant
   },
-  MarkdownDocs: _MarkdownDocs.MarkdownDocs,
+  Markdown: _Markdown.Markdown,
   Navigation: _Navigation.Navigation,
   Pagination: _Pagination.Pagination,
   Popover: {
@@ -73,7 +73,7 @@ var Legacy = exports.Legacy = {
     PopoverVariant: _Popover.PopoverVariant,
     PopoverSize: _Popover.PopoverSize
   },
-  PreformattedCode: _PreformattedCode.PreformattedCode,
+  SyntaxHighlighter: _SyntaxHighlighter.SyntaxHighlighter,
   Progress: {
     Progress: _Progress.Progress,
     ProgressVariant: _Progress.ProgressVariant

package/build/Modern/Flash/__tests__/Flash.doc.md

@@ -0,0 +1,12 @@
+# Flash
+
+> Flash component all features
+
+```
+# Featues
+
+> Default
+> Success, Danger, Warning, Full
+> WithIconAndAction, WithIconActionDismiss
+
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@papillonarts/components",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "description": "Papillon Arts Components",
   "homepage": "https://github.com/papillonarts/papillonarts/tree/master/packages/components",
   "repository": {
@@ -26,8 +26,8 @@
     "build-release": "npm run build"
   },
   "dependencies": {
-    "@papillonarts/css": "^0.34.0",
-    "@papillonarts/library": "^0.34.0"
+    "@papillonarts/css": "^0.35.0",
+    "@papillonarts/library": "^0.35.0"
   },
-  "gitHead": "1d84f25ec55009565a268dee39ca2d0ba1cecbbf"
+  "gitHead": "b773b8065ee684eab14f2bf1da2aebf9298fc76e"
 }

package/build/Legacy/MarkdownDocs/MarkdownDocs.d.ts

@@ -1,3 +0,0 @@
-import { IMarkdownDocs } from './MarkdownDocs.type';
-export declare function MarkdownDocs({ highlighter, children }: IMarkdownDocs): import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=MarkdownDocs.d.ts.map

package/build/Legacy/MarkdownDocs/MarkdownDocs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MarkdownDocs.d.ts","sourceRoot":"","sources":["../../../src/Legacy/MarkdownDocs/MarkdownDocs.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAgD,MAAM,qBAAqB,CAAA;AAEjG,wBAAgB,YAAY,CAAC,EAAE,WAA6C,EAAE,QAAQ,EAAE,EAAE,aAAa,2CAgDtG"}

package/build/Legacy/MarkdownDocs/MarkdownDocs.type.d.ts

@@ -1,15 +0,0 @@
-export interface IMarkdownDocsHighlighter {
-    HLJS: string;
-    PRISM: string;
-}
-export declare const MarkdownDocsHighlighter: IMarkdownDocsHighlighter;
-export interface IMarkdownDocsDefault {
-    Highlighter?: string;
-    Children: string;
-}
-export declare const MarkdownDocsDefault: IMarkdownDocsDefault;
-export interface IMarkdownDocs {
-    highlighter?: string;
-    children?: string;
-}
-//# sourceMappingURL=MarkdownDocs.type.d.ts.map

package/build/Legacy/MarkdownDocs/MarkdownDocs.type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MarkdownDocs.type.d.ts","sourceRoot":"","sources":["../../../src/Legacy/MarkdownDocs/MarkdownDocs.type.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd;AAED,eAAO,MAAM,uBAAuB,EAAE,wBAGrC,CAAA;AAED,MAAM,WAAW,oBAAoB;IACnC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,eAAO,MAAM,mBAAmB,EAAE,oBAGjC,CAAA;AAED,MAAM,WAAW,aAAa;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB"}

package/build/Legacy/MarkdownDocs/MarkdownDocs.type.js

@@ -1,14 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.MarkdownDocsHighlighter = exports.MarkdownDocsDefault = void 0;
-var MarkdownDocsHighlighter = exports.MarkdownDocsHighlighter = {
-  HLJS: 'HLJS',
-  PRISM: 'PRISM'
-};
-var MarkdownDocsDefault = exports.MarkdownDocsDefault = {
-  Highlighter: MarkdownDocsHighlighter.PRISM,
-  Children: ''
-};

package/build/Legacy/MarkdownDocs/__tests__/MarkdownDocs.markdown.docs.md

@@ -1,33 +0,0 @@
-# MarkdownDocs
-
-> MarkdownDocs component all features
-
-```
-# Features
-
-> Regular
-```
-
-## Regular
-
-> MarkdownDocs component regular feature
-
-```jsx
-<MarkdownDocs>{MarkdownDocsUnformattedCode}</MarkdownDocs>
-```
-
-## HLJS
-
-> MarkdownDocs component hljs feature
-
-```jsx
-<MarkdownDocs highlighter={MarkdownDocsHighlighter.HLJS}>{MarkdownUnformattedCode}</MarkdownDocs>
-```
-
-## Prism
-
-> MarkdownDocs component prism feature
-
-```jsx
-<MarkdownDocs highlighter={MarkdownDocsHighlighter.PRISM}>{MarkdownUnformattedCode}</MarkdownDocs>
-```

package/build/Legacy/MarkdownDocs/index.d.ts

@@ -1,2 +0,0 @@
-export { MarkdownDocs } from './MarkdownDocs';
-//# sourceMappingURL=index.d.ts.map

package/build/Legacy/MarkdownDocs/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/Legacy/MarkdownDocs/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA"}

package/build/Legacy/MarkdownDocs/index.js

@@ -1,12 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "MarkdownDocs", {
-  enumerable: true,
-  get: function get() {
-    return _MarkdownDocs.MarkdownDocs;
-  }
-});
-var _MarkdownDocs = require("./MarkdownDocs");

package/build/Legacy/PreformattedCode/PreformattedCode.d.ts

@@ -1,3 +0,0 @@
-import { IPreformattedCode } from './PreformattedCode.type';
-export declare function PreformattedCode({ highlighter, language, style, children, }: IPreformattedCode): import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=PreformattedCode.d.ts.map

package/build/Legacy/PreformattedCode/PreformattedCode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PreformattedCode.d.ts","sourceRoot":"","sources":["../../../src/Legacy/PreformattedCode/PreformattedCode.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,iBAAiB,EAAwD,MAAM,yBAAyB,CAAA;AAIjH,wBAAgB,gBAAgB,CAAC,EAC/B,WAAiD,EACjD,QAA2C,EAC3C,KAAqC,EACrC,QAAQ,GACT,EAAE,iBAAiB,2CAgBnB"}

package/build/Legacy/PreformattedCode/PreformattedCode.js

@@ -1,39 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.PreformattedCode = PreformattedCode;
-var _PreformattedCode = require("./PreformattedCode.type");
-var _PreformattedCodeHLJS = require("./PreformattedCodeHLJS");
-var _PreformattedCodePrism = require("./PreformattedCodePrism");
-var _jsxRuntime = require("react/jsx-runtime");
-// https://github.com/react-syntax-highlighter/react-syntax-highlighter
-// https://github.com/react-syntax-highlighter/react-syntax-highlighter/blob/master/AVAILABLE_LANGUAGES_HLJS.MD
-// https://github.com/react-syntax-highlighter/react-syntax-highlighter/blob/master/AVAILABLE_STYLES_HLJS.MD
-// https://github.com/react-syntax-highlighter/react-syntax-highlighter/blob/master/AVAILABLE_LANGUAGES_PRISM.MD
-// https://github.com/react-syntax-highlighter/react-syntax-highlighter/blob/master/AVAILABLE_STYLES_PRISM.MD
-
-function PreformattedCode(_ref) {
-  var _ref$highlighter = _ref.highlighter,
-    highlighter = _ref$highlighter === void 0 ? _PreformattedCode.PreformattedCodeDefault.Highlighter : _ref$highlighter,
-    _ref$language = _ref.language,
-    language = _ref$language === void 0 ? _PreformattedCode.PreformattedCodeDefault.Language : _ref$language,
-    _ref$style = _ref.style,
-    style = _ref$style === void 0 ? _PreformattedCode.PreformattedCodeDefault.Style : _ref$style,
-    children = _ref.children;
-  if (highlighter == _PreformattedCode.PreformattedCodeHighlighter.HLJS) {
-    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_PreformattedCodeHLJS.PreformattedCodeHLJS, {
-      language: language,
-      style: style,
-      children: children
-    });
-  }
-  if (highlighter == _PreformattedCode.PreformattedCodeHighlighter.PRISM) {
-    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_PreformattedCodePrism.PreformattedCodePrism, {
-      language: language,
-      style: style,
-      children: children
-    });
-  }
-}

package/build/Legacy/PreformattedCode/PreformattedCode.type.d.ts

@@ -1,32 +0,0 @@
-export interface IPreformattedCodeHighlighter {
-    HLJS: string;
-    PRISM: string;
-}
-export declare const PreformattedCodeHighlighter: IPreformattedCodeHighlighter;
-export interface IPreformattedCodeLanguage {
-    TypeScript: string;
-    JavaScript: string;
-    Markdown: string;
-}
-export declare const PreformattedCodeLanguage: IPreformattedCodeLanguage;
-export interface IPreformattedCodeStyle {
-    Ocean: string;
-    Nord: string;
-}
-export declare const PreformattedCodeStyle: IPreformattedCodeStyle;
-export interface IPreformattedCodeDefault {
-    Highlighter?: string;
-    Language: string;
-    Style: string;
-    Children: string;
-}
-export declare const PreformattedCodeDefault: IPreformattedCodeDefault;
-export interface IPreformattedCode extends IPreformattedCodeBase {
-    highlighter?: string;
-}
-export interface IPreformattedCodeBase {
-    language?: string;
-    style?: string;
-    children?: string;
-}
-//# sourceMappingURL=PreformattedCode.type.d.ts.map

package/build/Legacy/PreformattedCode/PreformattedCode.type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PreformattedCode.type.d.ts","sourceRoot":"","sources":["../../../src/Legacy/PreformattedCode/PreformattedCode.type.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,4BAA4B;IAC3C,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd;AAED,eAAO,MAAM,2BAA2B,EAAE,4BAGzC,CAAA;AAED,MAAM,WAAW,yBAAyB;IACxC,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,eAAO,MAAM,wBAAwB,EAAE,yBAItC,CAAA;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;CACb;AAED,eAAO,MAAM,qBAAqB,EAAE,sBAGnC,CAAA;AAED,MAAM,WAAW,wBAAwB;IACvC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,eAAO,MAAM,uBAAuB,EAAE,wBAKrC,CAAA;AAED,MAAM,WAAW,iBAAkB,SAAQ,qBAAqB;IAC9D,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB"}

package/build/Legacy/PreformattedCode/PreformattedCode.type.js

@@ -1,25 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.PreformattedCodeStyle = exports.PreformattedCodeLanguage = exports.PreformattedCodeHighlighter = exports.PreformattedCodeDefault = void 0;
-var PreformattedCodeHighlighter = exports.PreformattedCodeHighlighter = {
-  HLJS: 'HLJS',
-  PRISM: 'PRISM'
-};
-var PreformattedCodeLanguage = exports.PreformattedCodeLanguage = {
-  TypeScript: 'typescript',
-  JavaScript: 'javascript',
-  Markdown: 'markdown'
-};
-var PreformattedCodeStyle = exports.PreformattedCodeStyle = {
-  Ocean: 'ocean',
-  Nord: 'nord'
-};
-var PreformattedCodeDefault = exports.PreformattedCodeDefault = {
-  Highlighter: PreformattedCodeHighlighter.HLJS,
-  Language: PreformattedCodeLanguage.TypeScript,
-  Style: PreformattedCodeStyle.Ocean,
-  Children: ''
-};

package/build/Legacy/PreformattedCode/PreformattedCodeHLJS.d.ts

@@ -1,3 +0,0 @@
-import { IPreformattedCodeBase } from './PreformattedCode.type';
-export declare function PreformattedCodeHLJS({ language, style, children, }: IPreformattedCodeBase): import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=PreformattedCodeHLJS.d.ts.map

package/build/Legacy/PreformattedCode/PreformattedCodeHLJS.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PreformattedCodeHLJS.d.ts","sourceRoot":"","sources":["../../../src/Legacy/PreformattedCode/PreformattedCodeHLJS.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,qBAAqB,EAAkD,MAAM,yBAAyB,CAAA;AAI/G,wBAAgB,oBAAoB,CAAC,EACnC,QAA2C,EAC3C,KAAqC,EACrC,QAAQ,GACT,EAAE,qBAAqB,2CAYvB"}

package/build/Legacy/PreformattedCode/PreformattedCodePrism.d.ts

@@ -1,3 +0,0 @@
-import { IPreformattedCodeBase } from './PreformattedCode.type';
-export declare function PreformattedCodePrism({ language, style, children, }: IPreformattedCodeBase): import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=PreformattedCodePrism.d.ts.map

package/build/Legacy/PreformattedCode/PreformattedCodePrism.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PreformattedCodePrism.d.ts","sourceRoot":"","sources":["../../../src/Legacy/PreformattedCode/PreformattedCodePrism.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,qBAAqB,EAAkD,MAAM,yBAAyB,CAAA;AAK/G,wBAAgB,qBAAqB,CAAC,EACpC,QAA2C,EAC3C,KAAqC,EACrC,QAAQ,GACT,EAAE,qBAAqB,2CAWvB"}

package/build/Legacy/PreformattedCode/__tests__/PreformattedCode.markdown.docs.md

@@ -1,61 +0,0 @@
-# PreformattedCode
-
-> PreformattedCode component all features
-
-```
-# Features
-
-> Regular
-```
-
-## Regular
-
-> MarkdownDocs component regular feature
-
-```jsx
-<PreformattedCode>{TypeScriptUnformattedCode}</PreformattedCode>
-```
-
-## HLJS TypeScript
-
-> MarkdownDocs component hljs typescript feature
-
-```jsx
-<PreformattedCode
-  highlighter={PreformattedCodeHighlighter.HLJS}
-  language={PreformattedCodeLanguage.TypeScript}
-  style={PreformattedCodeStyle.Ocean}
->
-  {TypeScriptUnformattedCode}
-</PreformattedCode>
-```
-
-## HLJS Markdown
-
-> MarkdownDocs component hljs markdown feature
-
-```jsx
-<MarkdownDocs highlighter={MarkdownDocsHighlighter.HLJS}>{PreformattedCodeMarkdownDocs}</MarkdownDocs>
-```
-
-## Prism TypeScript
-
-> MarkdownDocs component prism typescript feature
-
-```jsx
-<PreformattedCode
-  highlighter={PreformattedCodeHighlighter.PRISM}
-  language={PreformattedCodeLanguage.TypeScript}
-  style={PreformattedCodeStyle.Nord}
->
-  {TypeScriptUnformattedCode}
-</PreformattedCode>
-```
-
-## Prism Markdown
-
-> MarkdownDocs component prism markdown feature
-
-```jsx
-<MarkdownDocs highlighter={MarkdownDocsHighlighter.PRISM}>{PreformattedCodeMarkdownDocs}</MarkdownDocs>
-```

package/build/Legacy/PreformattedCode/index.d.ts

@@ -1,3 +0,0 @@
-export { PreformattedCode } from './PreformattedCode';
-export { PreformattedCodeHighlighter, PreformattedCodeLanguage, PreformattedCodeStyle } from './PreformattedCode.type';
-//# sourceMappingURL=index.d.ts.map

package/build/Legacy/PreformattedCode/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/Legacy/PreformattedCode/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,EAAE,2BAA2B,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAA"}

package/build/Legacy/PreformattedCode/index.js

@@ -1,31 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "PreformattedCode", {
-  enumerable: true,
-  get: function get() {
-    return _PreformattedCode.PreformattedCode;
-  }
-});
-Object.defineProperty(exports, "PreformattedCodeHighlighter", {
-  enumerable: true,
-  get: function get() {
-    return _PreformattedCode2.PreformattedCodeHighlighter;
-  }
-});
-Object.defineProperty(exports, "PreformattedCodeLanguage", {
-  enumerable: true,
-  get: function get() {
-    return _PreformattedCode2.PreformattedCodeLanguage;
-  }
-});
-Object.defineProperty(exports, "PreformattedCodeStyle", {
-  enumerable: true,
-  get: function get() {
-    return _PreformattedCode2.PreformattedCodeStyle;
-  }
-});
-var _PreformattedCode = require("./PreformattedCode");
-var _PreformattedCode2 = require("./PreformattedCode.type");