mirror of
https://github.com/Funkoala14/knowledgebase_law.git
synced 2025-06-09 05:58:15 +08:00
391 lines
16 KiB
JavaScript
391 lines
16 KiB
JavaScript
"use strict";
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = _default;
|
|
var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
|
|
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
|
|
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
|
|
var _react = _interopRequireDefault(require("react"));
|
|
var _createElement = _interopRequireDefault(require("./create-element"));
|
|
var _checkForListedLanguage = _interopRequireDefault(require("./checkForListedLanguage"));
|
|
var _excluded = ["language", "children", "style", "customStyle", "codeTagProps", "useInlineStyles", "showLineNumbers", "showInlineLineNumbers", "startingLineNumber", "lineNumberContainerStyle", "lineNumberStyle", "wrapLines", "wrapLongLines", "lineProps", "renderer", "PreTag", "CodeTag", "code", "astGenerator"];
|
|
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
|
|
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
|
|
var newLineRegex = /\n/g;
|
|
function getNewLines(str) {
|
|
return str.match(newLineRegex);
|
|
}
|
|
function getAllLineNumbers(_ref) {
|
|
var lines = _ref.lines,
|
|
startingLineNumber = _ref.startingLineNumber,
|
|
style = _ref.style;
|
|
return lines.map(function (_, i) {
|
|
var number = i + startingLineNumber;
|
|
return /*#__PURE__*/_react["default"].createElement("span", {
|
|
key: "line-".concat(i),
|
|
className: "react-syntax-highlighter-line-number",
|
|
style: typeof style === 'function' ? style(number) : style
|
|
}, "".concat(number, "\n"));
|
|
});
|
|
}
|
|
function AllLineNumbers(_ref2) {
|
|
var codeString = _ref2.codeString,
|
|
codeStyle = _ref2.codeStyle,
|
|
_ref2$containerStyle = _ref2.containerStyle,
|
|
containerStyle = _ref2$containerStyle === void 0 ? {
|
|
"float": 'left',
|
|
paddingRight: '10px'
|
|
} : _ref2$containerStyle,
|
|
_ref2$numberStyle = _ref2.numberStyle,
|
|
numberStyle = _ref2$numberStyle === void 0 ? {} : _ref2$numberStyle,
|
|
startingLineNumber = _ref2.startingLineNumber;
|
|
return /*#__PURE__*/_react["default"].createElement("code", {
|
|
style: Object.assign({}, codeStyle, containerStyle)
|
|
}, getAllLineNumbers({
|
|
lines: codeString.replace(/\n$/, '').split('\n'),
|
|
style: numberStyle,
|
|
startingLineNumber: startingLineNumber
|
|
}));
|
|
}
|
|
function getEmWidthOfNumber(num) {
|
|
return "".concat(num.toString().length, ".25em");
|
|
}
|
|
function getInlineLineNumber(lineNumber, inlineLineNumberStyle) {
|
|
return {
|
|
type: 'element',
|
|
tagName: 'span',
|
|
properties: {
|
|
key: "line-number--".concat(lineNumber),
|
|
className: ['comment', 'linenumber', 'react-syntax-highlighter-line-number'],
|
|
style: inlineLineNumberStyle
|
|
},
|
|
children: [{
|
|
type: 'text',
|
|
value: lineNumber
|
|
}]
|
|
};
|
|
}
|
|
function assembleLineNumberStyles(lineNumberStyle, lineNumber, largestLineNumber) {
|
|
// minimally necessary styling for line numbers
|
|
var defaultLineNumberStyle = {
|
|
display: 'inline-block',
|
|
minWidth: getEmWidthOfNumber(largestLineNumber),
|
|
paddingRight: '1em',
|
|
textAlign: 'right',
|
|
userSelect: 'none'
|
|
};
|
|
// prep custom styling
|
|
var customLineNumberStyle = typeof lineNumberStyle === 'function' ? lineNumberStyle(lineNumber) : lineNumberStyle;
|
|
// combine
|
|
var assembledStyle = _objectSpread(_objectSpread({}, defaultLineNumberStyle), customLineNumberStyle);
|
|
return assembledStyle;
|
|
}
|
|
function createLineElement(_ref3) {
|
|
var children = _ref3.children,
|
|
lineNumber = _ref3.lineNumber,
|
|
lineNumberStyle = _ref3.lineNumberStyle,
|
|
largestLineNumber = _ref3.largestLineNumber,
|
|
showInlineLineNumbers = _ref3.showInlineLineNumbers,
|
|
_ref3$lineProps = _ref3.lineProps,
|
|
lineProps = _ref3$lineProps === void 0 ? {} : _ref3$lineProps,
|
|
_ref3$className = _ref3.className,
|
|
className = _ref3$className === void 0 ? [] : _ref3$className,
|
|
showLineNumbers = _ref3.showLineNumbers,
|
|
wrapLongLines = _ref3.wrapLongLines,
|
|
_ref3$wrapLines = _ref3.wrapLines,
|
|
wrapLines = _ref3$wrapLines === void 0 ? false : _ref3$wrapLines;
|
|
var properties = wrapLines ? _objectSpread({}, typeof lineProps === 'function' ? lineProps(lineNumber) : lineProps) : {};
|
|
properties['className'] = properties['className'] ? [].concat((0, _toConsumableArray2["default"])(properties['className'].trim().split(/\s+/)), (0, _toConsumableArray2["default"])(className)) : className;
|
|
if (lineNumber && showInlineLineNumbers) {
|
|
var inlineLineNumberStyle = assembleLineNumberStyles(lineNumberStyle, lineNumber, largestLineNumber);
|
|
children.unshift(getInlineLineNumber(lineNumber, inlineLineNumberStyle));
|
|
}
|
|
if (wrapLongLines & showLineNumbers) {
|
|
properties.style = _objectSpread({
|
|
display: 'flex'
|
|
}, properties.style);
|
|
}
|
|
return {
|
|
type: 'element',
|
|
tagName: 'span',
|
|
properties: properties,
|
|
children: children
|
|
};
|
|
}
|
|
function flattenCodeTree(tree) {
|
|
var className = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
|
|
var newTree = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
|
|
for (var i = 0; i < tree.length; i++) {
|
|
var node = tree[i];
|
|
if (node.type === 'text') {
|
|
newTree.push(createLineElement({
|
|
children: [node],
|
|
className: (0, _toConsumableArray2["default"])(new Set(className))
|
|
}));
|
|
} else if (node.children) {
|
|
var classNames = className.concat(node.properties.className);
|
|
flattenCodeTree(node.children, classNames).forEach(function (i) {
|
|
return newTree.push(i);
|
|
});
|
|
}
|
|
}
|
|
return newTree;
|
|
}
|
|
function processLines(codeTree, wrapLines, lineProps, showLineNumbers, showInlineLineNumbers, startingLineNumber, largestLineNumber, lineNumberStyle, wrapLongLines) {
|
|
var _ref4;
|
|
var tree = flattenCodeTree(codeTree.value);
|
|
var newTree = [];
|
|
var lastLineBreakIndex = -1;
|
|
var index = 0;
|
|
function createWrappedLine(children, lineNumber) {
|
|
var className = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
|
|
return createLineElement({
|
|
children: children,
|
|
lineNumber: lineNumber,
|
|
lineNumberStyle: lineNumberStyle,
|
|
largestLineNumber: largestLineNumber,
|
|
showInlineLineNumbers: showInlineLineNumbers,
|
|
lineProps: lineProps,
|
|
className: className,
|
|
showLineNumbers: showLineNumbers,
|
|
wrapLongLines: wrapLongLines,
|
|
wrapLines: wrapLines
|
|
});
|
|
}
|
|
function createUnwrappedLine(children, lineNumber) {
|
|
if (showLineNumbers && lineNumber && showInlineLineNumbers) {
|
|
var inlineLineNumberStyle = assembleLineNumberStyles(lineNumberStyle, lineNumber, largestLineNumber);
|
|
children.unshift(getInlineLineNumber(lineNumber, inlineLineNumberStyle));
|
|
}
|
|
return children;
|
|
}
|
|
function createLine(children, lineNumber) {
|
|
var className = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
|
|
return wrapLines || className.length > 0 ? createWrappedLine(children, lineNumber, className) : createUnwrappedLine(children, lineNumber);
|
|
}
|
|
var _loop = function _loop() {
|
|
var node = tree[index];
|
|
var value = node.children[0].value;
|
|
var newLines = getNewLines(value);
|
|
if (newLines) {
|
|
var splitValue = value.split('\n');
|
|
splitValue.forEach(function (text, i) {
|
|
var lineNumber = showLineNumbers && newTree.length + startingLineNumber;
|
|
var newChild = {
|
|
type: 'text',
|
|
value: "".concat(text, "\n")
|
|
};
|
|
|
|
// if it's the first line
|
|
if (i === 0) {
|
|
var _children = tree.slice(lastLineBreakIndex + 1, index).concat(createLineElement({
|
|
children: [newChild],
|
|
className: node.properties.className
|
|
}));
|
|
var _line = createLine(_children, lineNumber);
|
|
newTree.push(_line);
|
|
|
|
// if it's the last line
|
|
} else if (i === splitValue.length - 1) {
|
|
var stringChild = tree[index + 1] && tree[index + 1].children && tree[index + 1].children[0];
|
|
var lastLineInPreviousSpan = {
|
|
type: 'text',
|
|
value: "".concat(text)
|
|
};
|
|
if (stringChild) {
|
|
var newElem = createLineElement({
|
|
children: [lastLineInPreviousSpan],
|
|
className: node.properties.className
|
|
});
|
|
tree.splice(index + 1, 0, newElem);
|
|
} else {
|
|
var _children2 = [lastLineInPreviousSpan];
|
|
var _line2 = createLine(_children2, lineNumber, node.properties.className);
|
|
newTree.push(_line2);
|
|
}
|
|
|
|
// if it's neither the first nor the last line
|
|
} else {
|
|
var _children3 = [newChild];
|
|
var _line3 = createLine(_children3, lineNumber, node.properties.className);
|
|
newTree.push(_line3);
|
|
}
|
|
});
|
|
lastLineBreakIndex = index;
|
|
}
|
|
index++;
|
|
};
|
|
while (index < tree.length) {
|
|
_loop();
|
|
}
|
|
if (lastLineBreakIndex !== tree.length - 1) {
|
|
var children = tree.slice(lastLineBreakIndex + 1, tree.length);
|
|
if (children && children.length) {
|
|
var lineNumber = showLineNumbers && newTree.length + startingLineNumber;
|
|
var line = createLine(children, lineNumber);
|
|
newTree.push(line);
|
|
}
|
|
}
|
|
return wrapLines ? newTree : (_ref4 = []).concat.apply(_ref4, newTree);
|
|
}
|
|
function defaultRenderer(_ref5) {
|
|
var rows = _ref5.rows,
|
|
stylesheet = _ref5.stylesheet,
|
|
useInlineStyles = _ref5.useInlineStyles;
|
|
return rows.map(function (node, i) {
|
|
return (0, _createElement["default"])({
|
|
node: node,
|
|
stylesheet: stylesheet,
|
|
useInlineStyles: useInlineStyles,
|
|
key: "code-segement".concat(i)
|
|
});
|
|
});
|
|
}
|
|
|
|
// only highlight.js has the highlightAuto method
|
|
function isHighlightJs(astGenerator) {
|
|
return astGenerator && typeof astGenerator.highlightAuto !== 'undefined';
|
|
}
|
|
function getCodeTree(_ref6) {
|
|
var astGenerator = _ref6.astGenerator,
|
|
language = _ref6.language,
|
|
code = _ref6.code,
|
|
defaultCodeValue = _ref6.defaultCodeValue;
|
|
// figure out whether we're using lowlight/highlight or refractor/prism
|
|
// then attempt highlighting accordingly
|
|
|
|
// lowlight/highlight?
|
|
if (isHighlightJs(astGenerator)) {
|
|
var hasLanguage = (0, _checkForListedLanguage["default"])(astGenerator, language);
|
|
if (language === 'text') {
|
|
return {
|
|
value: defaultCodeValue,
|
|
language: 'text'
|
|
};
|
|
} else if (hasLanguage) {
|
|
return astGenerator.highlight(language, code);
|
|
} else {
|
|
return astGenerator.highlightAuto(code);
|
|
}
|
|
}
|
|
|
|
// must be refractor/prism, then
|
|
try {
|
|
return language && language !== 'text' ? {
|
|
value: astGenerator.highlight(code, language)
|
|
} : {
|
|
value: defaultCodeValue
|
|
};
|
|
} catch (e) {
|
|
return {
|
|
value: defaultCodeValue
|
|
};
|
|
}
|
|
}
|
|
function _default(defaultAstGenerator, defaultStyle) {
|
|
return function SyntaxHighlighter(_ref7) {
|
|
var language = _ref7.language,
|
|
children = _ref7.children,
|
|
_ref7$style = _ref7.style,
|
|
style = _ref7$style === void 0 ? defaultStyle : _ref7$style,
|
|
_ref7$customStyle = _ref7.customStyle,
|
|
customStyle = _ref7$customStyle === void 0 ? {} : _ref7$customStyle,
|
|
_ref7$codeTagProps = _ref7.codeTagProps,
|
|
codeTagProps = _ref7$codeTagProps === void 0 ? {
|
|
className: language ? "language-".concat(language) : undefined,
|
|
style: _objectSpread(_objectSpread({}, style['code[class*="language-"]']), style["code[class*=\"language-".concat(language, "\"]")])
|
|
} : _ref7$codeTagProps,
|
|
_ref7$useInlineStyles = _ref7.useInlineStyles,
|
|
useInlineStyles = _ref7$useInlineStyles === void 0 ? true : _ref7$useInlineStyles,
|
|
_ref7$showLineNumbers = _ref7.showLineNumbers,
|
|
showLineNumbers = _ref7$showLineNumbers === void 0 ? false : _ref7$showLineNumbers,
|
|
_ref7$showInlineLineN = _ref7.showInlineLineNumbers,
|
|
showInlineLineNumbers = _ref7$showInlineLineN === void 0 ? true : _ref7$showInlineLineN,
|
|
_ref7$startingLineNum = _ref7.startingLineNumber,
|
|
startingLineNumber = _ref7$startingLineNum === void 0 ? 1 : _ref7$startingLineNum,
|
|
lineNumberContainerStyle = _ref7.lineNumberContainerStyle,
|
|
_ref7$lineNumberStyle = _ref7.lineNumberStyle,
|
|
lineNumberStyle = _ref7$lineNumberStyle === void 0 ? {} : _ref7$lineNumberStyle,
|
|
wrapLines = _ref7.wrapLines,
|
|
_ref7$wrapLongLines = _ref7.wrapLongLines,
|
|
wrapLongLines = _ref7$wrapLongLines === void 0 ? false : _ref7$wrapLongLines,
|
|
_ref7$lineProps = _ref7.lineProps,
|
|
lineProps = _ref7$lineProps === void 0 ? {} : _ref7$lineProps,
|
|
renderer = _ref7.renderer,
|
|
_ref7$PreTag = _ref7.PreTag,
|
|
PreTag = _ref7$PreTag === void 0 ? 'pre' : _ref7$PreTag,
|
|
_ref7$CodeTag = _ref7.CodeTag,
|
|
CodeTag = _ref7$CodeTag === void 0 ? 'code' : _ref7$CodeTag,
|
|
_ref7$code = _ref7.code,
|
|
code = _ref7$code === void 0 ? (Array.isArray(children) ? children[0] : children) || '' : _ref7$code,
|
|
astGenerator = _ref7.astGenerator,
|
|
rest = (0, _objectWithoutProperties2["default"])(_ref7, _excluded);
|
|
astGenerator = astGenerator || defaultAstGenerator;
|
|
var allLineNumbers = showLineNumbers ? /*#__PURE__*/_react["default"].createElement(AllLineNumbers, {
|
|
containerStyle: lineNumberContainerStyle,
|
|
codeStyle: codeTagProps.style || {},
|
|
numberStyle: lineNumberStyle,
|
|
startingLineNumber: startingLineNumber,
|
|
codeString: code
|
|
}) : null;
|
|
var defaultPreStyle = style.hljs || style['pre[class*="language-"]'] || {
|
|
backgroundColor: '#fff'
|
|
};
|
|
var generatorClassName = isHighlightJs(astGenerator) ? 'hljs' : 'prismjs';
|
|
var preProps = useInlineStyles ? Object.assign({}, rest, {
|
|
style: Object.assign({}, defaultPreStyle, customStyle)
|
|
}) : Object.assign({}, rest, {
|
|
className: rest.className ? "".concat(generatorClassName, " ").concat(rest.className) : generatorClassName,
|
|
style: Object.assign({}, customStyle)
|
|
});
|
|
if (wrapLongLines) {
|
|
codeTagProps.style = _objectSpread({
|
|
whiteSpace: 'pre-wrap'
|
|
}, codeTagProps.style);
|
|
} else {
|
|
codeTagProps.style = _objectSpread({
|
|
whiteSpace: 'pre'
|
|
}, codeTagProps.style);
|
|
}
|
|
if (!astGenerator) {
|
|
return /*#__PURE__*/_react["default"].createElement(PreTag, preProps, allLineNumbers, /*#__PURE__*/_react["default"].createElement(CodeTag, codeTagProps, code));
|
|
}
|
|
|
|
/*
|
|
* Some custom renderers rely on individual row elements so we need to turn wrapLines on
|
|
* if renderer is provided and wrapLines is undefined.
|
|
*/
|
|
if (wrapLines === undefined && renderer || wrapLongLines) wrapLines = true;
|
|
renderer = renderer || defaultRenderer;
|
|
var defaultCodeValue = [{
|
|
type: 'text',
|
|
value: code
|
|
}];
|
|
var codeTree = getCodeTree({
|
|
astGenerator: astGenerator,
|
|
language: language,
|
|
code: code,
|
|
defaultCodeValue: defaultCodeValue
|
|
});
|
|
if (codeTree.language === null) {
|
|
codeTree.value = defaultCodeValue;
|
|
}
|
|
|
|
// determine largest line number so that we can force minWidth on all linenumber elements
|
|
var lineCount = codeTree.value.length;
|
|
if (lineCount === 1 && codeTree.value[0].type === 'text') {
|
|
// Since codeTree for an unparsable text (e.g. 'a\na\na') is [{ type: 'text', value: 'a\na\na' }]
|
|
lineCount = codeTree.value[0].value.split('\n').length;
|
|
}
|
|
var largestLineNumber = lineCount + startingLineNumber;
|
|
var rows = processLines(codeTree, wrapLines, lineProps, showLineNumbers, showInlineLineNumbers, startingLineNumber, largestLineNumber, lineNumberStyle, wrapLongLines);
|
|
return /*#__PURE__*/_react["default"].createElement(PreTag, preProps, /*#__PURE__*/_react["default"].createElement(CodeTag, codeTagProps, !showInlineLineNumbers && allLineNumbers, renderer({
|
|
rows: rows,
|
|
stylesheet: style,
|
|
useInlineStyles: useInlineStyles
|
|
})));
|
|
};
|
|
} |