自新世界 #0x06：生活在 AST 上

type 
type Workspace = {
    userId: string;
    knowledgebaseId: string;
    name: string;
    exportDate: string;
    exportVersion: number;
    documentRemToExportId: string;
    docs: Doc[];
}Workspace = {
    userId: stringuserId: string;
    knowledgebaseId: stringknowledgebaseId: string;
    name: stringname: string;
    exportDate: stringexportDate: string;
    exportVersion: numberexportVersion: number;
    documentRemToExportId: stringdocumentRemToExportId: string;
    docs: Doc[]docs: type Doc = /*unresolved*/ anyDoc[];
}

type type RemTypes = "Daily Document" | "Document" | "Automatically Sort" | "Tags" | "Template Slot" | "Header" | "Website" | "Link" | "Quote" | "Image" | "Code" | "Card Item" | "List Item"RemTypes = "Daily Document"
| "Document"
| "Automatically Sort"
| "Tags"
| "Template Slot"
| "Header"
| "Website"
| "Link"
| "Quote"
| "Image"
| "Code"
| "Card Item"
| "List Item"

import { const unified: Processor<undefined, undefined, undefined, undefined, undefined>
Create a new processor.
@example  This example shows how a new processor can be created (from `remark`) and linked
  to **stdin**(4) and **stdout**(4).

  ```js
  import process from 'node:process'
  import concatStream from 'concat-stream'
  import {remark} from 'remark'

  process.stdin.pipe(
    concatStream(function (buf) {
      process.stdout.write(String(remark().processSync(buf)))
    })
  )
  ```@returns  New *unfrozen* processor (`processor`).

  This processor is configured to work the same as its ancestor.
  When the descendant processor is configured in the future it does not
  affect the ancestral processor.unified, type type Parser<Tree extends import("unist").Node = Node> = (document: string, file: VFile) => Tree
A **parser** handles the parsing of text to a syntax tree.

It is used in the parse phase and is called with a `string` and

{@linkcode 
VFile
}
 of the document to parse.
It must return the syntax tree representation of the given file
(
{@linkcode 
Node
}
).Parser } from "unified";
 
function function remParse(): voidremParse() {
  const const self: anyself = this;
 
  const self: anyself.parser = function (local function) parser(doc: string, file: unknown): anyparser as type Parser<Tree extends import("unist").Node = Node> = (document: string, file: VFile) => Tree
A **parser** handles the parsing of text to a syntax tree.

It is used in the parse phase and is called with a `string` and

{@linkcode 
VFile
}
 of the document to parse.
It must return the syntax tree representation of the given file
(
{@linkcode 
Node
}
).Parser;
 
  function function (local function) parser(doc: string, file: unknown): anyparser(doc: stringdoc: string, file: unknownfile: unknown) {
    return transformDoc(...);
  }
}
 
let let processor: anyprocessor = function unified(): Processor<undefined, undefined, undefined, undefined, undefined>
Create a new processor.
@example  This example shows how a new processor can be created (from `remark`) and linked
  to **stdin**(4) and **stdout**(4).

  ```js
  import process from 'node:process'
  import concatStream from 'concat-stream'
  import {remark} from 'remark'

  process.stdin.pipe(
    concatStream(function (buf) {
      process.stdout.write(String(remark().processSync(buf)))
    })
  )
  ```@returns  New *unfrozen* processor (`processor`).

  This processor is configured to work the same as its ancestor.
  When the descendant processor is configured in the future it does not
  affect the ancestral processor.unified().
    Processor<undefined, undefined, undefined, undefined, undefined>.use<[], undefined, undefined>(plugin: Plugin<[], undefined, undefined>, ...parameters: [] | [boolean]): Processor<undefined, undefined, undefined, undefined, undefined> (+2 overloads)
Configure the processor to use a plugin, a list of usable values, or a
preset.

If the processor is already using a plugin, the previous plugin
configuration is changed based on the options that are passed in.
In other words, the plugin is not added a second time.

> **Note**: `use` cannot be called on *frozen* processors.
> Call the processor first to create a new unfrozen processor.
@example  There are many ways to pass plugins to `.use()`.
  This example gives an overview:

  ```js
  import {unified} from 'unified'

  unified()
    // Plugin with options:
    .use(pluginA, {x: true, y: true})
    // Passing the same plugin again merges configuration (to `{x: true, y: false, z: true}`):
    .use(pluginA, {y: false, z: true})
    // Plugins:
    .use([pluginB, pluginC])
    // Two plugins, the second with options:
    .use([pluginD, [pluginE, {}]])
    // Preset with plugins and settings:
    .use({plugins: [pluginF, [pluginG, {}]], settings: {position: false}})
    // Settings only:
    .use({settings: {position: false}})
  ```@template{Array<unknown>} [Parameters=[]]@template{Node | string | undefined} [Input=undefined]@template[Output=Input]@overload@overload@overload@paramvalue Usable value.@paramparameters Parameters, when a plugin is given as a usable value.@returnsCurrent processor.use(function remParse(): voidremParse).
