nuxt-ignis 0.5.1 → 0.5.3

package/.output/server/node_modules/truncatise/index.js

@@ -1,188 +0,0 @@
-(function(exportTo) {
-    "use strict";
-
-    var selfClosingTags = ["area", "base", "br", "col", "embed", "hr", "img", "input", "keygen", "link", "menuitem", "meta", "param", "source", "track", "wbr"];
-
-    /**
-     * Truncates a given HTML string to the specified length.
-     * @param {string} text This is the HTMl string to be truncated
-     * @param {object} options An options object defining how to truncate
-     *      Default values:
-     *      {
-     *          TruncateBy : 'words',   // Options are 'words', 'characters' or 'paragraphs'
-     *          TruncateLength : 50,    // The count to be used with TruncatedBy
-     *          StripHTML : false,      // Whether or not the truncated text should contain HTML tags
-     *          Strict : true,          // When set to false the truncated text finish at the end of the word
-     *          Suffix : '...'          // Text to be appended to the end of the truncated text
-     *      }
-     * @return {string} This returns the provided string truncated to the
-     *      length provided by the options. HTML tags may be stripped based
-     *      on the given options.
-     */
-    var truncatise = function(text,options) {
-        var options         = options || {},
-            text            = (text || "").trim(),
-            truncatedText   = "",
-            currentState    = 0,
-            isEndOfWord     = false,
-            isTagOpen       = false,
-            currentTag      = "",
-            tagStack        = [],
-            nextChar        = "";
-        //Counters
-        var charCounter         = 0,
-            wordCounter         = 0,
-            paragraphCounter    = 0;
-        //currentState values
-        var NOT_TAG         = 0,
-            TAG_START       = 1,
-            TAG_ATTRIBUTES  = 2;
-
-        //Set default values
-        options.TruncateBy      = (options.TruncateBy === undefined
-                                    || typeof options.TruncateBy !==  "string"
-                                    || !options.TruncateBy.match(/(word(s)?|character(s)?|paragraph(s)?)/))
-                                ? 'words'
-                                : options.TruncateBy.toLowerCase();
-        options.TruncateLength  = (options.TruncateLength === undefined
-                                    || typeof options.TruncateLength !== "number")
-                                ? 50
-                                : options.TruncateLength;
-        options.StripHTML       = (options.StripHTML === undefined
-                                    || typeof options.StripHTML !== "boolean")
-                                ? false
-                                : options.StripHTML;
-        options.Strict          = (options.Strict === undefined
-                                    || typeof options.Strict !== "boolean")
-                                ? true
-                                : options.Strict;
-        options.Suffix          = (options.Suffix === undefined
-                                    || typeof options.Suffix !== "string")
-                                ? '...'
-                                : options.Suffix;
-
-        if(text === "" || (text.length <= options.TruncateLength && options.StripHTML === false)){
-            return text;
-        }
-
-        if(options.StripHTML) {
-            text = String(text).replace(/<br( \/)?>/gi, ' ');
-        }
-
-        //If not splitting on paragraphs we can quickly remove tags using regex
-        if(options.StripHTML && !options.TruncateBy.match(/(paragraph(s)?)/)){
-            text = String(text).replace(/<!--(.*?)-->/gm, '').replace(/<\/?[^>]+>/gi, '');
-        }
-        //Remove newline seperating paragraphs
-        text = String(text).replace(/<\/p>(\r?\n)+<p>/gm, '</p><p>');
-        //Replace double newlines with paragraphs
-        if(options.StripHTML && String(text).match(/\r?\n\r?\n/)){
-            text = String(text).replace(/((.+)(\r?\n\r?\n|$))/gi, "<p>$2</p>");
-        }
-
-        for (var pointer = 0; pointer < text.length; pointer++ ) {
-
-            var currentChar = text[pointer];
-
-            switch(currentChar){
-                case "<":
-                    if(currentState === NOT_TAG){
-                        currentState = TAG_START;
-                        currentTag = "";
-                    }
-                    if(!options.StripHTML){
-                        truncatedText += currentChar;
-                    }
-                    break;
-                case ">":
-                    if(currentState === TAG_START || currentState === TAG_ATTRIBUTES){
-                        currentState = NOT_TAG;
-                        currentTag = currentTag.toLowerCase();
-                        if(currentTag === "/p"){
-                            paragraphCounter++;
-                            if(options.StripHTML){
-                                truncatedText += " ";
-                            }
-                        }
-
-                        // Ignore self-closing tags.
-                        if ((selfClosingTags.indexOf(currentTag) === -1) && (selfClosingTags.indexOf(currentTag + '/') === -1)) {
-                            if(currentTag.indexOf("/") >= 0){
-                                tagStack.pop();
-                            } else {
-                                tagStack.push(currentTag);
-                            }
-                        }
-                    }
-                    if(!options.StripHTML){
-                        truncatedText += currentChar;
-                    }
-                    break;
-                case " ":
-                    if(currentState === TAG_START){
-                        currentState = TAG_ATTRIBUTES;
-                    }
-                    if(currentState === NOT_TAG){
-                        wordCounter++;
-                        charCounter++;
-                    }
-                    if(currentState === NOT_TAG || !options.StripHTML){
-                        truncatedText += currentChar;
-                    }
-                    break;
-                default:
-                    if(currentState === NOT_TAG){
-                        charCounter++;
-                    }
-                    if(currentState === TAG_START){
-                        currentTag += currentChar;
-                    }
-                    if(currentState === NOT_TAG || !options.StripHTML){
-                        truncatedText += currentChar;
-                    }
-                    break;
-            }
-
-            nextChar = text[pointer + 1] || "";
-            isEndOfWord = options.Strict ? true : (!currentChar.match(/[a-zA-ZÇ-Ü']/i) || !nextChar.match(/[a-zA-ZÇ-Ü']/i));
-
-            if(options.TruncateBy.match(/word(s)?/i) && options.TruncateLength <= wordCounter){
-                truncatedText = truncatedText.replace(/\s+$/, '');
-                break;
-            }
-            if(options.TruncateBy.match(/character(s)?/i) && options.TruncateLength <= charCounter && isEndOfWord){
-                break;
-            }
-            if(options.TruncateBy.match(/paragraph(s)?/i) && options.TruncateLength === paragraphCounter){
-                break;
-            }
-        }
-
-        if(!options.StripHTML && tagStack.length > 0){
-            while(tagStack.length > 0){
-                var tag = tagStack.pop();
-                if(tag!=="!--"){
-                    truncatedText += "</"+tag+">";
-                }
-            }
-        }
-
-        if(pointer < text.length - 1) {
-          if(truncatedText.match(/<\/p>$/gi)){
-              truncatedText = truncatedText.replace(/(<\/p>)$/gi, options.Suffix + "$1");
-          }else{
-              truncatedText = truncatedText + options.Suffix;
-          }
-        }
-
-        return truncatedText.trim();
-    };
-
-    // Export to node
-    if (typeof module !== 'undefined' && module.exports){
-        return module.exports = truncatise;
-    }
-
-    // Nope, export to the browser instead.
-    exportTo.truncatise = truncatise;
-}(this));

