LogalDeveloper/owncast
0
Fork 0
Code Activity

These files should not be added

Browse Source
This commit is contained in:
Gabe Kangas
2020-10-19 22:22:33 -07:00
parent 226242f07b
commit 205ef8926e
6368 changed files with 0 additions and 603959 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
build/javascript/node_modules/postcss-inline-svg/lib/defaults.js generated vendored
View File

@@ -1,36 +0,0 @@
function encode(code) {
return code
.replace(/%/g, "%25")
.replace(/</g, "%3C")
.replace(/>/g, "%3E")
.replace(/&/g, "%26")
.replace(/#/g, "%23")
.replace(/{/g, "%7B")
.replace(/}/g, "%7D");
}
function addXmlns(code) {
if (code.indexOf("xmlns") === -1) {
return code.replace(/<svg/g, '<svg xmlns="http://www.w3.org/2000/svg"');
} else {
return code;
}
}
function normalize(code) {
return code
.replace(/'/g, "%22")
.replace(/"/g, "'")
.replace(/\s+/g, " ")
.trim();
}
function transform(code) {
return `"data:image/svg+xml;charset=utf-8,${normalize(code)}"`;
}
module.exports = {
encode,
addXmlns,
transform
};

128
build/javascript/node_modules/postcss-inline-svg/lib/index.js generated vendored
View File

@@ -1,128 +0,0 @@
const postcss = require("postcss");
const { parseRuleDefinition, getRuleParams } = require("./parseRule.js");
const parseDeclValue = require("./parseDeclValue.js");
const resolveId = require("./resolveId.js");
const load = require("./load.js");
function removeLoader(loader) {
if (!loader.error && loader.node.type === "atrule") {
loader.node.remove();
}
}
function applyInliner(inliner) {
if (!inliner.loader.error) {
inliner.valueNode.value = "url";
inliner.valueNode.nodes = [
{
type: "word",
value: inliner.loader.svg
}
];
}
}
function stringifyInliner(inliner) {
if (!inliner.loader.error) {
inliner.node.value = String(inliner.parsedValue);
}
}
module.exports = postcss.plugin(
"postcss-inline-svg",
(opts = {}) => (css, result) => {
const loadersMap = {};
const loaders = [];
const inliners = [];
css.walk(node => {
if (node.type === "atrule") {
if (node.name === "svg-load") {
try {
const file =
node.source && node.source.input && node.source.input.file;
const { name, url } = parseRuleDefinition(node.params);
const { params, selectors } = getRuleParams(node);
const loader = {
id: resolveId(file, url, opts),
parent: file,
params,
selectors,
node
};
loaders.push(loader);
loadersMap[name] = loader;
} catch (e) {
node.warn(result, e.message);
}
}
} else if (node.type === "decl") {
if (
node.value.indexOf("svg-load(") !== -1 ||
node.value.indexOf("svg-inline(") !== -1
) {
try {
const file =
node.source && node.source.input && node.source.input.file;
const statements = parseDeclValue(node.value);
statements.loaders.forEach(
({ url, params, valueNode, parsedValue }) => {
const loader = {
id: resolveId(file, url, opts),
parent: file,
params,
selectors: {},
node
};
loaders.push(loader);
inliners.push({
loader,
node,
valueNode,
parsedValue
});
}
);
statements.inliners.forEach(({ name, valueNode, parsedValue }) => {
const loader = loadersMap[name];
if (loader) {
inliners.push({
loader,
node,
valueNode,
parsedValue
});
} else {
node.warn(result, `"${name}" svg is not defined`);
}
});
} catch (e) {
node.warn(result, e.message);
}
}
}
});
const promises = loaders.map(loader => {
return load(loader.id, loader.params, loader.selectors, opts)
.then(code => {
loader.svg = code;
result.messages.push({
type: "dependency",
file: loader.id,
parent: loader.parent
});
})
.catch(err => {
loader.error = true;
loader.node.warn(result, err.message);
});
});
return Promise.all(promises).then(() => {
loaders.forEach(removeLoader);
inliners.forEach(applyInliner);
inliners.forEach(stringifyInliner);
});
}
);

47
build/javascript/node_modules/postcss-inline-svg/lib/load.js generated vendored
View File

@@ -1,47 +0,0 @@
const { readFile } = require("fs");
const render = require("./render.js");
const { transform, encode, addXmlns } = require("./defaults.js");
const {
removeFill,
removeStroke,
applyRootParams,
applySelectedParams
} = require("./processors.js");
function read(id) {
return new Promise((resolve, reject) => {
readFile(id, "utf-8", (err, data) => {
if (err) {
reject(Error(`Can't load '${id}'`));
} else {
resolve(data);
}
});
});
}
module.exports = function load(id, params, selectors, opts) {
const processors = [
removeFill(id, opts),
removeStroke(id,opts),
applyRootParams(params),
applySelectedParams(selectors)
];
return read(id).then(data => {
let code = render(data, ...processors);
if (opts.xmlns !== false) {
code = addXmlns(code);
}
if (opts.encode !== false) {
code = (opts.encode || encode)(code);
}
if (opts.transform !== false) {
code = (opts.transform || transform)(code, id);
}
return code;
});
};

140
build/javascript/node_modules/postcss-inline-svg/lib/parseDeclValue.js generated vendored
View File

@@ -1,140 +0,0 @@
const valueParser = require("postcss-value-parser");
const { stringify } = valueParser;
function getUrl(nodes) {
let url = "";
let urlEnd = 0;
for (let i = 0; i < nodes.length; i += 1) {
const node = nodes[i];
if (node.type === "string") {
if (i !== 0) {
throw Error(`Invalid "svg-load(${stringify(nodes)})" definition`);
}
url = node.value;
urlEnd = i + 1;
break;
}
if (node.type === "div" && node.value === ",") {
if (i === 0) {
throw Error(`Invalid "svg-load(${stringify(nodes)})" definition`);
}
urlEnd = i;
break;
}
url += stringify(node);
urlEnd += 1;
}
return {
url,
urlEnd
};
}
function getParamChunks(nodes) {
const list = [];
const lastArg = nodes.reduce((arg, node) => {
if (node.type === "word" || node.type === "string") {
return arg + node.value;
}
if (node.type === "space") {
return arg + " ";
}
if (node.type === "div" && node.value === ",") {
list.push(arg);
return "";
}
return arg + stringify(node);
}, "");
return list.concat(lastArg);
}
function splitParams(list) {
const params = {};
list.reduce((sep, arg) => {
if (!arg) {
throw Error(`Expected parameter`);
}
if (!sep) {
if (arg.indexOf(":") !== -1) {
sep = ":";
} else if (arg.indexOf("=") !== -1) {
sep = "=";
} else {
throw Error(`Expected ":" or "=" separator in "${arg}"`);
}
}
const pair = arg.split(sep);
if (pair.length !== 2) {
throw Error(`Expected "${sep}" separator in "${arg}"`);
}
params[pair[0].trim()] = pair[1].trim();
return sep;
}, null);
return params;
}
function getLoader(parsedValue, valueNode) {
if (!valueNode.nodes.length) {
throw Error(`Invalid "svg-load()" statement`);
}
// parse url
const { url, urlEnd } = getUrl(valueNode.nodes);
// parse params
const paramsNodes = valueNode.nodes.slice(urlEnd + 1);
const params =
urlEnd !== valueNode.nodes.length
? splitParams(getParamChunks(paramsNodes))
: {};
return {
url,
params,
valueNode,
parsedValue
};
}
function getInliner(parsedValue, valueNode) {
if (!valueNode.nodes.length) {
throw Error(`Invalid "svg-inline()" statement`);
}
const name = valueNode.nodes[0].value;
return {
name,
valueNode,
parsedValue
};
}
module.exports = function parseDeclValue(value) {
const loaders = [];
const inliners = [];
const parsedValue = valueParser(value);
parsedValue.walk(valueNode => {
if (valueNode.type === "function") {
if (valueNode.value === "svg-load") {
loaders.push(getLoader(parsedValue, valueNode));
} else if (valueNode.value === "svg-inline") {
inliners.push(getInliner(parsedValue, valueNode));
}
}
});
return {
loaders,
inliners
};
};

48
build/javascript/node_modules/postcss-inline-svg/lib/parseRule.js generated vendored
View File

@@ -1,48 +0,0 @@
const valueParser = require("postcss-value-parser");
function parseRuleDefinition(params) {
const { nodes } = valueParser(params);
if (
nodes.length !== 3 ||
nodes[0].type !== "word" ||
nodes[1].type !== "space" ||
nodes[2].type !== "function" ||
nodes[2].value !== "url" ||
nodes[2].nodes.length === 0
) {
throw Error('Invalid "@svg-load" definition');
}
return {
name: nodes[0].value,
url: nodes[2].nodes[0].value
};
}
function getRuleParams(rule) {
const params = {};
const selectors = {};
rule.each(node => {
if (node.type === "decl") {
params[node.prop] = node.value;
} else if (node.type === "rule") {
const selector = selectors[node.selectors] || {};
node.each(child => {
if (child.type === "decl") {
selector[child.prop] = child.value;
}
});
selectors[node.selectors] = selector;
}
});
return {
params,
selectors
};
}
module.exports = {
parseRuleDefinition,
getRuleParams
};

60
build/javascript/node_modules/postcss-inline-svg/lib/processors.js generated vendored
View File

@@ -1,60 +0,0 @@
const { selectOne, selectAll } = require("css-select");
function matchId(exp, id) {
return exp instanceof RegExp ? exp.test(id) : Boolean(exp);
}
function removeFillAttrib(element) {
delete element.attribs.fill;
}
function removeFill(id, opts) {
return dom => {
if (matchId(opts.removeFill, id)) {
selectAll("[fill]", dom).forEach(removeFillAttrib);
}
};
}
function removeStrokeAttrib(element) {
delete element.attribs.stroke;
}
function removeStroke(id, opts) {
return dom => {
if (matchId(opts.removeStroke, id)) {
selectAll("[stroke]", dom).forEach(removeStrokeAttrib);
}
};
}
function applyParams(params) {
return ({ attribs }) => {
Object.keys(params).forEach(name => {
attribs[name] = params[name];
});
};
}
function applyRootParams(params) {
return dom => {
applyParams(params)(selectOne("svg", dom));
};
}
function applySelectedParams(selectors) {
return dom => {
const svg = selectOne("svg", dom);
Object.keys(selectors).forEach(selector => {
selectAll(selector, svg).forEach(applyParams(selectors[selector]));
});
};
}
module.exports = {
removeFill,
removeStroke,
applyRootParams,
applySelectedParams
};

10
build/javascript/node_modules/postcss-inline-svg/lib/render.js generated vendored
View File

@@ -1,10 +0,0 @@
const { parseDOM } = require("htmlparser2");
const serialize = require("dom-serializer");
module.exports = function render(code, ...processors) {
const dom = parseDOM(code, { xmlMode: true });
processors.forEach(processor => processor(dom));
return serialize(dom);
};

24
build/javascript/node_modules/postcss-inline-svg/lib/resolveId.js generated vendored
View File

@@ -1,24 +0,0 @@
const { dirname, resolve } = require("path");
const { existsSync } = require("fs");
module.exports = function resolveId(file, url, opts) {
if (opts.paths && opts.paths.length) {
let absolutePath;
for (let path of opts.paths) {
absolutePath = resolve(path, url);
if (existsSync(absolutePath)) {
return absolutePath;
}
}
return absolutePath;
}
if (file) {
return resolve(dirname(file), url);
}
return resolve(url);
};