apply
arguments
bind
call
caller
compiler
data
freeze
length
name
parse
parser
process
processSync
prototype
run
runSync
stringify
toString
use
attachers
Compiler
copy
freezeIndex
frozen
namespace
Parser
transformers
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

type type NoneOf<S> = { [K in keyof S]?: undefined; }NoneOf<function (type parameter) S in type NoneOf<S>S> = {[function (type parameter) KK in keyof function (type parameter) S in type NoneOf<S>S]?: never};
 
type type AllOrNone<B, S> = (B & S) | (B & NoneOf<S>)AllOrNone<function (type parameter) B in type AllOrNone<B, S>B, function (type parameter) S in type AllOrNone<B, S>S> = function (type parameter) B in type AllOrNone<B, S>B & function (type parameter) S in type AllOrNone<B, S>S | function (type parameter) B in type AllOrNone<B, S>B & type NoneOf<S> = { [K in keyof S]?: undefined; }NoneOf<function (type parameter) S in type AllOrNone<B, S>S>;
 
/////////////
 
type 
type Base = {
    a: number;
    b: string;
}Base = {
    a: numbera: number,
    b: stringb: string,
}
 
type 
type FeatSet = {
    c: number;
    d: string;
}FeatSet = {
    c: numberc: number,
    d: stringd: string,
}
 
type type MyType = (Base & FeatSet) | (Base & NoneOf<FeatSet>)MyType = type AllOrNone<B, S> = (B & S) | (B & NoneOf<S>)AllOrNone<
type Base = {
    a: number;
    b: string;
}Base, 
type FeatSet = {
    c: number;
    d: string;
}FeatSet>
 
const const dataAll: MyTypedataAll: type MyType = (Base & FeatSet) | (Base & NoneOf<FeatSet>)MyType = {
    a: numbera: 1,
    b: stringb: "2",
    c: numberc: 3,
    d: stringd: "4"
}
 
const const dataNone: MyTypedataNone: type MyType = (Base & FeatSet) | (Base & NoneOf<FeatSet>)MyType = {
    a: numbera: 1,
    b: stringb: "2",
}
 
const dataPartial: type MyType = (Base & FeatSet) | (Base & NoneOf<FeatSet>)MyType = { // should throw
Type '{ a: number; b: string; c: number; }' is not assignable to type 'MyType'.
  Type '{ a: number; b: string; c: number; }' is not assignable to type 'Base & FeatSet'.
    Property 'd' is missing in type '{ a: number; b: string; c: number; }' but required in type 'FeatSet'.
    a: numbera: 1,
    b: stringb: "2",
    c: numberc: 3,
}
 
///////////
 
type type ExpandToAllOrNoneHelper<T, U> = U extends [infer F, ...infer R] ? ExpandToAllOrNoneHelper<AllOrNone<T, F>, R> : TExpandToAllOrNoneHelper<function (type parameter) T in type ExpandToAllOrNoneHelper<T, U>T, function (type parameter) U in type ExpandToAllOrNoneHelper<T, U>U> = function (type parameter) U in type ExpandToAllOrNoneHelper<T, U>U extends [infer function (type parameter) FF, ...infer function (type parameter) RR]
  ? type ExpandToAllOrNoneHelper<T, U> = U extends [infer F, ...infer R] ? ExpandToAllOrNoneHelper<AllOrNone<T, F>, R> : TExpandToAllOrNoneHelper<type AllOrNone<B, S> = (B & S) | (B & NoneOf<S>)AllOrNone<function (type parameter) T in type ExpandToAllOrNoneHelper<T, U>T, function (type parameter) FF>, function (type parameter) RR>
  : function (type parameter) T in type ExpandToAllOrNoneHelper<T, U>T;
 
type type AllOrNones<T, U extends any[]> = U extends [infer F, ...infer R] ? ExpandToAllOrNoneHelper<AllOrNone<T, F>, R> : TAllOrNones<function (type parameter) T in type AllOrNones<T, U extends any[]>T, function (type parameter) U in type AllOrNones<T, U extends any[]>U extends any[]> = type ExpandToAllOrNoneHelper<T, U> = U extends [infer F, ...infer R] ? ExpandToAllOrNoneHelper<AllOrNone<T, F>, R> : TExpandToAllOrNoneHelper<function (type parameter) T in type AllOrNones<T, U extends any[]>T, function (type parameter) U in type AllOrNones<T, U extends any[]>U>;
 