package/.output/server/node_modules/truncatise/package.json

@@ -1,36 +0,0 @@
-{
-  "name": "truncatise",
-  "version": "0.0.8",
-  "description": "Truncate HTML based on characters, words or paragraphs. Has the ability to strip tags.",
-  "main": "index.js",
-  "scripts": {
-    "test": "mocha -R spec test.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/AverageMarcus/Truncatise"
-  },
-  "keywords": [
-    "text",
-    "truncate",
-    "truncatise",
-    "word",
-    "character",
-    "limit",
-    "html",
-    "tag",
-    "strip",
-    "paragraph",
-    "excerpt"
-  ],
-  "author": "Marcus Noble",
-  "license": "MIT",
-  "devDependencies": {
-    "chai": "~1.5.0",
-    "mocha": "~1.9.0"
-  },
-  "readmeFilename": "README.md",
-  "bugs": {
-    "url": "https://github.com/AverageMarcus/Truncatise/issues"
-  }
-}

package/.output/server/node_modules/unhead/dist/shared/unhead.BpRRHAhY.mjs

@@ -1,194 +0,0 @@
-import { U as UniqueTags, T as TagsWithInnerContent, M as MetaTagsArrayable, a as TagConfigKeys, D as DupeableTags } from './unhead.yem5I2v_.mjs';
-
-const allowedMetaProperties = ["name", "property", "http-equiv"];
-const StandardSingleMetaTags = /* @__PURE__ */ new Set([
-  "viewport",
-  "description",
-  "keywords",
-  "robots"
-]);
-function isMetaArrayDupeKey(v) {
-  const parts = v.split(":");
-  if (!parts.length)
-    return false;
-  return MetaTagsArrayable.has(parts[1]);
-}
-function dedupeKey(tag) {
-  const { props, tag: name } = tag;
-  if (UniqueTags.has(name))
-    return name;
-  if (name === "link" && props.rel === "canonical")
-    return "canonical";
-  if (props.charset)
-    return "charset";
-  if (tag.tag === "meta") {
-    for (const n of allowedMetaProperties) {
-      if (props[n] !== void 0) {
-        const propValue = props[n];
-        const isStructured = propValue.includes(":");
-        const isStandardSingle = StandardSingleMetaTags.has(propValue);
-        const shouldAlwaysDedupe = isStructured || isStandardSingle;
-        const keyPart = !shouldAlwaysDedupe && tag.key ? `:key:${tag.key}` : "";
-        return `${name}:${propValue}${keyPart}`;
-      }
-    }
-  }
-  if (tag.key) {
-    return `${name}:key:${tag.key}`;
-  }
-  if (props.id) {
-    return `${name}:id:${props.id}`;
-  }
-  if (TagsWithInnerContent.has(name)) {
-    const v = tag.textContent || tag.innerHTML;
-    if (v) {
-      return `${name}:content:${v}`;
-    }
-  }
-}
-function hashTag(tag) {
-  const dedupe = tag._h || tag._d;
-  if (dedupe)
-    return dedupe;
-  const inner = tag.textContent || tag.innerHTML;
-  if (inner)
-    return inner;
-  return `${tag.tag}:${Object.entries(tag.props).map(([k, v]) => `${k}:${String(v)}`).join(",")}`;
-}
-
-function walkResolver(val, resolve, key) {
-  const type = typeof val;
-  if (type === "function") {
-    if (!key || key !== "titleTemplate" && !(key[0] === "o" && key[1] === "n")) {
-      val = val();
-    }
-  }
-  let v;
-  if (resolve) {
-    v = resolve(key, val);
-  }
-  if (Array.isArray(v)) {
-    return v.map((r) => walkResolver(r, resolve));
-  }
-  if (v?.constructor === Object) {
-    const next = {};
-    for (const key2 of Object.keys(v)) {
-      next[key2] = walkResolver(v[key2], resolve, key2);
-    }
-    return next;
-  }
-  return v;
-}
-
-function normalizeStyleClassProps(key, value) {
-  const store = key === "style" ? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Set();
-  function processValue(rawValue) {
-    const value2 = rawValue.trim();
-    if (!value2)
-      return;
-    if (key === "style") {
-      const [k, ...v] = value2.split(":").map((s) => s.trim());
-      if (k && v.length)
-        store.set(k, v.join(":"));
-    } else {
-      value2.split(" ").filter(Boolean).forEach((c) => store.add(c));
-    }
-  }
-  if (typeof value === "string") {
-    key === "style" ? value.split(";").forEach(processValue) : processValue(value);
-  } else if (Array.isArray(value)) {
-    value.forEach((item) => processValue(item));
-  } else if (value && typeof value === "object") {
-    Object.entries(value).forEach(([k, v]) => {
-      if (v && v !== "false") {
-        key === "style" ? store.set(k.trim(), v) : processValue(k);
-      }
-    });
-  }
-  return store;
-}
-function normalizeProps(tag, input) {
-  tag.props = tag.props || {};
-  if (!input) {
-    return tag;
-  }
-  if (tag.tag === "templateParams") {
-    tag.props = input;
-    return tag;
-  }
-  Object.entries(input).forEach(([key, value]) => {
-    if (value === null) {
-      tag.props[key] = null;
-      return;
-    }
-    if (key === "class" || key === "style") {
-      tag.props[key] = normalizeStyleClassProps(key, value);
-      return;
-    }
-    if (TagConfigKeys.has(key)) {
-      if (["textContent", "innerHTML"].includes(key) && typeof value === "object") {
-        let type = input.type;
-        if (!input.type) {
-          type = "application/json";
-        }
-        if (!type?.endsWith("json") && type !== "speculationrules") {
-          return;
-        }
-        input.type = type;
-        tag.props.type = type;
-        tag[key] = JSON.stringify(value);
-      } else {
-        tag[key] = value;
-      }
-      return;
-    }
-    const strValue = String(value);
-    const isDataKey = key.startsWith("data-");
-    if (strValue === "true" || strValue === "") {
-      tag.props[key] = isDataKey ? strValue : true;
-    } else if (!value && isDataKey && strValue === "false") {
-      tag.props[key] = "false";
-    } else if (value !== void 0) {
-      tag.props[key] = value;
-    }
-  });
-  return tag;
-}
-function normalizeTag(tagName, _input) {
-  const input = typeof _input === "object" && typeof _input !== "function" ? _input : { [tagName === "script" || tagName === "noscript" || tagName === "style" ? "innerHTML" : "textContent"]: _input };
-  const tag = normalizeProps({ tag: tagName, props: {} }, input);
-  if (tag.key && DupeableTags.has(tag.tag)) {
-    tag.props["data-hid"] = tag._h = tag.key;
-  }
-  if (tag.tag === "script" && typeof tag.innerHTML === "object") {
-    tag.innerHTML = JSON.stringify(tag.innerHTML);
-    tag.props.type = tag.props.type || "application/json";
-  }
-  return Array.isArray(tag.props.content) ? tag.props.content.map((v) => ({ ...tag, props: { ...tag.props, content: v } })) : tag;
-}
-function normalizeEntryToTags(input, propResolvers) {
-  if (!input) {
-    return [];
-  }
-  if (typeof input === "function") {
-    input = input();
-  }
-  const resolvers = (key, val) => {
-    for (let i = 0; i < propResolvers.length; i++) {
-      val = propResolvers[i](key, val);
-    }
-    return val;
-  };
-  input = resolvers(void 0, input);
-  const tags = [];
-  input = walkResolver(input, resolvers);
-  Object.entries(input || {}).forEach(([key, value]) => {
-    if (value === void 0)
-      return;
-    for (const v of Array.isArray(value) ? value : [value])
-      tags.push(normalizeTag(key, v));
-  });
-  return tags.flat();
-}
-
-export { normalizeProps as a, dedupeKey as d, hashTag as h, isMetaArrayDupeKey as i, normalizeEntryToTags as n, walkResolver as w };

package/.output/server/node_modules/unhead/dist/shared/unhead.DH45uomy.mjs

@@ -1,180 +0,0 @@
-import { createHooks } from 'hookable';
-import { n as normalizeEntryToTags, d as dedupeKey, i as isMetaArrayDupeKey } from './unhead.BpRRHAhY.mjs';
-import { t as tagWeight, s as sortTags } from './unhead.DZbvapt-.mjs';
-import { c as UsesMergeStrategy, V as ValidHeadTags } from './unhead.yem5I2v_.mjs';
-
-function registerPlugin(head, p) {
-  const plugin = typeof p === "function" ? p(head) : p;
-  const key = plugin.key || String(head.plugins.size + 1);
-  const exists = head.plugins.get(key);
-  if (!exists) {
-    head.plugins.set(key, plugin);
-    head.hooks.addHooks(plugin.hooks || {});
-  }
-}
-// @__NO_SIDE_EFFECTS__
-function createHeadCore(resolvedOptions = {}) {
-  return /* @__PURE__ */ createUnhead(resolvedOptions);
-}
-// @__NO_SIDE_EFFECTS__
-function createUnhead(resolvedOptions = {}) {
-  const hooks = createHooks();
-  hooks.addHooks(resolvedOptions.hooks || {});
-  const ssr = !resolvedOptions.document;
-  const entries = /* @__PURE__ */ new Map();
-  const plugins = /* @__PURE__ */ new Map();
-  const normalizeQueue = /* @__PURE__ */ new Set();
-  const head = {
-    _entryCount: 1,
-    // 0 is reserved for internal use
-    plugins,
-    dirty: false,
-    resolvedOptions,
-    hooks,
-    ssr,
-    entries,
-    headEntries() {
-      return [...entries.values()];
-    },
-    use: (p) => registerPlugin(head, p),
-    push(input, _options) {
-      const options = { ..._options || {} };
-      delete options.head;
-      const _i = options._index ?? head._entryCount++;
-      const inst = { _i, input, options };
-      const _ = {
-        _poll(rm = false) {
-          head.dirty = true;
-          !rm && normalizeQueue.add(_i);
-          hooks.callHook("entries:updated", head);
-        },
-        dispose() {
-          if (entries.delete(_i)) {
-            head.invalidate();
-          }
-        },
-        // a patch is the same as creating a new entry, just a nice DX
-        patch(input2) {
-          if (!options.mode || options.mode === "server" && ssr || options.mode === "client" && !ssr) {
-            inst.input = input2;
-            entries.set(_i, inst);
-            _._poll();
-          }
-        }
-      };
-      _.patch(input);
-      return _;
-    },
-    async resolveTags() {
-      const ctx = {
-        tagMap: /* @__PURE__ */ new Map(),
-        tags: [],
-        entries: [...head.entries.values()]
-      };
-      await hooks.callHook("entries:resolve", ctx);
-      while (normalizeQueue.size) {
-        const i = normalizeQueue.values().next().value;
-        normalizeQueue.delete(i);
-        const e = entries.get(i);
-        if (e) {
-          const normalizeCtx = {
-            tags: normalizeEntryToTags(e.input, resolvedOptions.propResolvers || []).map((t) => Object.assign(t, e.options)),
-            entry: e
-          };
-          await hooks.callHook("entries:normalize", normalizeCtx);
-          e._tags = normalizeCtx.tags.map((t, i2) => {
-            t._w = tagWeight(head, t);
-            t._p = (e._i << 10) + i2;
-            t._d = dedupeKey(t);
-            return t;
-          });
-        }
-      }
-      let hasFlatMeta = false;
-      ctx.entries.flatMap((e) => (e._tags || []).map((t) => ({ ...t, props: { ...t.props } }))).sort(sortTags).reduce((acc, next) => {
-        const k = String(next._d || next._p);
-        if (!acc.has(k))
-          return acc.set(k, next);
-        const prev = acc.get(k);
-        const strategy = next?.tagDuplicateStrategy || (UsesMergeStrategy.has(next.tag) ? "merge" : null) || (next.key && next.key === prev.key ? "merge" : null);
-        if (strategy === "merge") {
-          const newProps = { ...prev.props };
-          Object.entries(next.props).forEach(([p, v]) => (
-            // @ts-expect-error untyped
-            newProps[p] = p === "style" ? new Map([...prev.props.style || /* @__PURE__ */ new Map(), ...v]) : p === "class" ? /* @__PURE__ */ new Set([...prev.props.class || /* @__PURE__ */ new Set(), ...v]) : v
-          ));
-          acc.set(k, { ...next, props: newProps });
-        } else if (next._p >> 10 === prev._p >> 10 && next.tag === "meta" && isMetaArrayDupeKey(k)) {
-          acc.set(k, Object.assign([...Array.isArray(prev) ? prev : [prev], next], next));
-          hasFlatMeta = true;
-        } else if (next._w === prev._w ? next._p > prev._p : next?._w < prev?._w) {
-          acc.set(k, next);
-        }
-        return acc;
-      }, ctx.tagMap);
-      const title = ctx.tagMap.get("title");
-      const titleTemplate = ctx.tagMap.get("titleTemplate");
-      head._title = title?.textContent;
-      if (titleTemplate) {
-        const titleTemplateFn = titleTemplate?.textContent;
-        head._titleTemplate = titleTemplateFn;
-        if (titleTemplateFn) {
-          let newTitle = typeof titleTemplateFn === "function" ? titleTemplateFn(title?.textContent) : titleTemplateFn;
-          if (typeof newTitle === "string" && !head.plugins.has("template-params")) {
-            newTitle = newTitle.replace("%s", title?.textContent || "");
-          }
-          if (title) {
-            newTitle === null ? ctx.tagMap.delete("title") : ctx.tagMap.set("title", { ...title, textContent: newTitle });
-          } else {
-            titleTemplate.tag = "title";
-            titleTemplate.textContent = newTitle;
-          }
-        }
-      }
-      ctx.tags = Array.from(ctx.tagMap.values());
-      if (hasFlatMeta) {
-        ctx.tags = ctx.tags.flat().sort(sortTags);
-      }
-      await hooks.callHook("tags:beforeResolve", ctx);
-      await hooks.callHook("tags:resolve", ctx);
-      await hooks.callHook("tags:afterResolve", ctx);
-      const finalTags = [];
-      for (const t of ctx.tags) {
-        const { innerHTML, tag, props } = t;
-        if (!ValidHeadTags.has(tag)) {
-          continue;
-        }
-        if (Object.keys(props).length === 0 && !t.innerHTML && !t.textContent) {
-          continue;
-        }
-        if (tag === "meta" && !props.content && !props["http-equiv"] && !props.charset) {
-          continue;
-        }
-        if (tag === "script" && innerHTML) {
-          if (props.type?.endsWith("json")) {
-            const v = typeof innerHTML === "string" ? innerHTML : JSON.stringify(innerHTML);
-            t.innerHTML = v.replace(/</g, "\\u003C");
-          } else if (typeof innerHTML === "string") {
-            t.innerHTML = innerHTML.replace(new RegExp(`</${tag}`, "g"), `<\\/${tag}`);
-          }
-          t._d = dedupeKey(t);
-        }
-        finalTags.push(t);
-      }
-      return finalTags;
-    },
-    invalidate() {
-      for (const entry of entries.values()) {
-        normalizeQueue.add(entry._i);
-      }
-      head.dirty = true;
-      hooks.callHook("entries:updated", head);
-    }
-  };
-  (resolvedOptions?.plugins || []).forEach((p) => registerPlugin(head, p));
-  head.hooks.callHook("init", head);
-  resolvedOptions.init?.forEach((e) => e && head.push(e));
-  return head;
-}
-
-export { createUnhead as a, createHeadCore as c };