type 
type AnotherFeatSet = {
    e: boolean;
    f: "aaa" | "bbb";
}AnotherFeatSet = {
    e: booleane: boolean,
    f: "aaa" | "bbb"f: "aaa" | "bbb"
}
 
type type MyTypeB = (AllOrNone<Base, FeatSet> & AnotherFeatSet) | (AllOrNone<Base, FeatSet> & NoneOf<AnotherFeatSet>)MyTypeB = type AllOrNones<T, U extends any[]> = U extends [infer F, ...infer R] ? ExpandToAllOrNoneHelper<AllOrNone<T, F>, R> : TAllOrNones<
type Base = {
    a: number;
    b: string;
}Base, [
type FeatSet = {
    c: number;
    d: string;
}FeatSet, 
type AnotherFeatSet = {
    e: boolean;
    f: "aaa" | "bbb";
}AnotherFeatSet]>;
 
const const dataWithAnotherFeatSet: AllOrNone<AllOrNone<Base, FeatSet>, AnotherFeatSet>dataWithAnotherFeatSet: type MyTypeB = (AllOrNone<Base, FeatSet> & AnotherFeatSet) | (AllOrNone<Base, FeatSet> & NoneOf<AnotherFeatSet>)MyTypeB = {
    a: numbera: 11.4,
    b: stringb: "514",
    e: booleane: true,
    f: "aaa" | "bbb"f: "aaa"
}
 
const dataWithIncompleteFeatSet: type MyTypeB = (AllOrNone<Base, FeatSet> & AnotherFeatSet) | (AllOrNone<Base, FeatSet> & NoneOf<AnotherFeatSet>)MyTypeB = { // should throw
Type '{ a: number; b: string; f: "aaa"; }' is not assignable to type 'AllOrNone<AllOrNone<Base, FeatSet>, AnotherFeatSet>'.
  Type '{ a: number; b: string; f: "aaa"; }' is not assignable to type '(Base & FeatSet & AnotherFeatSet) | (Base & NoneOf<FeatSet> & AnotherFeatSet)'.
    Type '{ a: number; b: string; f: "aaa"; }' is not assignable to type 'Base & NoneOf<FeatSet> & AnotherFeatSet'.
      Property 'e' is missing in type '{ a: number; b: string; f: "aaa"; }' but required in type 'AnotherFeatSet'.
    a: numbera: 11.4,
    b: stringb: "514",
    f: "aaa" | "bbb"f: "aaa",
}
 
const const dataWithIncompatibleFeatSet: AllOrNone<AllOrNone<Base, FeatSet>, AnotherFeatSet>dataWithIncompatibleFeatSet: type MyTypeB = (AllOrNone<Base, FeatSet> & AnotherFeatSet) | (AllOrNone<Base, FeatSet> & NoneOf<AnotherFeatSet>)MyTypeB = {
    a: numbera: 11.4,
    b: stringb: "514",
    e: truee: true,
    f: "233", // should throw
Type '"233"' is not assignable to type '"aaa" | "bbb" | undefined'.
}

---
const r = `<span class="text-red-600">紅色</span>`;
const y = 'PHNwYW4gY2xhc3M9InRleHQteWVsbG93LTYwMCI+eWVsbG93PC9zcGFuPg==';
---
<div set:html={r} />
<div set:html={atob(y)} />
<div class="text-blue-600">藍色</div>

import { function createGenerator<Theme extends object = object>(config?: UserConfig<Theme>, defaults?: UserConfigDefaults<Theme>): UnoGenerator<Theme>createGenerator } from "unocss";
import import unoConfigunoConfig from "uno.config"; // 匯入當前專案的 UnoCSS 配置
 
export async function function generateUno(content: string, layer?: string): Promise<string | undefined>
Generate UnoCSS style from HTML string
@paramcontent HTML string@returnsCSS stringgenerateUno(content: string
HTML string
@paramcontent HTML stringcontent: string, layer: stringlayer: string = 'default') {
  const const generator: UnoGenerator<object>generator = createGenerator<object>(config?: UserConfig<object> | undefined, defaults?: UserConfigDefaults<object> | undefined): UnoGenerator<object>createGenerator(import unoConfigunoConfig);
  const const style: GenerateResult<Set<string>>style = await const generator: UnoGenerator<object>generator.UnoGenerator<object>.generate(input: string | Set<string> | CountableSet<string> | string[], options?: GenerateOptions<false>): Promise<GenerateResult<Set<string>>> (+1 overload)generate(content: string
HTML string
@paramcontent HTML stringcontent);
  // 返回的內容為不同 layer 的 CSS 字串，這裡我們只用到了 default layer
  return const style: GenerateResult<Set<string>>style.GenerateResult<Set<string>>.getLayer: (name?: string) => string | undefinedgetLayer(layer: stringlayer);
}