package/.output/server/node_modules/unhead/dist/shared/unhead.DZbvapt-.mjs

@@ -1,70 +0,0 @@
-const sortTags = (a, b) => a._w === b._w ? a._p - b._p : a._w - b._w;
-const TAG_WEIGHTS = {
-  base: -10,
-  title: 10
-};
-const TAG_ALIASES = {
-  critical: -8,
-  high: -1,
-  low: 2
-};
-const WEIGHT_MAP = {
-  meta: {
-    "content-security-policy": -30,
-    "charset": -20,
-    "viewport": -15
-  },
-  link: {
-    "preconnect": 20,
-    "stylesheet": 60,
-    "preload": 70,
-    "modulepreload": 70,
-    "prefetch": 90,
-    "dns-prefetch": 90,
-    "prerender": 90
-  },
-  script: {
-    async: 30,
-    defer: 80,
-    sync: 50
-  },
-  style: {
-    imported: 40,
-    sync: 60
-  }
-};
-const ImportStyleRe = /@import/;
-const isTruthy = (val) => val === "" || val === true;
-function tagWeight(head, tag) {
-  if (typeof tag.tagPriority === "number")
-    return tag.tagPriority;
-  let weight = 100;
-  const offset = TAG_ALIASES[tag.tagPriority] || 0;
-  const weightMap = head.resolvedOptions.disableCapoSorting ? {
-    link: {},
-    script: {},
-    style: {}
-  } : WEIGHT_MAP;
-  if (tag.tag in TAG_WEIGHTS) {
-    weight = TAG_WEIGHTS[tag.tag];
-  } else if (tag.tag === "meta") {
-    const metaType = tag.props["http-equiv"] === "content-security-policy" ? "content-security-policy" : tag.props.charset ? "charset" : tag.props.name === "viewport" ? "viewport" : null;
-    if (metaType)
-      weight = WEIGHT_MAP.meta[metaType];
-  } else if (tag.tag === "link" && tag.props.rel) {
-    weight = weightMap.link[tag.props.rel];
-  } else if (tag.tag === "script") {
-    if (isTruthy(tag.props.async)) {
-      weight = weightMap.script.async;
-    } else if (tag.props.src && !isTruthy(tag.props.defer) && !isTruthy(tag.props.async) && tag.props.type !== "module" && !tag.props.type?.endsWith("json")) {
-      weight = weightMap.script.sync;
-    } else if (isTruthy(tag.props.defer) && tag.props.src && !isTruthy(tag.props.async)) {
-      weight = weightMap.script.defer;
-    }
-  } else if (tag.tag === "style") {
-    weight = tag.innerHTML && ImportStyleRe.test(tag.innerHTML) ? weightMap.style.imported : weightMap.style.sync;
-  }
-  return (weight || 100) + offset;
-}
-
-export { sortTags as s, tagWeight as t };